From 96d950adbfb03d25bb67ec6d67b1b0524ac9caa5 Mon Sep 17 00:00:00 2001
From: Robert Gering <mail@robertgering.de>
Date: Tue, 21 Jul 2026 14:54:46 +0200
Subject: [PATCH] =?UTF-8?q?Fully-qualify=20kickoff's=20/continue=20?=
 =?UTF-8?q?=E2=86=92=20/work-system:continue?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A Claude Code built-in/alias `/continue` can shadow the work-system plugin
skill, and plugin skills are only guaranteed reachable via their
`plugin:skill` namespace. So a `/kickoff`-launched worker running the bare
`/continue` in a fresh worktree ran CC's own resume (nothing to resume →
idle, TASK.md never loaded) instead of the work-system resume flow, breaking
the kickoff→worker handoff.

Switch every machine-generated launch invocation to the plugin-qualified
`/work-system:continue`, which resolves unambiguously and can't be shadowed:
- agent-registry.sh emit_argv (the selector path) + its argv-shape comment
- herdr-launch.sh legacy no-selector fallback + header comment
- kickoff/adopt SKILL.md outside-herdr manual launch blocks
- kickoff's "suggest /continue" hint when run inside a worktree
- README launch examples (root + work-system)

Tests lock in the qualified argv: test_agent_registry.py asserts emit_argv's
shape, and test_herdr_launch.py now asserts the legacy no-selector worker
argv is `claude -n <session> /work-system:continue` (one token, no bare form).

Human-typed reopen instructions (continue SKILL description, README reopen
section) updated to the qualified form too, since the bare command is what
the built-in shadows. Knowledge (herdr-kickoff-automation) gains a dedicated
shadowing gotcha with the verified CC finding and the plugin-cache
deployment caveat; CHANGELOG entry added; work-system bumped 1.9.1 → 1.9.2.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0189f7ewkgmdN1xgWBLJM1J2
---
 .claude-plugin/marketplace.json               |  2 +-
 .../features/herdr-kickoff-automation.md      | 32 +++++++++++--
 CHANGELOG.md                                  |  3 ++
 README.md                                     |  2 +-
 .../work-system/.claude-plugin/plugin.json    |  2 +-
 plugins/work-system/README.md                 | 17 ++++---
 plugins/work-system/scripts/agent-registry.sh |  9 ++--
 plugins/work-system/scripts/herdr-launch.sh   |  5 +-
 .../scripts/test_agent_registry.py            |  6 +--
 .../work-system/scripts/test_herdr_launch.py  | 47 +++++++++++++++++--
 plugins/work-system/skills/adopt/SKILL.md     |  8 ++--
 plugins/work-system/skills/continue/SKILL.md  |  4 +-
 plugins/work-system/skills/kickoff/SKILL.md   |  9 ++--
 13 files changed, 114 insertions(+), 32 deletions(-)

diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index 9c9d125..2b9694b 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.1"
+      "version": "1.9.2"
     },
     {
       "name": "pr-flow",
diff --git a/.claude/knowledge/features/herdr-kickoff-automation.md b/.claude/knowledge/features/herdr-kickoff-automation.md
index 10f144b..9c184e3 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-19
+updatedAt: 2026-07-21
 createdFrom: "PR #17"
-updatedFrom: "session: 2026-07-19 (surface herdr launch errors)"
-pluginVersion: 1.9.1
+updatedFrom: "session: 2026-07-21 (fully-qualify kickoff's /continue)"
+pluginVersion: 1.9.2
 prime: false
 reindexedAt: 2026-07-12
 ---
@@ -31,7 +31,8 @@ truth; this entry captures the durable design and one non-obvious gotcha.
   `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
   agent** by `agent-registry.sh` (`emit_argv`), not hardcoded: a claude worker is
-  `claude --model <m> -n "<label>" "/continue"`, while codex/grok get their own
+  `claude --model <m> -n "<label>" "/work-system:continue"` (plugin-qualified — see
+  the shadowing gotcha below), while codex/grok get their own
   `-m` form — `codex -m <model> "<bootstrap prompt>"` /
   `grok -m <model> "<bootstrap prompt>"` (see [[kickoff-agent-selection]]).
   herdr-launch stays CLI-agnostic — it just execs the resolved `argv=` words. The
@@ -213,6 +214,29 @@ by-hand tab close where a kickoff tab would auto-close. This is the same
 agent-detection question flagged as unverified for the deferred race-free-prevention
 option above; both wait on live herdr verification.
 
+## Gotcha: launch the worker with `/work-system:continue`, never bare `/continue`
+
+The claude worker's initial prompt is the **plugin-qualified** `/work-system:continue`,
+not the bare `/continue` (work-system 1.9.2 fix). Bare `/continue` is not a safe way to
+reach a plugin skill: a Claude Code built-in/alias `/continue` can shadow it, and — per
+CC's own docs — plugin skills live under a `plugin-name:skill-name` namespace and are
+only *guaranteed* reachable via that qualified form; the bare name resolves to a skill
+only when nothing at a higher precedence claims it. In a fresh worktree session
+(`claude -n <name>`, no prior conversation) a shadowed bare `/continue` either runs CC's
+own resume (nothing to resume → worker sits idle, TASK.md never loaded) or errors as an
+unknown command — either way the work-system resume flow never runs, breaking the core
+kickoff→worker handoff. The exact mechanism (a built-in vs namespace-only resolution)
+is CC-version-dependent and was reported intermittently; the fix is orthogonal to which
+it is, because `/work-system:continue` is the one documented, unshadowable invocation.
+**Do not "simplify" it back to the bare form.**
+
+Sites carrying the qualified form (all machine-generated invocations): `agent-registry.sh`
+`emit_argv` (the primary selector path), `herdr-launch.sh`'s legacy no-selector fallback,
+and kickoff's outside-herdr manual block; `test_agent_registry.py` asserts the argv ends
+in `/work-system:continue`. **Deployment caveat:** `agent-registry.sh` / `herdr-launch.sh`
+run from the *plugin cache*, not the repo, so a launch only picks up this fix after a
+`/plugin` marketplace update + reload refreshes the cache.
+
 ## Gotcha: input into a fresh pane races shell startup
 
 This is *why* the launch uses argv-exec, not `herdr pane run` / typed keystrokes.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 808ef4d..fd9a2e7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -52,6 +52,9 @@ entries are grouped per plugin, newest first.
 
 ## work-system
 
+### 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.
+
 ### 1.9.1 — 2026-07-20
 - `herdr-launch.sh` no longer swallows herdr's own error on a launch/resume failure (`2>/dev/null`). The `agent start`, `pane move`, `tab create`, and `pane run` calls (plus the `tab close` orphan-cleanup that can run after a malformed `tab create`) now capture stderr, strip control/escape bytes both before AND after JSON-decoding a message (a ``-style escape only becomes a real control byte once decoded), parse herdr's `{"error":{"code","message"}}` JSON defensively (raw text as fallback, never a traceback), and print it before the existing generic diagnostic — `pane run`'s failure line now follows the same before-the-generic-message order as the other call sites. When the error names an invalid workspace placement (`agent_placement_not_found`, or the message names the sanitized workspace id as a bounded token within the same clause as "not found"/"placement", case-insensitively), a one-line actionable hint is appended pointing at a stale `HERDR_WORKSPACE_ID` — scoped to the two calls that actually send `--workspace` (`agent start`, `tab create`), since `pane move`/`pane run` can't have a workspace-id problem. `kickoff`/`continue` SKILL.md now explicitly instruct relaying the helper's stderr diagnostic to the user on every failure path, so the richer diagnostic actually reaches the user instead of staying in the tool output — worded per call site, since the stale-workspace hint can only ever appear on the `agent start`/`tab create` paths. Diagnostics only — stdout key=value lines, exit codes, and `moved`/`reused`/`resumed`/`focused` semantics are unchanged. Covered by new `test_herdr_launch.py`.
 
diff --git a/README.md b/README.md
index cef2387..12fa08e 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 `/continue` for you; `/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); `/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 2b5a720..677c9fb 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.1",
+  "version": "1.9.2",
   "author": {
     "name": "gering"
   },
diff --git a/plugins/work-system/README.md b/plugins/work-system/README.md
index fde9104..b1b0735 100644
--- a/plugins/work-system/README.md
+++ b/plugins/work-system/README.md
@@ -117,11 +117,13 @@ See [Worker agent selection](#worker-agent-selection) below for the full set.
 ### 3. Continue in the worktree
 
 Open a new Claude session in the worktree — `-n` names the session, and the
-`/continue` initial prompt loads the task context in one step:
+`/work-system:continue` initial prompt loads the task context in one step (use
+the plugin-qualified form: a Claude Code built-in `/continue` shadows the bare
+skill name):
 
 ```
 cd .claude/worktrees/add-dark-mode
