diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index ed4b283..fef4d04 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -18,7 +18,7 @@
       "name": "work-system",
       "source": "./plugins/work-system",
       "description": "Generic task and worktree workflow system for Claude Code. Manage tasks as markdown files, run them in isolated git worktrees with a choice of worker agent (Claude, codex, or grok), and track progress across the define/kickoff/continue/status/close lifecycle.",
-      "version": "1.9.2"
+      "version": "1.9.3"
     },
     {
       "name": "pr-flow",
diff --git a/.claude/knowledge/_index.md b/.claude/knowledge/_index.md
index 892c9ab..da9f191 100644
--- a/.claude/knowledge/_index.md
+++ b/.claude/knowledge/_index.md
@@ -12,7 +12,7 @@
 ## Features
 - `features/backfill-and-origin-metadata.md` — `/backfill-knowledge` significance bar + origin-reconstruction cascade
 - `features/statusline-integration.md` — Status-line segments: plugins can't own `statusLine.command`; marker-block injection; the `[ks …]` + `[ws …]` two-segment coexistence and ws's never-block-on-network PR cache
-- `features/herdr-kickoff-automation.md` — herdr `herdr-launch.sh`: `launch` (`/kickoff`) + `resume` (`/continue <task>` reopens an `/exit`-closed tab)
+- `features/herdr-kickoff-automation.md` — herdr `herdr-launch.sh`: `launch` (`/kickoff` + `/adopt`) + `resume` (`/continue <task>` reopens an `/exit`-closed tab)
 - `features/herdr-close-automation.md` — `/close` in herdr: cwd-tab teardown, plugin SessionEnd hook, the one TUI-exit primitive, detached self-exit onto idle
 - `features/herdr-tab-glyphs.md` — Task-state glyphs (`○ ● ◇ ◆ ✓`) + main-root `◉` on herdr tab labels: `states` mode in the self-contained renderer, sync-vs-`--cached` PR refresh per caller, exact-cwd rename rules, soft pr-flow shim
 - `features/kickoff-agent-selection.md` — `/kickoff` worker choice: single committed per-repo default (no global/fallback/ranking) else picker; `agent-registry.sh` as SoT; bounded model-aware grok probe (inconclusive→trust-auth); non-claude "document, don't fake" degradation; announce-not-prompt for external defaults
diff --git a/.claude/knowledge/features/herdr-kickoff-automation.md b/.claude/knowledge/features/herdr-kickoff-automation.md
index 9c184e3..6354514 100644
--- a/.claude/knowledge/features/herdr-kickoff-automation.md
+++ b/.claude/knowledge/features/herdr-kickoff-automation.md
@@ -1,10 +1,10 @@
 ---
 title: "herdr /kickoff + /continue-reopen Automation"
 createdAt: 2026-06-24
-updatedAt: 2026-07-21
+updatedAt: 2026-07-23
 createdFrom: "PR #17"
-updatedFrom: "session: 2026-07-21 (fully-qualify kickoff's /continue)"
-pluginVersion: 1.9.2
+updatedFrom: "session: 2026-07-23 (adopt auto-launch reuses launch)"
+pluginVersion: 1.9.3
 prime: false
 reindexedAt: 2026-07-12
 ---
@@ -14,7 +14,8 @@ reindexedAt: 2026-07-12
 Inside a herdr session, `/kickoff` replaces its manual "open a terminal yourself"
 block with an automated tab launch. The launch lives in one shared, testable
 helper — `plugins/work-system/scripts/herdr-launch.sh` — with two subcommands:
-`launch` (called from `skills/kickoff/SKILL.md` step 13) and `resume` (called from
+`launch` (called from **both** `skills/kickoff/SKILL.md` step 13 and
+`skills/adopt/SKILL.md` step 13 — see the adopt note below) and `resume` (called from
 `skills/continue/SKILL.md`'s reopen path — the main session with a `<task>` arg, or
 a *different* task's name given from inside a worktree). The helper is the source of
 truth; this entry captures the durable design and one non-obvious gotcha.
@@ -23,10 +24,10 @@ truth; this entry captures the durable design and one non-obvious gotcha.
 
 - **Encapsulate the launch in a script, not skill prose.** The deterministic
   sequence (gate → `agent start` → robust pane-id parse → `pane move` → exit code)
-  lives in `herdr-launch.sh` so it can be `bash`-tested and reused (e.g. by a
-  future `/adopt` automation), per the project's helper-script convention and the
-  "prose skill logic drifts" memory. The skill only derives the label and branches
-  on the helper's `moved=yes|no` / exit code.
+  lives in `herdr-launch.sh` so it can be `bash`-tested and reused — realized in
+  work-system 1.9.3 by `/adopt` (see the adopt note below) — per the project's
+  helper-script convention and the "prose skill logic drifts" memory. The skill only
+  derives the label and branches on the helper's `moved=yes|no` / exit code.
 - **Spawn the worker as argv, never type it into a shell.** The launch is
   `herdr agent start "<label>" … -- <worker argv>`, which execs the worker binary
   directly. As of work-system 1.9.0 the worker argv is **resolved from the chosen
@@ -113,6 +114,29 @@ truth; this entry captures the durable design and one non-obvious gotcha.
   in all of this — every case above, plus the stdout contract, as regression
   coverage the first round shipped without.
 
+## `/adopt` auto-launch: reference kickoff's prose, don't duplicate it
+
+work-system 1.9.3 gave `/adopt` the same in-herdr tab launch as `/kickoff`: after it
+builds the worktree from an existing branch, `skills/adopt/SKILL.md` step 13 calls the
+identical `herdr-launch.sh launch "$LABEL" "$WORKTREE" "$HERDR_WORKSPACE_ID" "$SELECTOR"`
+(step 12 resolves the worker selector exactly as kickoff does — `/adopt` grew an
+optional `[agent-selector]` arg for it). Two durable decisions:
+
+- **One copy of the intricate branching.** The launch *helper* is already the single
+  source of truth for the mechanics, but the *skill prose* around it (the picker/announce
+  rules of step 12, and the exit-0-`moved`/exit-2/exit-3/non-zero result branching of
+  step 13) is stateful logic that drifts if copied — the "prose skill logic drifts"
+  memory. So adopt's steps **reference** `kickoff/SKILL.md` step 12/13 for that shared
+  logic and inline only the adopt-specific deltas, rather than a full paraphrase that
+  would silently diverge under later edits.
+- **Adopt-specific deltas that must stay inline.** (1) The `LABEL` derives from the
+  *resolved* task name (prefix-stripped), because `/adopt` may **keep the original
+  branch name** rather than rename to `task/<name>` — deriving from the branch would
+  give a nonsense label. (2) The success/manual templates show `<current-branch-name>`
+  (the adopted branch, possibly not `task/<name>`), not kickoff's assumed `task/<name>`.
+  (3) The worktree path is built from the `<main-repo>` captured in adopt step 1, never a
+  possibly-drifted CWD (adopt runs in the main-repo session — its whole cwd-safety spine).
+
 ## `resume` mode: reopen a task tab a `/exit` closed
 
 A kickoff tab runs Claude as its **root pane** (argv-exec above), so a clean `/exit`
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b64ddb3..8ee49ba 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -52,6 +52,9 @@ entries are grouped per plugin, newest first.
 
 ## work-system
 
+### 1.9.3 — 2026-07-24
+- `/adopt` now auto-launches inside herdr, exactly like `/kickoff`: after it builds the worktree from an existing branch it opens the task's tab and starts the chosen worker there (outside herdr it prints the manual launch block unchanged). Reuses the shared `herdr-launch.sh launch` helper — no launch logic duplicated; the intricate result-branching and picker/announce rules stay a single source in `/kickoff`'s steps 12/13, which `/adopt` references. `/adopt` grew an optional `[agent-selector]` argument (`--fable`/`--opus`/`--sol`/`--grok`/`--codex`/`--agent <cli[:model]>`/`--pick`, same set as `/kickoff`); the branch is parsed position-independently from the selector. The tab label derives from the *resolved* task name, so it stays sensible when `/adopt` keeps the original branch name rather than renaming to `task/<name>`. READMEs and the `herdr-kickoff-automation` knowledge entry updated to cover both callers.
+
 ### 1.9.2 — 2026-07-21
 - Fix: `/kickoff`-launched Claude workers no longer run the wrong `/continue`. The machine-generated launch prompt is now the plugin-qualified `/work-system:continue`, not the bare `/continue` — a Claude Code built-in/alias `/continue` can shadow the plugin skill (and plugin skills are only *guaranteed* reachable via their `plugin:skill` namespace), so a freshly-launched worker was running CC's own resume (nothing to resume in a new worktree → idle, TASK.md never loaded) instead of the work-system resume flow. Changed at all machine-invocation sites: `agent-registry.sh` `emit_argv` (the selector path), `herdr-launch.sh`'s legacy no-selector fallback, kickoff's outside-herdr manual block, and the README launch examples; `test_agent_registry.py` asserts the qualified form. Human-typed reopen instructions (`/work-system:continue <task>`) updated to match. **Deployment note:** `agent-registry.sh` / `herdr-launch.sh` run from the *plugin cache*, not the repo, so live launches only pick up this fix after a `/plugin` marketplace update + reload refreshes the cache.
 
diff --git a/README.md b/README.md
index b82a330..b88e444 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ Lightweight, native knowledge management for Claude Code projects. Three layers
 
 ### Work System
 
-Generic task and worktree workflow system. Manage tasks as markdown files, work in isolated git worktrees, and track progress through the full lifecycle. `/kickoff` runs the repo's default worker agent (Claude, codex, or grok — a single committed per-project default), or, when none is set, shows a picker and offers to save your choice; override per run with flags like `--opus`/`--sol` or `--pick`. Inside a [herdr](plugins/work-system/README.md#herdr-integration) session it auto-opens a tab (named after the task, shortened for the sidebar and prefixed with the task's state glyph — `●` active, `◇` in review, `◆` approved, `✓` merged) with the worktree as cwd, starts the chosen worker, and — for a Claude worker — runs `/work-system:continue` for you (plugin-qualified, since a Claude Code built-in `/continue` shadows the bare skill); `/work-system:continue <task>` from the main session reopens that tab and resumes it if a stray `/exit` closed it; and `/close` tears the tab down again when the task is merged.
+Generic task and worktree workflow system. Manage tasks as markdown files, work in isolated git worktrees, and track progress through the full lifecycle. `/kickoff` runs the repo's default worker agent (Claude, codex, or grok — a single committed per-project default), or, when none is set, shows a picker and offers to save your choice; override per run with flags like `--opus`/`--sol` or `--pick`. Inside a [herdr](plugins/work-system/README.md#herdr-integration) session it auto-opens a tab (named after the task, shortened for the sidebar and prefixed with the task's state glyph — `●` active, `◇` in review, `◆` approved, `✓` merged) with the worktree as cwd, starts the chosen worker, and — for a Claude worker — runs `/work-system:continue` for you (plugin-qualified, since a Claude Code built-in `/continue` shadows the bare skill); `/adopt` auto-opens the same tab once it has built the worktree from an existing branch; `/work-system:continue <task>` from the main session reopens that tab and resumes it if a stray `/exit` closed it; and `/close` tears the tab down again when the task is merged.
 
 **Commands:** `/define`, `/kickoff`, `/adopt`, `/continue`, `/status`, `/close`, `/list`, `/statusline`
 
diff --git a/plugins/work-system/.claude-plugin/plugin.json b/plugins/work-system/.claude-plugin/plugin.json
index 677c9fb..a2ae250 100644
--- a/plugins/work-system/.claude-plugin/plugin.json
+++ b/plugins/work-system/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "work-system",
   "description": "Generic task and worktree workflow system for Claude Code. Manage tasks as markdown files, run them in isolated git worktrees with a choice of worker agent (Claude, codex, or grok), and track progress across the define/kickoff/continue/status/close lifecycle.",
-  "version": "1.9.2",
+  "version": "1.9.3",
   "author": {
     "name": "gering"
   },
diff --git a/plugins/work-system/README.md b/plugins/work-system/README.md
index b1b0735..4b6f15f 100644
--- a/plugins/work-system/README.md
+++ b/plugins/work-system/README.md
@@ -188,32 +188,37 @@ note into the worktree is an optional way to give them standing task guidance.
 ## herdr integration
 
 When you run the work system inside a **herdr** session (herdr is a terminal
-multiplexer for AI coding agents), `/kickoff` and `/close` automate the terminal
-juggling you'd otherwise do by hand — `/kickoff` opens the task's tab, `/close`
-tears it down. They activate when `HERDR_ENV=1`, a herdr workspace id is set, and
+multiplexer for AI coding agents), `/kickoff`, `/adopt`, and `/close` automate the
+terminal juggling you'd otherwise do by hand — `/kickoff` and `/adopt` open the
+task's tab, `/close` tears it down. They activate when `HERDR_ENV=1`, a herdr workspace id is set, and
 both `herdr` and `python3` are on `PATH`; if any prerequisite is missing or the
 socket is unreachable they fall back to the plain, herdr-free behaviour, so you're
 never left stranded. Outside herdr, every skill behaves exactly as documented above.
 
