/start

description: Start session - restore context, show tasks, select work item
argument-hint: "[task-id|--continue|--main]"

Session Start

Restore context and prepare for work. **User MUST select a task before working.**

> **LETS Notice — surface it.** If a `## LETS Notice` block is present in the injected context (a one-time message the SessionStart hook emits — e.g. workflow rules outdated/missing, a migration result), it MUST be the **first line of your output** for `/lets:start` (`⚠️ <notice text>`), before the session summary. Don't omit it — it tells the user a `/lets:update` or `/lets:init` is needed. Mention it once, then continue with the steps below; don't repeat it in later turns.

Usage

/lets:start                # Full flow - show history, tasks, select work
/lets:start <task-id>      # Quick start - jump to specific task
/lets:start --continue     # Resume last in_progress task with session context
/lets:start --main         # Project-assistant / PM mode - no task, read + triage on merge-branch
/lets:start --assistant    # Alias of --main

Step 0: Argument Parsing

**If `<task-id>` provided** (e.g., `/lets:start lets-rmcwo`):

• Skip Steps 1, 3, 5 (session history, orient, task selection)
• Run Step 2 (git state) briefly
• the tracker's `show` + `comment-list` for `<task-id>` — read the FULL description and ALL comments, never truncate
• Jump to Step 6 (branch) with this task

**If `--continue`:**

• Run Step 1 (session history) - important for context recovery
• Run Step 2 (git state) briefly
• the tracker's `list-by-status` (in_progress) - find task(s)
• If exactly 1 in_progress -> use it. **Skip Step 3 (orient) and Step 5** - the task is already known, so the Next up / Project snapshot is noise (and it would re-run `list-by-status` a second time inside orient). Present only the `## Recent Sessions` recovery line (Step 4), then jump to Step 6 (take-task) - its Step 6 context recovery reads the task comments + latest snapshot
• If multiple -> run Step 3 (orient) and show selection with context from recent sessions
• If none -> fall through to full flow

**If `--main` or `--assistant` provided** (project-assistant / PM mode):

• Deliberate **NO-TASK** session stance. Do NOT select, claim, or auto-create a task.
• **Precedence:** mutually exclusive with `<task-id>` and `--continue`. If an explicit task-id or `--continue` is ALSO present, the explicit task **wins** (run the normal task flow) and `--main` is ignored - tell the user it was dropped because a task was specified.
• **Skip** Step 5 (Task Selection), Step 6 (Take Task), Step 8 (Task Size Assessment) - all task-bound.
• **Run** Step 1 (session history), Step 2 (git state). The orient snapshot is rendered once by Main Mode M1 (below), AFTER the session-boundary write - do NOT also run Step 3 (that would render orient twice).
• Then go to `## Main Mode` (below) instead of Steps 4-9.

**If no arguments** -> full flow (Steps 1-9 as below)

Step 1: Previous Session Context

LETS_PROJECT_ROOT=$(git rev-parse --show-toplevel)
BRANCH=$(git branch --show-current)
BRANCH_SLUG=$(echo "$BRANCH" | tr '/' '-')
mkdir -p "$LETS_PROJECT_ROOT/.lets/sessions"

# Read last 3 snapshots: task-id-named first (artifact-path naming, lets-05c4s), then the branch
# slug (legacy {TS}-{branch}.md AND taskless {branch}-{hex}-snapshot), then any branch.
TASK_ID=$(sed -n 's/^task: //p' "$LETS_PROJECT_ROOT/.lets/sessions/.task-${BRANCH_SLUG}" 2>/dev/null | head -1)
SESSIONS=""
[ -n "$TASK_ID" ] && SESSIONS=$(ls -t "$LETS_PROJECT_ROOT/.lets/sessions/"*"-${TASK_ID}-snapshot"*.md 2>/dev/null | head -3)
[ -z "$SESSIONS" ] && SESSIONS=$(ls -t "$LETS_PROJECT_ROOT/.lets/sessions/"*"-${BRANCH_SLUG}"*.md 2>/dev/null | head -3)
[ -z "$SESSIONS" ] && SESSIONS=$(ls -t "$LETS_PROJECT_ROOT/.lets/sessions/"*.md 2>/dev/null | head -3)

**Read EACH session file** found above using the Read tool (up to 3 files in parallel). Then present a compact summary of all sessions. Focus on: what was done, key decisions, next steps suggested.

Step 2: Git State

git branch --show-current
git status --short
if git rev-parse --verify --quiet HEAD >/dev/null; then
  git log --oneline -3
else
  echo "(no commits yet — fresh repo)"
fi

# Unfinished PR-review restore. /lets:review keys its record by session id, so the session that
# could act on it is gone - a fresh session is exactly where a stray must be surfaced.
LETS_PROJECT_ROOT=$(git rev-parse --show-toplevel)
for f in "$LETS_PROJECT_ROOT"/.lets/sessions/.review-restore-*; do
  [ -e "$f" ] || continue
  printf 'STRAY REVIEW RESTORE %s -> ref: %s | pr: %s | stash: %s\n' "${f##*/}" \
    "$(sed -n 's/^ref: //p' "$f" | head -1)" \
    "$(sed -n 's/^pr: //p' "$f" | head -1)" \
    "$(sed -n 's/^stash: //p' "$f" | head -1)"
done

Report: branch, uncommitted changes, recent commits. **On a `STRAY REVIEW RESTORE` line**, tell the user in one line: a PR review did not finish restoring, `git checkout <ref>` returns them, and a listed `stash:` is still in `git stash list`. Report only - never act: `.lets/` is shared by every worktree of this repo, so the stray may belong to a session that is still running. **If the repo has no commits yet** (the `else` branch above fires), that's fine — say so in plain text; offer `git commit --allow-empty -m "chore: initial setup"` if the user wants an anchor for `git log` to work later. **Don't** raise `/lets:init` here (it's a separate concern) and **don't** treat the missing HEAD as a fatal error.

Step 3: Orient

Invoke `Skill(skill: "lets:orient")` - it renders Where you are / In flight / Next up (and the Project counts if the tracker provides them). This is the same snapshot `/lets:status` shows; start reuses it, then drives task selection below.

Step 4: Present

The orient snapshot (Step 3) already shows In flight + Next up - don't repeat them. Present the recovery line, then the snapshot:

## Recent Sessions
{1-2 line recovery from