-claude -n "add-dark-mode" "/continue"
+claude -n "add-dark-mode" "/work-system:continue"
 ```
 
 Loads the task context, checks dependencies, and shows current progress.
@@ -203,10 +205,11 @@ worktree as its cwd, and starts the task there for you:
   `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 `/continue` still resolves the task.
+  underlying `task/<name>` branch 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>" "/continue"`
+  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
@@ -240,12 +243,14 @@ marker file (under `$HOME/.cache`), so it never fires on an ordinary session exi
 All of this lives in the tested `scripts/herdr-teardown.sh`; see
 `skills/close/SKILL.md` step 12 for the flow.
 
-### `/continue <task>` reopens a closed task tab
+### `/work-system:continue <task>` reopens a closed task tab
 
 A kickoff tab runs Claude as its **root pane**, so a bare `/exit` (even just to
 restart Claude Code) ends that pane and herdr closes the whole tab — the worktree
 and the resumable session survive, but you lose your place. Run
-`/continue <task>` **from the main session** to get it back: it reopens a herdr tab
+`/work-system:continue <task>` **from the main session** to get it back (use the
+plugin-qualified form — a Claude Code built-in `/continue` shadows the bare skill
+name): it reopens a herdr tab
 at the task's worktree and resumes the existing session with `claude -c` (the
 most-recent session for that cwd — since each worktree hosts exactly one task, the
 cwd identifies it unambiguously), then focuses the tab.
diff --git a/plugins/work-system/scripts/agent-registry.sh b/plugins/work-system/scripts/agent-registry.sh
index 710be87..87447f5 100755
--- a/plugins/work-system/scripts/agent-registry.sh
+++ b/plugins/work-system/scripts/agent-registry.sh
@@ -26,8 +26,9 @@
 #
 # Launch shape per CLI (resolve builds the argv; the launch helper just execs
 # the `argv=` words, so the argv-exec path — no shell-typing race — is kept):
-#   claude  -> claude --model <model> [-n <session>] /continue
-#              (the work-system /continue skill resumes TASK.md deterministically)
+#   claude  -> claude --model <model> [-n <session>] /work-system:continue
+#              (plugin-qualified so a CC built-in /continue can't shadow the skill;
+#              the work-system continue skill resumes TASK.md deterministically)
 #   codex   -> codex -m <model> <bootstrap-prompt>
 #   grok    -> grok  -m <model> <bootstrap-prompt>
 #   The bootstrap prompt (codex/grok have no work-system skills) tells the agent
@@ -265,7 +266,9 @@ emit_argv() {
     claude)
       printf 'argv=%s\n' claude --model "$model"
       [ -n "$session" ] && printf 'argv=%s\n' -n "$session"