-### `/kickoff` opens a named tab
+### `/kickoff` and `/adopt` open a named tab
 
 Inside herdr, `/kickoff` doesn't just create the worktree and print manual
 instructions — it opens a new herdr **tab** in the *same* workspace, with the
-worktree as its cwd, and starts the task there for you:
+worktree as its cwd, and starts the task there for you. `/adopt` does exactly the
+same once it has created the worktree from an existing branch — same helper, same
+tab, same worker selection (`--opus`/`--sol`/`--grok`/`--pick`, or the repo default);
+its tab label comes from the *resolved* task name, so it's sensible even when `/adopt`
+keeps the original branch name rather than renaming it to `task/<name>`:
 
 - The tab is **named after the task** (shortened for a readable sidebar — see
   `skills/kickoff/SKILL.md` step 13 for the exact rule), so the sidebar shows one
   clear entry per task instead of a wall of identical agents. The same short label
-  names the herdr agent (and, for a claude worker, the `-n` session); the
-  underlying `task/<name>` branch is unchanged, so the resume flow still resolves
-  the task.
+  names the herdr agent (and, for a claude worker, the `-n` session); the task's
+  branch — `task/<name>` from `/kickoff`, or the original branch `/adopt` kept — is
+  unchanged, so the resume flow still resolves the task.
 - The chosen worker is launched directly as argv (`herdr agent start … --
   <resolved worker command>`), so the real CLI process is what herdr's agent-state
   detection sees. A claude worker gets `claude --model <m> -n "<label>" "/work-system:continue"`
   and loads the task context automatically; a codex/grok worker gets a bootstrap
   prompt (read `TASK.md`, drive the task to a PR) since they have no work-system skills.
