/start

description: Start session - restore context, show tasks, select work item
argument-hint: '[task-id|--continue|--main|--assistant] [--scope "<part>"] [--orc=<name>]'

Session Start

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

> **IMPORTANT:** If the spec below invokes any deferred tool (e.g. `AskUserQuestion`), you MUST load and call it as specified. Never skip the call, never substitute a default answer of your own — the tool invocation is part of the contract. This is critical.

> **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
/lets:start --solo         # Team lead: start lean - read the team notebook, respawn no members

Step 0: Argument Parsing

Step 0a: Parse

Parse the arguments only - a task id (it goes through the detect-task id gate before any use), `--continue`, `--main` / `--assistant`, `--scope "<text>"` (main mode: the part of the repo this orchestrator owns), `--solo` (a team lead starts lean: Step 4T respawns no member; dropped silently outside a team worktree - on the dispatch commands `--solo` turns team mode off for one run, here it only skips the respawn). `--orc` is stripped per the detect-task explicit-argument convention before the task-id test and forwarded to take-task; with `--main` it is dropped with a one-line note (an orchestrator is never bound). No tracker verb runs here. Every path below runs **Step 0.5 first**, then its own steps.

**`--orc` without a task id** (not `--main` - e.g. the lead `/lets:team create` launched with `'/lets:start --orc="<name>"'`): after Step 0.5, record the binding on the current branch right away, single-quoting the name (`'\''` for a quote inside it) - the same call detect-task uses for an in-progress task:

command -v lets >/dev/null 2>&1 && lets worktree task-state set --create --orc '<name>' --json

So a `team_<c>` lead is a bound row of its orchestrator's `lets peers who --orc` from launch, and `lets worktree switch` carries that `orc:` to every task branch it moves to. `written=false` (`orc_on_merge_branch` on the merge-branch) or a refused name -> one line, nothing else changes; no binary -> say nothing. A task picked later still goes to take-task with the same `orc="<name>"`.

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

• Step 0.5 (with `--task '<task-id>'`), then:
• 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
• Step 4T (team worktree only), then Step 5.5, then Step 6 (branch) with this task

**If `--continue`:**

• Step 0.5, then:
• 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 Step 4T (team worktree only), Step 5.5, then Step 6 (take-task) - its Step 6 context recovery reads the task comments + latest snapshot
• If multiple -> run Step 3 (orient), Step 4T (team worktree only), and show selection with context from recent sessions; then Step 5.5 with the pick
• If none -> fall through to full flow

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

• Step 0.5, then:
• 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), Step 4T (team worktree only: the notebook and the table, no respawn). 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** -> Step 0.5, then the full flow (Steps 1-9 as below)

Step 0.5: Link an unlinked worktree (fallback self-heal)

Runs on every path BEFORE any `show` / `comment-list` / `list-by-status`. The SessionStart hook normally adopts a worktree someone else created (Orca, a teammate) before this session's LETS Config is built; this is the fallback for a session whose hook could not (a `lets` binary older than the self-heal, a disabled hook). `{TASK_FLAG}` is `--task '<task-id>'` when an explicit id was given (after the id gate), else empty:

LETS_PROJECT_ROOT=$(git rev-parse --show-toplevel)
# Absolute on both sides: from a subdirectory of the main checkout --git-dir is absolute and
# --git-common-dir relative, so a plain comparison would "find" a worktree there.
if [ "$(git rev-parse --path-format=absolut