-      printf 'argv=%s\n' /continue
+      # Plugin-qualified: a CC built-in/alias `/continue` shadows the skill, so
+      # the bare form would run CC's own resume, not the work-system flow.
+      printf 'argv=%s\n' /work-system:continue
       ;;
     codex)
       printf 'argv=%s\n' codex -m "$model" "$BOOTSTRAP_PROMPT"
diff --git a/plugins/work-system/scripts/herdr-launch.sh b/plugins/work-system/scripts/herdr-launch.sh
index 38bb085..e155245 100755
--- a/plugins/work-system/scripts/herdr-launch.sh
+++ b/plugins/work-system/scripts/herdr-launch.sh
@@ -12,7 +12,7 @@
 #                         can eat the leading keystrokes of a typed command.
 #                         The worker argv is resolved from an agent SELECTOR via
 #                         agent-registry.sh (claude/codex/grok × model); with no
-#                         selector it stays the legacy `claude … /continue`. The
+#                         selector it stays the legacy `claude … /work-system:continue`. The
 #                         registry owns every per-CLI launch detail, so this script
 #                         is CLI-agnostic — it just execs the resolved argv.
 #
@@ -252,7 +252,8 @@ case "$mode" in
     agent_name="claude"
     note=""
     if [ -z "$selector" ]; then
-      worker_argv=(claude -n "$session" "/continue")
+      # Plugin-qualified: a CC built-in/alias `/continue` shadows the skill.
+      worker_argv=(claude -n "$session" "/work-system:continue")
     else
       registry="${0%/*}/agent-registry.sh"
       [ -f "$registry" ] || { echo "agent-registry.sh not found next to herdr-launch.sh" >&2; exit 1; }
diff --git a/plugins/work-system/scripts/test_agent_registry.py b/plugins/work-system/scripts/test_agent_registry.py
index 0856002..9a49d65 100644
--- a/plugins/work-system/scripts/test_agent_registry.py
+++ b/plugins/work-system/scripts/test_agent_registry.py
@@ -3,7 +3,7 @@
 or via scripts/check-structure.py's "plugin tests" check.
 
 Guards the registry's contract: alias/name/cli selector resolution, the per-CLI
-launch argv shape (claude `/continue` vs codex/grok bootstrap prompt), the
+launch argv shape (claude `/work-system:continue` vs codex/grok bootstrap prompt), the
 availability probe (codex login status + grok auth file + grok model-list), the
 exit-code map (2 unknown selector, 3 resolved-but-unavailable), and the
 project-default state (set/get, bogus rejection, no-git-repo error).
@@ -114,13 +114,13 @@ def kv(out):
 check("--fable -> claude:fable", r.get("name") == "claude:fable")
 check("--fable cli", r.get("cli") == "claude")
 check("claude argv shape",
-      r["argv"] == ["claude", "--model", "fable", "-n", "close-herdr", "/continue"])
+      r["argv"] == ["claude", "--model", "fable", "-n", "close-herdr", "/work-system:continue"])
 check("claude supports lifecycle", "continue" in r.get("supports", ""))
 
 r = kv(e.run("resolve", "--opus").stdout)
 check("--opus -> claude:opus", r.get("name") == "claude:opus")
 check("claude argv without session omits -n",
-      r["argv"] == ["claude", "--model", "opus", "/continue"])
+      r["argv"] == ["claude", "--model", "opus", "/work-system:continue"])
 
 r = kv(e.run("resolve", "--sol").stdout)
 check("--sol -> codex:gpt-5.6-sol", r.get("name") == "codex:gpt-5.6-sol")
diff --git a/plugins/work-system/scripts/test_herdr_launch.py b/plugins/work-system/scripts/test_herdr_launch.py
index 0ca71d9..351d762 100644
--- a/plugins/work-system/scripts/test_herdr_launch.py
+++ b/plugins/work-system/scripts/test_herdr_launch.py
@@ -36,8 +36,18 @@ def shquote(s):
 
 
 def herdr_stub(cases):