-- The new tab opens in the background (`--no-focus`), so your kickoff session
-  stays in front; switch to the tab when you're ready to work there.
+- The new tab opens in the background (`--no-focus`), so the session you launched
+  from (`/kickoff` or `/adopt`, in the main repo) stays in front; switch to the tab
+  when you're ready to work there.
 
 ### `/close` tears down the task's tab
 
@@ -306,7 +311,10 @@ keep the plain label, since those are stable identities.
 Already started work on a branch outside the work system? Use `/adopt` to bring it in:
 
 ```
-> /adopt feature/dark-mode
+> /adopt feature/dark-mode              # repo default worker
+> /adopt feature/dark-mode --opus       # claude on opus
+> /adopt feature/dark-mode --sol        # codex on gpt-5.6-sol
+> /adopt feature/dark-mode --pick       # force the interactive picker
 ```
 
 This will:
@@ -314,6 +322,9 @@ This will:
 2. Generate a task file from that context
 3. Optionally rename the branch to `task/<name>` for consistency
 4. Create a worktree and set everything up
+5. Inside a [herdr](#herdr-integration) session, open the task's tab and start the
+   chosen worker there (same auto-launch as `/kickoff`); outside herdr it prints the
+   manual launch command instead
 
 After adoption, the standard workflow applies (`/continue`, `/status`, `/close`).
 
diff --git a/plugins/work-system/scripts/herdr-launch.sh b/plugins/work-system/scripts/herdr-launch.sh
index e155245..e92d16b 100755
--- a/plugins/work-system/scripts/herdr-launch.sh
+++ b/plugins/work-system/scripts/herdr-launch.sh
@@ -3,7 +3,7 @@
 #
 # Two modes share one precondition/JSON-parse/output contract:
 #
-#   launch  (/kickoff)  — spawn the chosen worker as ARGV via `agent start … --
+#   launch  (/kickoff, /adopt) — spawn the chosen worker as ARGV via `agent start … --
 #                         <worker-argv>`, then move it into its own background tab.
 #                         The worker is the tab's ROOT pane, so a later clean /exit
 #                         ends the pane and herdr closes the tab. Argv-exec
diff --git a/plugins/work-system/skills/adopt/SKILL.md b/plugins/work-system/skills/adopt/SKILL.md
index 1fb0f21..f6dca15 100644
--- a/plugins/work-system/skills/adopt/SKILL.md
+++ b/plugins/work-system/skills/adopt/SKILL.md
@@ -13,7 +13,11 @@ user_invocable: true
 
 ## Arguments
 
-- `$ARGUMENTS` - Optional: branch name to adopt
+- `$ARGUMENTS` — `<branch> [agent-selector]`: optional branch name to adopt, plus an
+  optional worker-agent selector (same set as `/kickoff`: `--fable`, `--opus`, `--sol`,
+  `--grok`, `--codex`, `--agent <cli[:model]>`, `--pick`). The selector chooses the
+  worker the herdr auto-launch (step 13) starts; omit it to use the repo default. The
+  **branch is the token that does not start with `-`**; step 2 separates the two.
 
 ## Critical: never persist a `cd` into the worktree
 
@@ -35,9 +39,14 @@ The Bash tool persists CWD between calls — a bare `cd .claude/worktrees/<task>
    - Run: `bash "${CLAUDE_PLUGIN_ROOT}/scripts/main-repo-path.sh" path` → `<main-repo>` — capture
      it for the CWD-drift check in step 11.
 
-2. **Select branch**:
-   - If `$ARGUMENTS` provided, use as branch name
-   - Otherwise, list available branches:
+2. **Select branch** (separate it from any agent selector first):
+   - The **branch** is the `$ARGUMENTS` token that does **not** start with `-`. The
+     `--…` selector tokens (`--opus`, `--pick`, …) belong to step 12, never the branch;
+     `--agent` additionally **consumes the immediately-following token** as its value
+     (`cli[:model]`), so that token is not a branch candidate either. This mirrors
+     `/kickoff`'s arg rule — set the leftover selector tokens aside for step 12.
+   - If a branch token is present, use it as the branch name.
+   - Otherwise (no non-`-` token), list available branches:
      - Run: `git branch --list --no-merged | grep -v '^\*'`
      - Exclude the current branch and any `task/*` branches that already have worktrees
      - Show the list and ask the user which branch to adopt
@@ -116,13 +125,84 @@ The Bash tool persists CWD between calls — a bare `cd .claude/worktrees/<task>
     - Run: `pwd` and compare to the `<main-repo>` path captured by the helper in step 1.
     - If they differ, **stop and report an error**: "Session CWD drifted into the worktree during adopt — investigate which step ran a persistent `cd`." Do not silently continue.
 
-12. **Final output for the user** (display this block — do *not* execute the `cd`):
+12. **Select the worker agent** — resolve the selector tokens **step 2 set aside**
+    into a concrete `SELECTOR`, and set `OFFER_DEFAULT` (`no`, flipped to `yes` only when
+    the picker asks to save). The default / picker / announce / OFFER_DEFAULT rules are
+    **identical to `skills/kickoff/SKILL.md` step 12 — follow that one copy, do not
+    re-paraphrase them here** (a divergent copy is exactly the drift this feature avoids).
+    With `REG="${CLAUDE_PLUGIN_ROOT}/scripts/agent-registry.sh"`, only the
+    token→`SELECTOR` mapping is restated, because it must match step 2's split (the
+    selector may precede or follow the branch — never assume it comes "after" it):
+    - a shorthand flag (`--fable`/`--opus`/`--sol`/`--grok`/`--codex`) → `SELECTOR` is
+      that flag verbatim;
+    - `--agent <cli[:model]>` → `SELECTOR` is the **`cli[:model]` value**, not the
+      `--agent` token (the registry resolves the bare value; the flag verbatim fails as
+      an unknown selector — exit 2);
+    - no selector token → the repo default (`SELECTOR="$(bash "$REG" default get)"`);
+      empty default, or `--pick`, → the picker.
+
+    The helper (step 13) resolves and validates `SELECTOR`, so don't resolve
+    models/availability yourself.
+
+13. **Launch the worktree session** — automate inside herdr, otherwise show the
+    manual block. Inside herdr this replaces the old "print manual instructions" final
+    step: `/adopt` now opens the task's tab for you, exactly like `/kickoff`.
+
+    Gate (same as kickoff): automate **only** when `[ "${HERDR_ENV:-}" = "1" ]`, a
+    non-empty `$HERDR_WORKSPACE_ID`, and both `command -v herdr` and `command -v
+    python3` succeed. Otherwise show the manual block (b). The helper re-checks these
+    and exits non-zero if it cannot automate, so a broken socket degrades to (b) too.
+
+    **a) Inside herdr — open a named tab that auto-continues.** Derive a short,
+    sidebar-friendly `LABEL` from the **resolved task name** (`<task-name>` from step 3,
+    which already stripped `task/`/`feature/`/`fix/`… prefixes — so the label stays
+    sensible even when step 8 kept the *original* branch name). Drop filler words,
+    hard-cap ~32 chars, pass it PLAIN (the helper prefixes the task's state glyph onto
+    the tab label). The worktree path is absolute — build it from the `<main-repo>`
+    captured in step 1 (never from a drifted CWD):
+
+    ```sh
+    WORKTREE="<main-repo>/.claude/worktrees/<task-name>"   # absolute path
+    LABEL="<short sidebar label>"
+    bash "${CLAUDE_PLUGIN_ROOT}/scripts/herdr-launch.sh" launch "$LABEL" "$WORKTREE" "$HERDR_WORKSPACE_ID" "$SELECTOR"
+    ```
+
+    This is the **same helper and call `/kickoff` uses** — the single source of truth
+    for selector resolution, argv-launch, tab-move, and exit codes. **Branch on its
+    result exactly as `skills/kickoff/SKILL.md` step 13a describes** (exit 0 `moved=yes`
+    → new background tab; `moved=no` → running as a split in *this* tab, relay the
+    helper's stderr; the `OFFER_DEFAULT=yes` → `bash "$REG" default set "<agent>"`
+    persistence after a successful launch; exit 2 unknown selector → re-offer the
+    picker; exit 3 unavailable agent → report `unavailable=`/`note=` verbatim, re-offer;
+    other non-zero → relay stderr, then the manual block). Do not re-implement that
+    branching here — following one copy keeps adopt and kickoff from drifting.
+
+    Success report (adopt keeps the *adopted* branch name — use `<current-branch-name>`,
+    which is `task/<task-name>` only if step 8 renamed it):
+    ```
+    Branch adopted and launched in herdr!
+
+    Tab:       <LABEL>   (workspace <HERDR_WORKSPACE_ID>, opened in the background)
+    Agent:     <cli:model>   (the helper's `agent=` line)
+    Location:  .claude/worktrees/<task-name>
+    Branch:    <current-branch-name>   (original branch, unless step 8 renamed it)
+    Task file: TASK.md (drafted from the branch — review it)
+
+    The new tab is already running the worker. Switch to it to work there.
+    ```
+
+    **b) Outside herdr (or on any fallback) — manual instructions.** Resolve the
+    selector to the exact launch command (registry-driven — do not hand-write it per
+    CLI): `bash "$REG" resolve "$SELECTOR" --session "<task-name>"`. Take the `argv=`
+    lines in order and **shell-quote each word** (the codex/grok bootstrap prompt is one
+    `argv=` word containing spaces; space-joining raw would split it). Display this block
+    — do **not** execute the `cd`:
     ```
     Branch adopted into work system!
 
     Original branch: <original-branch-name>
     Task file:       tasks/<task-name>.md
-    Worktree:        .claude/worktrees/<task-name>
+    Location:        .claude/worktrees/<task-name>
     Branch:          <current-branch-name>
     Commits:         <count> commits ahead of <main-branch>
 
@@ -130,14 +210,18 @@ The Bash tool persists CWD between calls — a bare `cd .claude/worktrees/<task>
        session — this session stays in the main repo) and run:
 
          cd .claude/worktrees/<task-name>
-         claude -n "<task-name>" "/work-system:continue"
+         <the argv= words, each shell-quoted>
     ```
-    `-n "<task-name>"` names the session (shown in `/resume` and the terminal title);
-    the `/work-system:continue` initial prompt runs the resume flow (load TASK.md, recent
-    commits, progress) deterministically — both in one launch. Use the plugin-qualified
-    form: a Claude Code built-in `/continue` shadows the bare skill name. Do **not** execute
-    the `cd` yourself
-    — it is for the user's new terminal.
+    For a **claude** worker that is `claude --model <m> -n "<task-name>"
+    "/work-system:continue"` — `-n` names the session (shown in `/resume`),
+    `/work-system:continue` runs the resume flow (load TASK.md, commits, progress).
+    Use the plugin-qualified form: a Claude Code built-in `/continue` shadows the bare
+    skill. For **codex/grok** it's `codex -m <model> '<bootstrap prompt>'`. Do **not**
+    execute the `cd` yourself — it is for the user's new terminal. If `resolve` exits
+    non-zero (2 unknown / 3 unavailable), surface that instead and re-offer the picker.
+    On the picker's "save default" path, persist only after the user confirms the worker
+    is up (see kickoff step 13b) — you (this main-repo session) then run
+    `bash "$REG" default set "<name>"`; it writes the committed `.claude/work-system-agent`.
 
 ## Remember