diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index 6b8e9c18..77bd5ea3 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. Keep tasks as GitHub issues or local markdown files, run them in isolated git worktrees with a choice of worker agent (Claude, codex, grok, kimi, or a PATH-detected cc-harness agent), and track progress across the define/kickoff/continue/status/close lifecycle.",
-      "version": "1.28.2"
+      "version": "1.28.3"
     },
     {
       "name": "pr-flow",
diff --git a/.claude/knowledge/_index.md b/.claude/knowledge/_index.md
index f6d79a74..a39fd33d 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` + `/adopt`) + `resume`; feature-detected dual contract (legacy placement vs 0.7.5+ `agent start --kind --pane`), registry-declared transport, rollback vs `blocked=unverified`, worker death from process state not terminal text
+- `features/herdr-kickoff-automation.md` — herdr `herdr-launch.sh`: `launch` (`/kickoff` + `/adopt`) + `resume`; feature-detected dual contract (legacy placement vs 0.7.5+ `agent start --kind --pane`), registry-declared transport, rollback vs `blocked=unverified`, 0.8.2 idle-readiness timeout confirmed by detection + rename, worker death from process state not terminal text
 - `features/herdr-shell-interactive-tabs.md` — `herdr-shell.sh`: temp `tmp-` tabs for screen programs + `handover`; termios gate (canonical+no-echo; `read -s` is a builtin), socket-only `send_input`, secret fetched before the gate, pid-based fg, flock across create+record vs sweep, `python3 -I` (cwd shadows stdlib), teardown-by-cwd gap, `smoke_*` not `test_*`
 - `features/lane-registry.md` — `lanes.sh` + `herdr-agent.sh` (Wave 1): the one herdr-agent wrapper (degrade-not-block, bounded wait) + centralized `$HERDR_MATCH_PRELUDE` cwd↔worktree match (consumed by herdr-tab-glyph, regression-guarded via live snapshot); lanes.sh joins states+liveness keyed by worktree_path with a worktree-tab-state degrade tri-state; env test-seams for hermetic join tests
 - `features/herdr-close-automation.md` — `/close` in herdr: cwd-tab teardown, plugin SessionEnd hook, the one TUI-exit primitive, detached self-exit onto idle, Manager close-delegation, ask-on-doubt auto-accept + follow-up sweep; `/land` composition + `--delegate` preselect; follow-ups do/ask/record (ROADMAP via `followups.py`) and Manager-owned deploy (`deploy-owner`); the `landing.sh` marker (git common dir, pane+session identity) for a lane torn down under `/land`
diff --git a/.claude/knowledge/features/herdr-kickoff-automation.md b/.claude/knowledge/features/herdr-kickoff-automation.md
index 7861f244..74a1fc0a 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-08-19
+updatedAt: 2026-10-26
 createdFrom: "PR #17"
-updatedFrom: "session: 2026-08-19 (task/offer-cc-harness-agents-at-kickoff)"
-pluginVersion: 1.12.0
+updatedFrom: "session: 2026-10-26 (task/fix-herdr-launch-unverified-on-0-8-2)"
+pluginVersion: 1.28.3
 prime: false
 reindexedAt: 2026-07-12
 ---
@@ -164,7 +164,8 @@ decisions from the fix:
   Definitive failures close the created tab exactly once through
   `herdr-teardown.sh close-tab` (the existing close-then-verify SoT — it deliberately
   does not re-issue the close, since a recycled tab id would kill an unrelated live
-  tab). Ambiguous outcomes — readiness timeout, an unclassifiable herdr error, a
+  tab). Ambiguous outcomes — a readiness timeout with no running worker detected
+  (see the 0.8.2 section below), an unclassifiable herdr error, a
   returned pane id that isn't the requested one, a wrapper detected as the wrong kind
   — leave the tab alone and return the new fail-closed `blocked=unverified` result
   (exit 0, `blocked` FIRST). An *unconfirmed* rollback downgrades to the same result:
@@ -185,6 +186,50 @@ decisions from the fix:
   "the verified worker is in its dedicated tab", and changing the key would break
   every caller for a cosmetic gain.
 
+### herdr 0.8.2: `agent start` waits for an IDLE agent (work-system 1.28.3)
+
+From 0.8.2, `agent start` succeeds only once the agent is *ready for input* — idle.
+A claude worker handed `/work-system:continue` starts working immediately and stays
+busy for the whole task, so every native `claude:*` start (any `agent start` kind that is busy at once would) ran into its `--timeout`
+(`code=timeout`) while the worker ran fine, and herdr then **never registers the
+requested name** — not even once the agent later goes idle (`agent get <label>` →
+`agent_not_found`). Measured live: `pane get` reports `agent=claude` 0.6s in, the
+start times out at 10.4s; a start whose turn finished in 16s returned at 17s. The
+pane-run path (cc-harness, kimi) never hit this: it confirms by detection, not by
+`agent start`'s readiness.
+
+- **A `timeout` — that code only — is confirmed from process state.** A bounded poll
+  (`WORK_SYSTEM_HERDR_CONFIRM_SECONDS`, 10s) of `pane get`'s `agent` + `agent_status`
+  in that exact pane: the expected kind while `working`/`idle`/`done` → `moved=yes`;
+  `blocked` (held at a prompt), a different kind or nothing → `blocked=unverified` as
+  before. `unknown` is herdr's first seconds of detection and is polled through.
+  Nothing is retried. A timeout is genuinely two-sided: live, a 3s start into a pane
+  whose shell was still busy typed **nothing** and left a bare prompt.
+- **Then name it**: `agent rename <pane> <label>` (idempotent, so bounded unlike the
+  launch mutations). Best-effort — `agent_name_taken` (a stale tab holding the label)
+  is reported on stderr plus a `named=no` stdout line `/kickoff` relays (the
+  caller must not advertise a name herdr gave someone else); the launch stays
+  confirmed.
+- **Not every startup error is the busy case.** `agent_not_ready` ("blocked during
+  startup") is CC's trust dialog in an untrusted cwd — the agent is stuck, not
+  working, so it stays ambiguous → `unverified`.
+- herdr's own error line is withheld on a confirmed launch and printed only when
+  confirmation fails.
+
+### Gotcha: a killed probe shifts a sequenced test stub
+
+`test_herdr_launch.py`'s herdr stub answers the Nth call to a subcommand with the
+Nth canned reply, counting on ENTRY. A bounded read that a loaded runner stalls past
+its bound is killed after it was counted, so every later answer shifts by one — the
+suite then failed on a different assertion each run (`stops immediately` sees 2
+polls; a ready→busy shell reads busy at once). Measured: a single 2s `pane get` under
+a 1s bound turns 1 poll into 2. Hence every time bound is a seam
+(`WORK_SYSTEM_HERDR_PROBE_SECONDS`, `WORK_SYSTEM_AGENT_PROBE_SECONDS`,
+`HA_CALL_TIMEOUT_SECS`) pinned to 120s in `Env.__init__`, together with every poll
+window (`…_CONFIRM/DETECT/READY/ALIVE/BUSY_SECONDS`): a read that stalls without
+being killed would otherwise end a window after one poll. Production stays 10s. A
+new bounded call or window needs the same seam, or the flake returns.
+
 ### Gotcha: a supervisor cannot take its signal from terminal text
 
 Deciding "did this worker die?" from what the pane SHOWS was attempted three times
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c7738514..02b93195 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -52,6 +52,10 @@ entries are grouped per plugin, newest first.
 
 ## work-system
 
+### 1.28.3 — 2026-10-27
+- `herdr-launch.sh launch` confirms an `agent start` worker (in practice a native `claude:*` one) whose `agent start` hit herdr's readiness `timeout`: herdr 0.8.2 waits for an idle agent, and a worker handed `/work-system:continue` is busy from the start, so every such kickoff ended `blocked=unverified` while it ran. On that error code only, a bounded poll (`WORK_SYSTEM_HERDR_CONFIRM_SECONDS`, 10 s) for the expected kind in the pane, in a running state (`working`/`idle`/`done`), turns it into `moved=yes`; a worker held at a prompt (`blocked`), nothing or a different kind stays `unverified`, and nothing is retried. The confirmed worker then gets the herdr agent name the timed-out start never registered (`agent rename`, best-effort; a refused name adds `named=no`, which `/kickoff` relays), and herdr's timeout error is printed only when the confirmation fails.
+- Test seams for the probe time bounds (`WORK_SYSTEM_HERDR_PROBE_SECONDS`, `WORK_SYSTEM_AGENT_PROBE_SECONDS`; production default unchanged at 10 s), pinned with `HA_CALL_TIMEOUT_SECS` and every poll window in `test_herdr_launch.py`. A stalled call killed by the bound had already advanced the herdr stub's per-call sequence, which is why the test failed on a different assertion each loaded run.
+
 ### 1.28.2 — 2026-10-27
 - `test_close_request.py` and `test_landing.py` build their shadow `PATH` skipping dangling source entries and checking presence with `os.path.lexists`, so a dangling link that `/usr/bin` and `/bin` both list (usrmerge) no longer fails the second `symlink_to` with `FileExistsError`, and a later source's real binary of that name still gets linked (Structure Checks red on main since #91). Tests only; no script behavior changes.
 
diff --git a/plugins/work-system/.claude-plugin/plugin.json b/plugins/work-system/.claude-plugin/plugin.json
index 11af24ee..d06e5655 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. Keep tasks as GitHub issues or local markdown files, run them in isolated git worktrees with a choice of worker agent (Claude, codex, grok, kimi, or a PATH-detected cc-harness agent), and track progress across the define/kickoff/continue/status/close lifecycle.",
-  "version": "1.28.2",
+  "version": "1.28.3",
   "author": {
     "name": "gering"
   },
diff --git a/plugins/work-system/README.md b/plugins/work-system/README.md
index cd3be6f9..3af7acd2 100644
--- a/plugins/work-system/README.md
+++ b/plugins/work-system/README.md
@@ -596,6 +596,12 @@ keeps the original branch name rather than renaming it to `task/<name>`:
   a bounded window. On **0.7.0–0.7.4** the old `agent start --workspace --cwd -- …`
   plus `pane move --new-tab` sequence is kept unchanged. If neither contract is
   recognizable, nothing is created and you get the manual command instead.
+- On herdr **0.8.2**, `agent start` only returns once the agent is idle, so a
+  worker already busy (in practice claude with `/work-system:continue`) runs into
+  herdr's startup timeout. The launcher then confirms the worker from herdr's own
+  detection — the expected kind in that pane, `working`/`idle`/`done` (one held at
+  a prompt stays unconfirmed) — and tries to give it the tab's agent name; if herdr
+  refuses the name, `/kickoff` says so and the worker is addressed by pane.
 - If a launch can't be **confirmed** (the worker never became detectable, an
   unclassifiable herdr error, a pane-id mismatch), the tab is left in place and the
   skill tells you to look at it rather than launching a second worker onto the same
diff --git a/plugins/work-system/scripts/agent-registry.sh b/plugins/work-system/scripts/agent-registry.sh
index de09d99f..69a185d7 100755
--- a/plugins/work-system/scripts/agent-registry.sh
+++ b/plugins/work-system/scripts/agent-registry.sh
@@ -109,6 +109,8 @@
 #   WORK_SYSTEM_CC_HARNESS_AGENTS    path to the optional cc-harness-agents
 #                                    helper; default: `cc-harness-agents` on PATH.
 #                                    Point it at a stub to test without PATH munging.
+#   WORK_SYSTEM_AGENT_PROBE_SECONDS  time bound of each CLI availability probe
+#                                    (default 10); a test seam for loaded runners.
 #   No global state and no shipped fallback — a repo with no default gets the
 #   picker instead.
 #
@@ -346,7 +348,7 @@ harness_list_raw() {
   # from "configured but this provider is logged out". pipefail is not POSIX, so
   # dash-as-sh cannot express this.
   set +e
-  run_bounded 10 bash -c 'set -o pipefail; "$1" list 2>/dev/null | head -c "$2"' _ \
+  run_bounded "$PROBE_SECONDS" bash -c 'set -o pipefail; "$1" list 2>/dev/null | head -c "$2"' _ \
     "$HARNESS_BIN" "$HARNESS_MAX_BYTES" >"$tmp"
   rc=$?
   set -e
@@ -693,6 +695,7 @@ row_for_selector() {
 # lib-bounded.sh (herdr-launch.sh sources the same file): two private copies had
 # already drifted apart, and a sibling-script dependency is the norm here anyway.
 _LIB_BOUNDED="$SCRIPT_DIR/lib-bounded.sh"
+PROBE_SECONDS="${WORK_SYSTEM_AGENT_PROBE_SECONDS:-10}"
 # shellcheck source=lib-bounded.sh
 . "$_LIB_BOUNDED" 2>/dev/null || {
   echo "agent-registry.sh: cannot source $_LIB_BOUNDED (it ships alongside this script)" >&2
@@ -717,7 +720,7 @@ _GROK_RAW_RC=0
 grok_models_load() {
   [ -n "$_GROK_RAW_LOADED" ] && return 0
   _GROK_RAW_LOADED=1
-  _GROK_RAW="$(run_bounded 10 grok models 2>/dev/null)" || _GROK_RAW_RC=$?
+  _GROK_RAW="$(run_bounded "$PROBE_SECONDS" grok models 2>/dev/null)" || _GROK_RAW_RC=$?
 }
 grok_models_raw() {
   grok_models_load
@@ -767,7 +770,7 @@ grok_resolve_latest() {
 # model alias against the raw JSON rather than parsing it — no jq/python
 # dependency, and a reshaped config document can't yield a wrong token.
 kimi_models_raw() {
-  run_bounded 10 kimi provider list --json 2>/dev/null
+  run_bounded "$PROBE_SECONDS" kimi provider list --json 2>/dev/null
 }
 
 entry_status() {
@@ -787,7 +790,7 @@ entry_status() {
       local crc=0
       if ! command -v codex >/dev/null 2>&1; then note="not installed"
       else
-        run_bounded 10 codex login status >/dev/null 2>&1 || crc=$?
+        run_bounded "$PROBE_SECONDS" codex login status >/dev/null 2>&1 || crc=$?
         if [ "$crc" -eq 0 ]; then avail=yes
         elif [ "$crc" -eq 124 ]; then avail=yes; note="codex login status timed out — availability assumed"
         else note="run: codex login"; fi
diff --git a/plugins/work-system/scripts/herdr-launch.sh b/plugins/work-system/scripts/herdr-launch.sh
index e9998744..0d932589 100755
--- a/plugins/work-system/scripts/herdr-launch.sh
+++ b/plugins/work-system/scripts/herdr-launch.sh
@@ -83,6 +83,8 @@
 #                     resume: always yes — its own tab)
 #   agent=<name>     (launch only) the resolved CLI×model (e.g. codex:gpt-5.6-sol,
 #                     or plain `claude` for the legacy no-selector path)
+#   named=no         (launch only, rare) a worker confirmed after a readiness
+#                     timeout did not get its herdr agent name — address it by pane
 # launch selector errors (nothing spawned): exit 2 = unknown selector; exit 3 =
 # the CLI is not available, with stdout `unavailable=<name>` + `note=<hint>` so
 # the caller can print a clear "run: … login".
@@ -92,8 +94,9 @@
 #   tab=<tab or empty>
 #   agent=<resolved agent>
 # It means a tab exists and a worker MAY be running in it, but the launch could
-# not be confirmed (readiness timeout, an unrecognized herdr error, a pane-id
-# mismatch, or a rollback that could not be verified). Callers must branch on
+# not be confirmed (a readiness timeout with no worker detected in the pane
+# afterwards, an unrecognized herdr error, a pane-id mismatch, or a rollback that
+# could not be verified). Callers must branch on
 # `blocked` BEFORE `moved`, tell the user to inspect that tab, and must NOT launch
 # again, print the manual worker command, or save a project default.
 # resume adds three keys so the caller never reports a resume that didn't happen:
@@ -185,6 +188,9 @@ fi
 # (`tab create`, `agent start`, `pane run`, `pane move`): `agent start` carries
 # herdr's own `--timeout`, and client-side killing a half-applied mutation would
 # trade a hang for unknown server state — those keep their pre-existing behavior.
+# PROBE_SECONDS is that bound for every read; a seam so tests under load can widen
+# it, never a reason to change the production 10s.
+PROBE_SECONDS="${WORK_SYSTEM_HERDR_PROBE_SECONDS:-10}"
 # shellcheck source=lib-bounded.sh
 . "$SCRIPT_DIR/lib-bounded.sh" 2>/dev/null || {
   echo "herdr-launch.sh: cannot source $SCRIPT_DIR/lib-bounded.sh (it ships alongside this script)" >&2
@@ -213,7 +219,7 @@ detect_launch_api() {
   # so a SIGKILLed grandchild still holding it would keep this $( ) open forever —
   # defeating the exact hang guard run_bounded's temp-file stdout routing provides.
   # `--help` goes to stdout; herdr's stderr is of no use here.
-  help="$(run_bounded 10 herdr agent start --help 2>/dev/null)" || rc=$?
+  help="$(run_bounded "$PROBE_SECONDS" herdr agent start --help 2>/dev/null)" || rc=$?
   # Plain substring tests on a string already in memory — `case` does this with no
   # subprocess, where the printf|grep pipelines it replaces cost eight per launch
   # and implied a regex match that was never wanted.
@@ -243,12 +249,17 @@ READY_TRIES="${WORK_SYSTEM_HERDR_READY_TRIES:-60}"               # shell-prompt
 DETECT_TRIES="${WORK_SYSTEM_HERDR_DETECT_TRIES:-60}"             # wrapper detection polls
 RETRY_DELAY="${WORK_SYSTEM_HERDR_RETRY_DELAY:-0.5}"              # seconds between polls
 # Try counts alone do NOT bound these loops in wall clock: each iteration makes
-# herdr calls that are themselves only bounded at 10s each, so against a wedged
+# herdr calls that are themselves bounded at PROBE_SECONDS (10s) each, so against a wedged
 # socket "60 tries" can mean twenty minutes rather than the ~30s the numbers imply.
 # Every poll loop therefore also carries an absolute deadline, and whichever bound
 # trips first ends it.
 READY_SECONDS="${WORK_SYSTEM_HERDR_READY_SECONDS:-45}"
 DETECT_SECONDS="${WORK_SYSTEM_HERDR_DETECT_SECONDS:-45}"
+# After an `agent start` readiness timeout: how long to look for the worker herdr
+# may already have started in the pane. Short on purpose — measured live, herdr
+# detects a typed claude in under a second, and by then the start has already
+# spent its own --timeout.
+CONFIRM_SECONDS="${WORK_SYSTEM_HERDR_CONFIRM_SECONDS:-10}"
 ALIVE_SECONDS="${WORK_SYSTEM_HERDR_ALIVE_SECONDS:-20}"
 # The busy-retry budget is wall clock for a reason: `agent start` may REJECT
 # instantly (a precondition check) or only after consuming its own --timeout, so a
@@ -278,12 +289,14 @@ try:
 except Exception:
     pass'
 #   modern launch: the detected agent kind of one pane (`pane get`), i.e. what
-#   herdr believes is running there. Empty for a plain shell pane.
-extract_pane_agent='import sys, json
+#   herdr believes is running there, plus its agent_status, as `<kind>|<status>`.
+#   The kind is empty for a plain shell pane; an unreadable answer is a bare "|".
+extract_pane_agent_state='import sys, json
 try:
-    print(json.load(sys.stdin)["result"]["pane"].get("agent") or "")
+    p = json.load(sys.stdin)["result"]["pane"]
+    print((p.get("agent") or "") + "|" + (p.get("agent_status") or ""))
 except Exception:
-    pass'
+    print("|")'
 #   modern launch (pane-run) + resume: is the pane back at its own shell prompt,
 #   i.e. safe to type a command into? Answered from WHICH PROCESSES hold the
 #   foreground: only the shell itself → ready; anything else (rc-file startup
@@ -441,7 +454,16 @@ HERDR_WORKSPACE_ID=$ws_clean is not a valid workspace on this herdr server (like
 # exist to keep the three outcome shapes (success, rolled-back failure, fail-closed
 # unverified) in ONE place instead of repeated inline at every error site.
 
-# classify_start_failure <rc> <stderr-blob> → busy | definitive | ambiguous
+# herdr_error_code <stderr-blob> → herdr's error.code, or empty.
+herdr_error_code() {
+  local code
+  code="$(printf '%s' "$1" | tr -dc '[:print:]\t\n' | python3 -c "$extract_herdr_error" 2>/dev/null || true)"
+  printf '%s\n' "${code%%|*}"
+}
+
+# classify_start_failure <rc> <error-code> → busy | definitive | ambiguous
+#   (<error-code> from herdr_error_code, so a caller that branches on it too
+#   parses the blob once)
 #   busy       herdr refused because the pane's shell was not at a prompt yet. This
 #              is THE failure right after `tab create` (a login shell running
 #              direnv/sops/ssh-add takes seconds), so it is retried — bounded, and
@@ -452,13 +474,13 @@ HERDR_WORKSPACE_ID=$ws_clean is not a valid workspace on this herdr server (like
 #              required --pane", "unknown option: …") or a no-such-pane/placement
 #              error code.
 #   ambiguous  anything else, INCLUDING a readiness timeout: the worker may be
-#              coming up in that pane. Never rolled back, never retried — reported
-#              as blocked=unverified so the user inspects the tab.
+#              coming up in that pane. Never rolled back, never retried. The
+#              native-start caller confirms a `timeout` from process state
+#              (moved=yes when the expected kind is detected); everything else is
+#              reported as blocked=unverified so the user inspects the tab.
 classify_start_failure() {
-  local rc="$1" blob="$2" code
+  local rc="$1" code="$2"
   [ "$rc" = 2 ] && { printf 'definitive\n'; return 0; }
-  code="$(printf '%s' "$blob" | tr -dc '[:print:]\t\n' | python3 -c "$extract_herdr_error" 2>/dev/null || true)"
-  code="${code%%|*}"
   case "$code" in
     agent_pane_busy) printf 'busy\n' ;;
     agent_pane_not_found|agent_target_not_found|agent_placement_not_found|pane_not_found)
@@ -515,9 +537,30 @@ fail_definitive() {
   exit 0
 }
 
-# pane_agent_kind <pane> — what herdr currently detects in that pane ("" = nothing).
-pane_agent_kind() {
-  run_bounded 10 herdr pane get "$1" 2>/dev/null | python3 -c "$extract_pane_agent" 2>/dev/null || true
+# pane_agent_state <pane> → `<kind>|<agent_status>` of what herdr currently
+# detects in that pane ("|" = nothing readable). Non-printables are stripped:
+# both fields reach the terminal in diagnostics.
+pane_agent_state() {
+  run_bounded "$PROBE_SECONDS" herdr pane get "$1" 2>/dev/null | python3 -c "$extract_pane_agent_state" 2>/dev/null | tr -dc '[:print:]\n' || printf '|\n'
+}
+
+# name_agent <pane> <name> — give a confirmed worker the herdr agent name its
+# timed-out `agent start` never registered, so `agent read/prompt <label>` works.
+# Best-effort: the worker is confirmed either way, so a failure (e.g.
+# agent_name_taken by a stale tab) is reported and returns 1, which the caller
+# turns into a `named=no` line. A rename is idempotent,
+# which is why — unlike the launch mutations — it may be bounded.
+name_agent() {
+  local err diag rc=0
+  err="$(mktemp)"
+  run_bounded "$PROBE_SECONDS" herdr agent rename "$1" "$2" >/dev/null 2>"$err" || rc=$?
+  if [ "$rc" != 0 ]; then
+    diag="$(herdr_diag "$(cat "$err")" "$workspace" 0)"
+    [ -n "$diag" ] && printf '%s\n' "$diag" >&2
+    echo "the worker in pane $1 is running, but herdr did not take the agent name '$2' — address it by pane" >&2
+  fi
+  rm -f "$err"
+  return "$rc"
 }
 
 # pane_state <pane> → present | gone | unverified. Used on the LEGACY path, where a
@@ -543,7 +586,7 @@ if not pid or not panes:
 print("present" if any(p.get("pane_id") == pid for p in panes) else "gone")'
 pane_state() {
   local json
-  json="$(run_bounded 10 herdr pane list 2>/dev/null || true)"
+  json="$(run_bounded "$PROBE_SECONDS" herdr pane list 2>/dev/null || true)"
   [ -n "$json" ] || { printf 'unverified\n'; return 0; }
   printf '%s' "$json" | python3 -c "$extract_pane_present" "$1" 2>/dev/null || printf 'unverified\n'
 }
@@ -573,7 +616,7 @@ pane_state() {
 # its own shell prompt". `ready` = the shell itself holds the foreground, `busy` =
 # a child does (the wrapper is running), `unknown` = herdr cannot answer.
 pane_shell_state() {
-  run_bounded 10 herdr pane process-info --pane "$1" 2>/dev/null \
+  run_bounded "$PROBE_SECONDS" herdr pane process-info --pane "$1" 2>/dev/null \
     | python3 -c "$extract_shell_ready" 2>/dev/null || echo unknown
 }
 
@@ -685,7 +728,7 @@ EOF_RESOLVE
         # We never got an answer, so we know nothing about the contract. Say THAT,
         # instead of accusing herdr of an unrecognizable API — the cause here is a
         # wedged/unreachable socket or a probe that outran its bound.
-        echo "could not probe 'herdr agent start --help' (no output, an error, or it outran its 10s bound) — herdr may be unreachable or wedged" >&2
+        echo "could not probe 'herdr agent start --help' (no output, an error, or it outran its ${PROBE_SECONDS}s bound) — herdr may be unreachable or wedged" >&2
         echo "nothing was created and no worker was started — start it by hand, or retry once herdr responds" >&2
         exit 1
         ;;
@@ -845,7 +888,8 @@ EOF_RESOLVE
         rm -f "$start_err"
         [ "$start_rc" = 0 ] && break
 
-        class="$(classify_start_failure "$start_rc" "$start_blob")"
+        start_code="$(herdr_error_code "$start_blob")"
+        class="$(classify_start_failure "$start_rc" "$start_code")"
         # Retry ONLY the "shell not ready yet" rejection, bounded. Everything else
         # falls straight through — a retry loop over an unrelated error is how a
         # launcher ends up starting two workers.
@@ -856,15 +900,63 @@ EOF_RESOLVE
         fi
 
         # This call never sends --workspace, so a placement error here cannot be a
-        # stale-workspace problem: ws_relevant=0 keeps that hint off.
-        diag="$(herdr_diag "$start_blob" "$workspace" 0)"
-        [ -n "$diag" ] && printf '%s\n' "$diag" >&2
+        # stale-workspace problem: ws_relevant=0 keeps that hint off. A timeout's
+        # diagnostic waits until the confirmation below has failed — a confirmed
+        # launch is a success and must not print herdr's error.
+        if [ "$start_code" != timeout ]; then
+          diag="$(herdr_diag "$start_blob" "$workspace" 0)"
+          [ -n "$diag" ] && printf '%s\n' "$diag" >&2
+        fi
         if [ "$class" = busy ]; then
           fail_definitive "pane $pane never reached an interactive shell prompt (herdr kept reporting agent_pane_busy for ${BUSY_SECONDS}s / $BUSY_TRIES retries) — nothing was started"
         fi
         if [ "$class" = definitive ]; then
           fail_definitive "herdr agent start --kind $herdr_kind was rejected before starting anything in pane $pane"
         fi
+        # A readiness TIMEOUT is the one ambiguous error confirmed from process
+        # state. Since herdr 0.8.2 `agent start` returns only once the agent is
+        # ready for input, i.e. idle — and a claude worker handed
+        # /work-system:continue starts working at once and stays busy for the
+        # whole task, so the call outlives its --timeout although the worker is
+        # healthy (measured live: detected as claude 0.6s in, timeout at 10.4s).
+        # herdr then never registers the requested name either. A timeout can
+        # equally mean nothing was typed (shell still busy when herdr gave up), so
+        # only herdr detecting the EXPECTED kind in THIS pane, in a running state
+        # (working/idle/done), turns it into a launch. `blocked` is a worker held
+        # at a prompt nobody was told about, so it stays unverified; `unknown` is
+        # the first seconds of detection and is polled through. Nothing is retried.
+        if [ "$start_code" = timeout ]; then
+          detected=""
+          status=""
+          i=0
+          confirm_deadline=$(( SECONDS + CONFIRM_SECONDS ))
+          while [ "$i" -lt "$DETECT_TRIES" ] && [ "$SECONDS" -lt "$confirm_deadline" ]; do
+            state="$(pane_agent_state "$pane")"
+            detected="${state%%|*}"
+            status="${state#*|}"
+            if [ -n "$detected" ] && [ "$status" != unknown ] && [ -n "$status" ]; then break; fi
+            [ -n "$detected" ] && [ "$detected" != "$herdr_kind" ] && break
+            i=$((i + 1))
+            sleep "$RETRY_DELAY" 2>/dev/null || true
+          done
+          if [ "$detected" = "$herdr_kind" ]; then
+            case "$status" in
+              working|idle|done)
+                named=yes
+                name_agent "$pane" "$label" || named=no
+                printf 'pane=%s\ntab=%s\nmoved=yes\nagent=%s\n' "$pane" "$tab" "$agent_name"
+                if [ "$named" = no ]; then printf 'named=no\n'; fi
+                exit 0 ;;
+            esac
+          fi
+          diag="$(herdr_diag "$start_blob" "$workspace" 0)"
+          [ -n "$diag" ] && printf '%s\n' "$diag" >&2
+          if [ -n "$detected" ] && [ "$detected" != "$herdr_kind" ]; then
+            echo "herdr detects '$detected' in pane $pane, not the expected '$herdr_kind' — cannot confirm the launch" >&2
+          elif [ -n "$detected" ]; then
+            echo "herdr detects $detected in pane $pane but its state is '${status:-unreadable}', not running — it may be waiting at a prompt" >&2
+          fi
+        fi
         echo "herdr agent start --kind $herdr_kind did not confirm the worker in pane $pane — it may still be coming up, so the tab was left alone" >&2
         emit_unverified
         exit 0
@@ -904,7 +996,7 @@ EOF_RESOLVE
     if [ "$run_rc" != 0 ]; then
       diag="$(herdr_diag "$run_blob" "$workspace" 0)"
       [ -n "$diag" ] && printf '%s\n' "$diag" >&2
-      if [ "$(classify_start_failure "$run_rc" "$run_blob")" = definitive ]; then
+      if [ "$(classify_start_failure "$run_rc" "$(herdr_error_code "$run_blob")")" = definitive ]; then
         fail_definitive "herdr pane run could not deliver the $agent_name wrapper to pane $pane"
       fi
       echo "herdr pane run returned an error for pane $pane but may still have delivered the command — the tab was left alone" >&2
@@ -918,7 +1010,7 @@ EOF_RESOLVE
     # second one.
     #
     # A dead wrapper is detected from process state, not from anything it printed
-    # (see the note above pane_agent_kind). The signal is NOT the busy→ready
+    # (see the note above pane_agent_state). The signal is NOT the busy→ready
     # transition — measured live, a wrapper that fails on startup (the common case:
     # expired auth) is gone before the first poll, so its "running" phase is never
     # observable. What IS observable is the steady state: a `sh -c` wrapper puts a
@@ -944,7 +1036,8 @@ EOF_RESOLVE
     # milliseconds and tear down a healthy worker that had not started yet.
     idle_earliest=$(( SECONDS + IDLE_MIN_SECONDS ))
     while [ "$i" -lt "$DETECT_TRIES" ] && [ "$SECONDS" -lt "$detect_deadline" ]; do
-      detected="$(pane_agent_kind "$pane")"
+      state="$(pane_agent_state "$pane")"
+      detected="${state%%|*}"
       if [ "$detected" = "$herdr_kind" ]; then
         printf 'pane=%s\ntab=%s\nmoved=yes\nagent=%s\n' "$pane" "$tab" "$agent_name"
         exit 0
diff --git a/plugins/work-system/scripts/test_herdr_launch.py b/plugins/work-system/scripts/test_herdr_launch.py
index c6fb1dc0..7793d91c 100644
--- a/plugins/work-system/scripts/test_herdr_launch.py
+++ b/plugins/work-system/scripts/test_herdr_launch.py
@@ -22,7 +22,10 @@
     bounded expected-kind detection, the idle-pane death signal (process state, not
     terminal text), wrong-kind and timeout → blocked=unverified with no retry;
   * rollback — exactly-once tab close on definitive failures, no rollback on
-    ambiguous ones, and an unconfirmed rollback downgrading to unverified.
+    ambiguous ones, and an unconfirmed rollback downgrading to unverified;
+  * herdr 0.8.2 readiness timeouts: the worker detected in the pane → moved=yes
+    + named (a refused name → named=no), nothing/wrong kind detected → still
+    unverified.
 """
 import json as jsonlib
 import os
@@ -72,11 +75,11 @@
     "code": "agent_pane_not_found", "message": "agent target pane w1:p7 not found"}})
 
 
-def pane_get(agent=None):
+def pane_get(agent=None, status="idle"):
     p = {"pane_id": "w1:p7", "tab_id": "w1:t7", "agent_status": "unknown"}
     if agent:
         p["agent"] = agent
-        p["agent_status"] = "idle"
+        p["agent_status"] = status
     return jsonlib.dumps({"result": {"pane": p}})
 
 
@@ -210,6 +213,20 @@ def __init__(self, cases, log_argv=False, api="legacy", help_text=None):
         self.env["WORK_SYSTEM_HERDR_IDLE_MIN_SECONDS"] = "0"
         self.env["WORK_SYSTEM_HERDR_UNKNOWN_TRIES"] = "2"
         self.env["WORK_SYSTEM_HERDR_ALIVE_TRIES"] = "2"
+        # Pin the TIME the tries run under, too. Every stub answers in milliseconds,
+        # so these bounds never fire here — unless a loaded runner stalls one call
+        # past the production 10s. The bounded call is then killed after the stub
+        # already logged it and advanced its per-call sequence, so every later
+        # answer shifts by one: a "stops immediately" counts 2 polls, a ready→busy
+        # shell reads busy from the start. That is how one slow fork surfaced as a
+        # different assertion each run. Nothing here waits on them firing.
+        # The poll WINDOWS too: a stalled-but-not-killed read can otherwise run a
+        # window out after one poll, which is the same flake by another route.
+        for bound in ("WORK_SYSTEM_HERDR_PROBE_SECONDS", "WORK_SYSTEM_AGENT_PROBE_SECONDS",
+                      "HA_CALL_TIMEOUT_SECS", "WORK_SYSTEM_HERDR_CONFIRM_SECONDS",
+                      "WORK_SYSTEM_HERDR_DETECT_SECONDS", "WORK_SYSTEM_HERDR_READY_SECONDS",
+                      "WORK_SYSTEM_HERDR_ALIVE_SECONDS", "WORK_SYSTEM_HERDR_BUSY_SECONDS"):
+            self.env[bound] = "120"
         if api is not None:
             self.env["WORK_SYSTEM_HERDR_API"] = api
         else:
@@ -618,6 +635,90 @@ def wrapper_cases(**over):
       len(e.call_args("agent start")) == 1)
 e.close()
 
+# --- herdr 0.8.2: a readiness TIMEOUT with the worker detected is a launch -- #
+# `agent start` waits for an IDLE agent; a claude worker handed /work-system:continue
+# is busy from the first second, so the call times out while the worker runs — and
+# herdr never registers the name. Confirmed from process state, then named.
+TIMEOUT_ERR = jsonlib.dumps({"error": {
+    "code": "timeout", "message": "timed out waiting for agent startup"}})
+RENAMED = jsonlib.dumps({"result": {"agent": {"pane_id": "w1:p7", "name": "t"}}})
+e = Env(modern_cases(**{
+    "agent start": ("", TIMEOUT_ERR, 1),
+    "pane get": [(pane_get(), "", 0), (pane_get("claude"), "", 0)],
+    "agent rename": (RENAMED, "", 0)}), log_argv=True, api="modern")
+r = e.run("launch", "t", str(e.worktree), "w1")
+check("timeout, worker detected: exit 0", r.returncode == 0)
+check("timeout, worker detected: moved=yes with the stable contract",
+      r.stdout == "pane=w1:p7\ntab=w1:t7\nmoved=yes\nagent=claude\n")
+check("timeout, worker detected: polled until detected", len(e.call_args("pane get")) == 2)
+check("timeout, worker detected: the agent is named after the label, by pane",
+      e.call_args("agent rename") == [["agent", "rename", "w1:p7", "t"]])
+check("timeout, worker detected: started exactly once",
+      len(e.call_args("agent start")) == 1)
+check("timeout, worker detected: tab left alone", "tab close" not in [n for n, _ in e.calls()])
+check("timeout, worker detected: no error on a confirmed launch", "timed out" not in r.stderr)
+e.close()
+
+# --- ...a rename herdr refuses does not unconfirm the worker --------------- #
+taken = jsonlib.dumps({"error": {"code": "agent_name_taken", "message": "agent name t is already used"}})
+e = Env(modern_cases(**{
+    "agent start": ("", TIMEOUT_ERR, 1),
+    "pane get": (pane_get("claude"), "", 0),
+    "agent rename": ("", taken, 1)}), log_argv=True, api="modern")
+r = e.run("launch", "t", str(e.worktree), "w1")
+check("timeout, name taken: still moved=yes", r.returncode == 0 and kv(r.stdout).get("moved") == "yes")
+check("timeout, name taken: named=no on stdout", kv(r.stdout).get("named") == "no")
+check("timeout, name taken: herdr's error and the pane fallback are reported",
+      "agent_name_taken" in r.stderr and "address it by pane" in r.stderr)
+e.close()
+
+# --- ...detection's first `unknown` seconds are polled through ------------- #
+e = Env(modern_cases(**{
+    "agent start": ("", TIMEOUT_ERR, 1),
+    "pane get": [(pane_get("claude", "unknown"), "", 0), (pane_get("claude", "working"), "", 0)],
+    "agent rename": (RENAMED, "", 0)}), log_argv=True, api="modern")
+r = e.run("launch", "t", str(e.worktree), "w1")
+check("timeout, status unknown then working: moved=yes",
+      r.returncode == 0 and kv(r.stdout).get("moved") == "yes")
+check("timeout, status unknown then working: polled until the status was known",
+      len(e.call_args("pane get")) == 2)
+e.close()
+
+# --- ...but a worker held at a prompt (blocked) is not a launch ------------ #
+e = Env(modern_cases(**{
+    "agent start": ("", TIMEOUT_ERR, 1),
+    "pane get": (pane_get("claude", "blocked"), "", 0)}), log_argv=True, api="modern")
+r = e.run("launch", "t", str(e.worktree), "w1")
+check("timeout, blocked: blocked=unverified", r.stdout.startswith("blocked=unverified\n"))
+check("timeout, blocked: says it may be waiting at a prompt", "waiting at a prompt" in r.stderr)
+check("timeout, blocked: stops at the first known state, no rename",
+      len(e.call_args("pane get")) == 1 and not e.call_args("agent rename"))
+e.close()
+
+# --- ...but a timeout with NOTHING detected stays unverified --------------- #
+e = Env(modern_cases(**{
+    "agent start": ("", TIMEOUT_ERR, 1),
+    "pane get": (pane_get(), "", 0)}), log_argv=True, api="modern")
+r = e.run("launch", "t", str(e.worktree), "w1")
+check("timeout, nothing detected: blocked=unverified",
+      r.returncode == 0 and r.stdout.startswith("blocked=unverified\n"))
+check("timeout, nothing detected: herdr's error is relayed", "timed out waiting" in r.stderr)
+check("timeout, nothing detected: bounded polling", len(e.call_args("pane get")) == 3)
+check("timeout, nothing detected: no rename, no second start, tab left alone",
+      not e.call_args("agent rename") and len(e.call_args("agent start")) == 1
+      and "tab close" not in [n for n, _ in e.calls()])
+e.close()
+
+# --- ...and so does a timeout with the WRONG kind in the pane --------------- #
+e = Env(modern_cases(**{
+    "agent start": ("", TIMEOUT_ERR, 1),
+    "pane get": (pane_get("codex"), "", 0)}), log_argv=True, api="modern")
+r = e.run("launch", "t", str(e.worktree), "w1")
+check("timeout, wrong kind: blocked=unverified", r.stdout.startswith("blocked=unverified\n"))
+check("timeout, wrong kind: names what herdr detected", "'codex'" in r.stderr)
+check("timeout, wrong kind: no rename", not e.call_args("agent rename"))
+e.close()
+
 # --- pane-id mismatch on a "successful" start is unverified, not rollback -- #
 mismatch = jsonlib.dumps({"result": {"agent": {"pane_id": "w1:pOTHER"}}})
 e = Env(modern_cases(**{"agent start": (mismatch, "", 0)}), log_argv=True, api="modern")
diff --git a/plugins/work-system/skills/kickoff/SKILL.md b/plugins/work-system/skills/kickoff/SKILL.md
index c59ea497..43a37925 100644
--- a/plugins/work-system/skills/kickoff/SKILL.md
+++ b/plugins/work-system/skills/kickoff/SKILL.md
@@ -467,6 +467,9 @@ is a per-repo committed file (`.claude/work-system-agent`), set via
       stderr, which says what could not be confirmed.
     - **exit 0 with `moved=yes`** → the task is running in its own background tab
       (`tab=<id>`) with worker `agent=<cli:model>`. Report success (template below).
+      A `named=no` line means herdr refused the tab's agent name (e.g. a stale tab
+      holds it): add one line that the worker is addressed by pane `<pane>`, and
+      relay the helper's stderr.
     - **exit 0 with `moved=no`** (legacy herdr only) → the worker started but the tab
       move failed, so it is running as a split in *this* session's tab — tell the user
       it's here, not in a new tab. The helper's stderr for this call carries herdr's own