-    """Build a fake `herdr` script from {"<argv1> <argv2>": (stdout, stderr, exit)}."""
-    lines = ["#!/usr/bin/env bash", 'case "$1 $2" in']
+    """Build a fake `herdr` script from {"<argv1> <argv2>": (stdout, stderr, exit)}.
+
+    When $HERDR_ARGV_LOG is set, every call appends a `=== <subcmd>` header line
+    followed by each received arg on its own line — so a test can assert the exact
+    argv herdr-launch.sh execs (e.g. the worker argv after `agent start … --`)."""
+    lines = [
+        "#!/usr/bin/env bash",
+        'if [ -n "${HERDR_ARGV_LOG:-}" ]; then',
+        '  { printf \'=== %s\\n\' "$1 $2"; printf \'%s\\n\' "$@"; } >> "$HERDR_ARGV_LOG"',
+        "fi",
+        'case "$1 $2" in',
+    ]
     for key, (out, err, rc) in cases.items():
         lines.append(f'  "{key}")')
         if out:
@@ -55,7 +65,7 @@ class Env:
     """A throwaway PATH with a fake `herdr` stub, plus a worktree dir for
     herdr-launch.sh to target."""
 
-    def __init__(self, cases):
+    def __init__(self, cases, log_argv=False):
         self.tmp = tempfile.TemporaryDirectory()
         root = Path(self.tmp.name)
         self.worktree = root / "wt"
@@ -67,6 +77,15 @@ def __init__(self, cases):
         herdr.chmod(0o755)
         self.env = dict(os.environ)
         self.env["PATH"] = f"{bindir}:{self.env['PATH']}"
+        self.argv_log = root / "argv.log" if log_argv else None
+        if self.argv_log is not None:
+            self.env["HERDR_ARGV_LOG"] = str(self.argv_log)
+
+    def logged_argv(self):
+        """Lines the herdr stub recorded (headers + one arg per line); [] if none."""
+        if self.argv_log is None or not self.argv_log.exists():
+            return []
+        return self.argv_log.read_text().splitlines()
 
     def run(self, *args):
         return subprocess.run(
@@ -163,6 +182,28 @@ def close(self):
       "herdr tab create did not return a pane id" in r.stderr)
 e.close()
 
+# --- legacy no-selector launch: worker argv is the plugin-qualified skill --- #
+# Guards the shadowing fix: an empty selector takes the legacy path, whose worker
+# argv MUST be `claude -n <session> /work-system:continue` — the qualified form as
+# ONE argv token (a bare `/continue` would be shadowed by a CC built-in/alias).
+e = Env({
+    "agent start": (jsonlib.dumps({"result": {"agent": {"pane_id": "w1:p5"}}}), "", 0),
+    "pane move": (jsonlib.dumps(
+        {"result": {"move_result": {"created_tab": {"tab_id": "w1:t9"}}}}), "", 0),
+}, log_argv=True)
+r = e.run("launch", "t", str(e.worktree), "w1", "", "sess1")  # "" selector = legacy path
+argv = e.logged_argv()
+check("legacy: exit 0", r.returncode == 0)
+check("legacy: agent=claude on stdout", "agent=claude\n" in r.stdout)
+check("legacy: worker argv carries the qualified skill as one token",
+      "/work-system:continue" in argv)
+check("legacy: bare /continue is NOT emitted", "/continue" not in argv)
+if "/work-system:continue" in argv:
+    i = argv.index("/work-system:continue")
+    check("legacy: `-n <session>` precedes the skill token",
+          argv[i - 2:i] == ["-n", "sess1"])
+e.close()
+
 # --- success path: stdout contract untouched by any of the above ----------- #
 e = Env({
     "agent start": (jsonlib.dumps({"result": {"agent": {"pane_id": "w1:p5"}}}), "", 0),
diff --git a/plugins/work-system/skills/adopt/SKILL.md b/plugins/work-system/skills/adopt/SKILL.md
index 8b00c3d..1fb0f21 100644
--- a/plugins/work-system/skills/adopt/SKILL.md
+++ b/plugins/work-system/skills/adopt/SKILL.md
@@ -130,11 +130,13 @@ 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>" "/continue"
+         claude -n "<task-name>" "/work-system:continue"
     ```
     `-n "<task-name>"` names the session (shown in `/resume` and the terminal title);
-    the `/continue` initial prompt runs the resume flow (load TASK.md, recent commits,
-    progress) deterministically — both in one launch. Do **not** execute the `cd` yourself
+    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.
 
 ## Remember
diff --git a/plugins/work-system/skills/continue/SKILL.md b/plugins/work-system/skills/continue/SKILL.md
index 611b1e1..7220fa8 100644
--- a/plugins/work-system/skills/continue/SKILL.md
+++ b/plugins/work-system/skills/continue/SKILL.md
@@ -2,7 +2,7 @@
 name: continue
 description: |
   Resumes a task, or reopens its herdr tab from the main session with
-  `/continue <task>`.
+  `/work-system:continue <task>`.
   Trigger: "continue", "resume the task", "reopen <task>", "pick up where I left off".
 user_invocable: true
 ---
@@ -46,7 +46,7 @@ the prefix-stripped task name) — comparing the raw argument instead misroutes.
         the current task." Never refuse to resume the task you're in.
 - `main` **with** a `<task>` argument → **Reopen mode** (step 1 normalizes the name).
 - `main` **without** an argument → nothing to resume in-session here; tell the user to
-  name a task (`/continue <task>`) or use `/kickoff` / `/list`, and stop.
+  name a task (`/work-system:continue <task>`) or use `/kickoff` / `/list`, and stop.
 
 ### Reopen mode (main session + `<task>` arg)
 
diff --git a/plugins/work-system/skills/kickoff/SKILL.md b/plugins/work-system/skills/kickoff/SKILL.md
index 0f25eef..ac893f6 100644
--- a/plugins/work-system/skills/kickoff/SKILL.md
+++ b/plugins/work-system/skills/kickoff/SKILL.md
@@ -55,7 +55,8 @@ is a per-repo committed file (`.claude/work-system-agent`), set via
 
 1. **Check current location** (shared helper — robust against paths with spaces and symlinks):
    - Run: `bash "${CLAUDE_PLUGIN_ROOT}/scripts/main-repo-path.sh" linked` → `main` or `linked`.
-     If `linked`, this is already a worktree — stop and suggest `/continue` instead.
+     If `linked`, this is already a worktree — stop and suggest `/work-system:continue`
+     instead (plugin-qualified — a CC built-in `/continue` shadows the bare skill).
    - Run: `bash "${CLAUDE_PLUGIN_ROOT}/scripts/main-repo-path.sh" path` → `<main-repo>` — capture
      it for the CWD-drift check in step 11.
 
@@ -252,8 +253,10 @@ is a per-repo committed file (`.claude/work-system-agent`), set via
          <the argv= words, each shell-quoted — e.g. codex -m gpt-5.6-sol 'Read TASK.md …'>
     ```
     For a **claude** worker the command is `claude --model <m> -n "<task-name>"
-    "/continue"` — `-n` names the session (shown in `/resume`), `/continue` runs the
-    resume flow (load TASK.md, commits, progress). For **codex/grok** it is
+    "/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 CC built-in/alias `/continue` shadows the skill,
+    so the bare word would run CC's own resume instead. For **codex/grok** it is
     `codex -m <model> '<bootstrap prompt>'` (they have no work-system skills, so the
     prompt tells them to read TASK.md and drive to a PR). Do **not** execute the `cd`
     yourself — it is for the user's new terminal. If `resolve` exits non-zero