@brainervirus/workit-opencode 0.8.7 → 0.8.9

package/README.md

@@ -33,7 +33,7 @@ Requirements: OpenCode ≥ 1.15.0, Node ≥ 22 (the published plugin is a self-c
 
 - **Approvals** — flow gates (`workflow_spec_approve` / `workflow_plan_approve` / `workflow_plan_menu`) record native `question` receipts; the self-review validation runs automatically during the transition. Approvals bind to the document's exact SHA-256 digest: editing an approved spec/plan invalidates the approval and forces a fresh reapproval.
 - **Lifecycle** — `workflow_plan_pause` / `workflow_plan_resume` / `workflow_plan_complete` move a plan through `pending`/`active`/`paused`/`completed`, each gated by a one-use native-question receipt; completion requires a complete SDD ledger and passing repository verification.
-- **Delegation** — approved plans execute through subagent-driven task delegation (native `task`); while a subagent-driven plan is active, coordinator product edits are intercepted.
+- **Delegation** — approved plans execute through subagent-driven task delegation (native `task`); while a subagent-driven plan is active, coordinator product edits are intercepted. Receipts are purpose-bound: each gate consumes the newest fresh receipt for exactly its purpose, so unrelated questions never authorize or mask a gate. Delegated authority is direct-child-only — authorized workers receive compact worker-only context, while mismatched session lineage is denied (`delegation_lineage_denied`).
 - **Commit** — `wk-commit` previews a Conventional Commit and confirms through a native `question`.
 - **Handoff** — `wk-handoff` seeds and spawns a native OpenCode continuation session; a destination session presents a four-choice menu (never the originating Handoff option) and carries the handoff-destination marker.
 - **Diagnostics** — durable JSONL journal plus native `client.app.log()`; nothing is mirrored to `process.stderr` or the agent conversation.

package/assets/skills/wk-handoff/SKILL.md

@@ -15,4 +15,6 @@ disable-model-invocation: true
 7. After any `workflow_handoff_session` result—success, partial, or failure—end the originating turn immediately after one status message. Never create todos, execute the plan inline, modify files, retry handoff, or call another tool.
 8. A destination run that executes the plan must still end with `workflow_plan_complete` (or the CLI `workit flow complete`) once the SDD ledger is complete and repository verification passes, and never finish the run while the plan is still `active`.
 
+Handoff titles continuation sessions `Workit: <slug>` (never `Continue <slug>`). OpenCode's native `Continue opencode -s <session-id>` epilogue is the valid manual recovery command when host selection is unavailable (`stage: "select"`): `selected: false` with a `sessionID` is a partial success — use `opencode -s <session-id>` to resume, not a Workit bug.
+
 Never emit a continuation prompt, use the clipboard, or ask the user to copy text. If selected, report the session ID only if the current session remains visible. If staying, report the seeded session ID. On failure, report `stage` and `error`; preserve any returned session for the session picker and never recreate it automatically. `todowrite` and `task` are unnecessary here.

package/assets/skills/wk-implement/SKILL.md

@@ -31,13 +31,15 @@ For every plan task whose ID is absent from `completed_task_ids`:
 3. Use `task` with the built-in `explore` agent for read-only discovery when needed, then a fresh built-in `general` agent to implement from the brief. The parent remains coordinator-only.
 4. Require product changes to follow TDD: failing check first, minimal implementation, passing focused check.
 5. Create the review package with `workflow_sdd_review_package` using `confirmed: true`.
-6. Dispatch separate `general` agents for spec-compliance review and code-quality review. **Blocking findings** (Critical, Important, or spec-compliance) may trigger at most **two** fix+re-review rounds per task. **Advisory** findings (Minor, style, YAGNI, taste) never pause the loop — append them to `<SDD_DIR>/advisories.md` with the task id.
+6. Dispatch separate `general` agents for spec-compliance review and code-quality review. **Blocking findings** (Critical, Important, or spec-compliance) may trigger at most **two** fix+re-review rounds per task. **Advisory** findings (Minor, style, YAGNI, taste) never pause the loop — append them with `workflow_sdd_append_advisory` (`--task <id> --text <text>`) using `confirmed: true`.
 7. Append the validated ledger line with `workflow_sdd_append_progress` using `confirmed: true`, then mark the task completed with `todowrite`.
 
 Each task lands exactly one contiguous non-empty commit range (`base..head`): fix rounds append commits to that range and never rewrite/amend an active review range; each progress line records the task's real base..head shas.
 
 Never redispatch completed task IDs. Pass task briefs and review diffs to agents; do not make them reparse the plan. Keep commits on the in-place feature/bugfix branch.
 
+Delegated authority is direct-child-only: a worker is the session whose host `parentID` exactly equals the activating coordinator's recorded `coordinator_session_id`; missing, mismatched, or multi-owner lineage fails closed with `delegation_lineage_denied`, and nested `opencode` launches are denied during active delegated work. An authorized child receives only the compact worker contract — execute the supplied brief, follow TDD, land one contiguous non-empty commit range, report results — never coordinator guidance, `wk-implement`, or ledger management. Coordinator bookkeeping (briefs, review packages, progress, advisories via `workflow_sdd_*`) stays with the coordinator session.
+
 ## Final gate
 
 After all remaining tasks, dispatch a final full-branch code review, run `workflow_verify`, and report exact per-check results. Present the full `<SDD_DIR>/advisories.md` roll-up once, then use native `question` so the user can choose which advisory items to fix, discuss, or discard. Only then may advisory fixes run. Use `workflow_git_context` for the final commit preview and the `wk-commit` skill for any approved commit. If a tracked stash reference exists, preview reapplication with `question`, then call `workflow_branch_setup` with `confirmed: true` only after approval.

package/assets/templates/execution-contract.md

@@ -7,12 +7,13 @@ Load `using-superpowers`, `subagent-driven-development`, `test-driven-developmen
 
 ## Handoff destination
 
-This session is a handoff destination for a continued plan. The originating session already recorded the post-plan menu choice; present exactly these four choices and never re-offer the originating handoff option:
+This session is a handoff destination for a continued plan. The originating session already recorded the post-plan menu choice; present exactly these four choices plus model deferral and never re-offer the originating handoff option:
 
 - Subagent-driven
 - Inline
 - Review spec first
 - Review plan first
+- Change model first
 
 <workflow-handoff-destination>true</workflow-handoff-destination>
 
@@ -24,6 +25,7 @@ This session is a handoff destination for a continued plan. The originating sess
 - Use native `todowrite` for visible task state as well as the gitignored ledger.
 - Use native `question` for branch/stash choices and guarded external mutations; call mutation tools only after approval with `confirmed: true` (grounded in the recorded NativeChoiceEvidence).
 - Flow-tool confirmations are never agent-typed booleans and never caller-supplied evidence objects: on OpenCode the plugin records the user's native-`question` answer as a host-observed one-use receipt (`attested: true`, `callID`, `selectedLabel`, `recordedAt`) consumed by `workflow_spec_approve` / `workflow_plan_approve` / `workflow_plan_menu` — no evidence argument exists, and delegated worker status comes from host session parentage (`parentID`), never a caller `role` field. On Cursor, confirmations are policy-only (`attested: false`) and subagent-driven execution is rejected as unsupported.
+- Delegated authority is direct-child-only: a worker is the session whose host `parentID` exactly equals the activating coordinator's recorded `coordinator_session_id`; missing, mismatched, or multi-owner lineage fails closed with `delegation_lineage_denied`, and nested `opencode` launches are denied during active delegated work. An authorized child receives only the compact worker contract (execute the supplied brief, follow TDD, land one contiguous non-empty commit range, report results) — never coordinator guidance, `wk-implement`, or ledger management; coordinator bookkeeping via `workflow_sdd_*` stays with the coordinator session.
 - On Cursor, for every repository-scoped `workflow_*` call, pass the active Cursor workspace as `workspace_root`; never rely on the MCP process default.
 - Use native `task` with only the built-in `explore` and `general` agents.
 
@@ -52,7 +54,7 @@ For each top-level task absent from `completed_task_ids`:
 3. Delegate read-only discovery, when needed, to an `explore` agent. Delegate implementation to a fresh `general` agent. Product changes follow TDD.
 4. Create a working-state diff with `workflow_sdd_review_package` and `confirmed: true`.
 5. Delegate spec-compliance review and code-quality review to separate `general` agents.
-6. **Blocking** findings (Critical, Important, or spec-compliance) may trigger at most **two** fix+re-review rounds per task. **Advisory** findings (Minor, style, YAGNI, taste) never pause the loop — append them to `<SDD_DIR>/advisories.md`.
+6. **Blocking** findings (Critical, Important, or spec-compliance) may trigger at most **two** fix+re-review rounds per task. **Advisory** findings (Minor, style, YAGNI, taste) never pause the loop — append them with `workflow_sdd_append_advisory` (`--task <id> --text <text>`, `confirmed: true`) instead of an unrestricted file edit.
 7. Append the validated ledger entry with `workflow_sdd_append_progress` and `confirmed: true`; mark the todo completed.
 
 ## Final gate

package/assets/templates/superpowers-doc-contract.md

@@ -60,10 +60,13 @@ On success, use native `question` / Cursor `AskQuestion` with exactly these opti
 3. Handoff → load `wk-handoff` (new session only)
 4. Review spec first
 5. Review plan first
+6. Change model first
+
+`Change model first` is display-only deferral: it ends the turn without calling `workflow_plan_menu` and re-presents the menu on the next turn. Every other choice must call `workflow_plan_menu` immediately after the answer and before any skill, branch question, mutation, or handoff.
 
 Never emit Superpowers text beginning “Two execution options”.
 
-A handoff destination session (the seeded contract carries `<workflow-handoff-destination>true</workflow-handoff-destination>`) presents exactly four choices — Subagent-driven, Inline, Review spec first, Review plan first — and never re-offers the originating handoff option.
+A handoff destination session (the seeded contract carries `<workflow-handoff-destination>true</workflow-handoff-destination>`) presents exactly five choices — Subagent-driven, Inline, Review spec first, Review plan first, Change model first — and never re-offers the originating handoff option.
 
 - Specs/plans must follow `templates/spec-template.md` / `templates/plan-template.md` (mandated diagrams, tables, CA-XX).
 

package/dist/plugin.js

@@ -14,7 +14,7 @@ var __export = (target, all) => {
 };
 
 // packages/workit-opencode/src/plugin.ts
-import { existsSync as existsSync21, readdirSync as readdirSync11 } from "node:fs";
+import { existsSync as existsSync21, readdirSync as readdirSync12 } from "node:fs";
 import path39 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
@@ -357,7 +357,7 @@ ${contract}
 
 After saving a plan, call \`workflow_docs_validate\` on the spec/plan pair. On failure, stop — do not offer execution.
 
-On success, use native \`question\` with exactly: Subagent-driven, Inline, Handoff (new session only), Review spec first, Review plan first. Never emit Superpowers “Two execution options” prose. No \`--stay\` in this menu.
+On success, use native \`question\` with exactly: Subagent-driven, Inline, Handoff (new session only), Review spec first, Review plan first, Change model first. Change model first is display-only: ends turn without workflow_plan_menu, re-presents menu next turn; real choices call workflow_plan_menu immediately before any skill/branch/mutation/handoff. Never emit Superpowers “Two execution options” prose. No \`--stay\` in this menu.
 
 ## Library documentation
 
@@ -374,13 +374,15 @@ var SOURCE_MENU_LABELS = [
   "Inline",
   "Handoff",
   "Review spec first",
-  "Review plan first"
+  "Review plan first",
+  "Change model first"
 ];
 var DESTINATION_MENU_LABELS = [
   "Subagent-driven",
   "Inline",
   "Review spec first",
-  "Review plan first"
+  "Review plan first",
+  "Change model first"
 ];
 var HANDOFF_DESTINATION_MARKER = "<workflow-handoff-destination>true</workflow-handoff-destination>";
 
@@ -412,6 +414,10 @@ You referenced a doc with a backtick-only path. Deliver docs with a clickable ma
 var SDD_REMINDER_TEXT = `<workflow-sdd-reminder>
 An approved plan is subagent-driven — execute it via \`wk-implement\` / \`task\` delegation. Never implement the approved plan inline in the main session.
 </workflow-sdd-reminder>`;
+var SDD_WORKER_REMINDER_TEXT = `<workflow-sdd-worker>
+You are an authorized delegated worker for an active subagent-driven plan.
+Execute only the supplied task brief: follow TDD (failing test first), land exactly one contiguous non-empty commit range for your task, then report status, commits, and test results to the coordinator. Do not manage coordinator bookkeeping or launch another agent harness.
+</workflow-sdd-worker>`;
 var DOC_RENDER_TEXT = `<workflow-doc-render>
 When delivering a spec or plan, by default render the full markdown content of the doc in chat (headings, tables, mermaid fences preserved) — NOT a backtick-wrapped raw block.
 If the doc exceeds the render threshold (more than 150 lines, over 8KB, or more than 3 mermaid diagrams), deliver only the clickable link \`[spec.md](docs/<slug>/spec.md)\` + a 3-5 bullet summary.
@@ -445,12 +451,11 @@ var shouldInjectBrainstorm = (currentText) => !currentText.includes(BRAINSTORM_T
 var shouldInjectDebug = (currentText) => !currentText.includes(DEBUG_TEXT);
 var shouldInjectReviewReception = (currentText) => !currentText.includes(REVIEW_RECEPTION_TEXT);
 var shouldInjectDocRender = (currentText) => !currentText.includes(DOC_RENDER_TEXT);
-var shouldInjectSddReminder = (currentText) => !currentText.includes(SDD_REMINDER_TEXT);
 var shouldInjectConfigGuard = (currentText) => !currentText.includes(CONFIG_GUARD_TEXT);
 var shouldInjectIssueRail = (currentText) => !currentText.includes(ISSUE_RAIL_TEXT);
 
 // packages/workit-core/src/core/detector.ts
-import { existsSync as existsSync16, readdirSync as readdirSync6, readFileSync as readFileSync17 } from "node:fs";
+import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync17 } from "node:fs";
 import path23 from "node:path";
 
 // packages/workit-core/src/core/init.ts
@@ -1596,7 +1601,11 @@ var checkLauncher = (res) => {
       detail: "no dev checkout found (WORKFLOW_TOOLKIT_DEV) — skipping non-Cursor launcher checks"
     };
   }
-  return { id: "launcher", status: "pass", detail: `${res.host} launcher/hook entries present` };
+  return {
+    id: "launcher",
+    status: "pass",
+    detail: `${res.host} launcher/hook entries present`
+  };
 };
 var checkUtility = (res) => {
   const git = commandOnPath("git", res.env);
@@ -1616,7 +1625,11 @@ var checkUtility = (res) => {
       fix: "Install util-linux (flock)"
     };
   }
-  return { id: "utility", status: "pass", detail: "git (and flock where required) on PATH" };
+  return {
+    id: "utility",
+    status: "pass",
+    detail: "git (and flock where required) on PATH"
+  };
 };
 var staleEntry = (entry) => {
   if (!entry)
@@ -1638,7 +1651,11 @@ var checkStalePin = (res) => {
     };
   }
   if (!existsSync7(res.opencodeConfig)) {
-    return { id: "stale_pin", status: "pass", detail: "no opencode config — not registered" };
+    return {
+      id: "stale_pin",
+      status: "pass",
+      detail: "no opencode config — not registered"
+    };
   }
   const cfg = readJson(res.opencodeConfig);
   const entries = pluginEntries(cfg);
@@ -1669,6 +1686,118 @@ var checkStalePin = (res) => {
   }
   return { id: "stale_pin", status: "pass", detail: "opencode pin resolves" };
 };
+var pluginMcpSelectors = (res) => {
+  const p = path10.join(res.cursorPluginDir, "mcp.json");
+  if (!existsSync7(p))
+    return null;
+  const cfg = readJson(p);
+  const server = cfg?.mcpServers?.workit;
+  if (!server || typeof server !== "object" || Array.isArray(server))
+    return null;
+  const args = server.args;
+  if (!Array.isArray(args))
+    return null;
+  return args.map(String).filter((a) => a.startsWith("--package="));
+};
+var registryLatestVersion = (res) => {
+  const seam = res.env.WORKIT_DOCTOR_STALE_REGISTRY_VERSION;
+  if (typeof seam === "string" && seam) {
+    return /^\d+(?:\.\d+){1,2}$/.test(seam) ? seam : null;
+  }
+  const cmd = res.env.WORKIT_DOCTOR_STALE_REGISTRY_CMD ?? (commandOnPath("npm", res.env) ? "npm" : null);
+  if (!cmd)
+    return null;
+  try {
+    const r = spawnSync2(cmd, ["view", CURSOR_RUNTIME_PACKAGE, "version"], {
+      encoding: "utf8",
+      timeout: 20000,
+      env: res.env
+    });
+    const v = (r.stdout ?? "").trim().split(/\s+/)[0];
+    return r.status === 0 && /^\d+(?:\.\d+){1,2}$/.test(v) ? v : null;
+  } catch {
+    return null;
+  }
+};
+var installedPluginVersion = (res) => {
+  const pkg = readJson(path10.join(res.cursorPluginDir, "package.json"));
+  return typeof pkg?.version === "string" && pkg.version ? pkg.version : null;
+};
+var checkStaleInstall = (res) => {
+  if (res.host !== "cursor" && res.host !== "cli") {
+    return {
+      id: "stale_install",
+      status: "pass",
+      detail: "cursor plugin not inspected on the opencode host"
+    };
+  }
+  const canonicalMcp = cursorMcpServerEntry("").args.find((a) => a.startsWith("--package="));
+  const mcpSelectors = pluginMcpSelectors(res);
+  const legacyPin = (mcpSelectors ?? []).find((s) => s !== canonicalMcp && s.includes("@brainervirus/workit-cursor@"));
+  if (legacyPin) {
+    return {
+      id: "stale_install",
+      status: "fail",
+      detail: `stale_install: plugin mcp.json pins a legacy selector ${legacyPin} (canonical: ${canonicalMcp})`,
+      fix: "Re-run install-cursor-plugin.sh — it rewrites the workit MCP entry to the canonical @latest selector"
+    };
+  }
+  const hooksFile = path10.join(res.cursorPluginDir, "hooks", "hooks-cursor.json");
+  const hookCmd = readJson(hooksFile)?.hooks?.sessionStart?.[0]?.command ?? null;
+  const canonicalHook = canonicalCursorHook;
+  const staleHook = hookCmd !== null && hookCmd !== canonicalHook && !hookCmd.startsWith("node ") && hookCmd.includes("@brainervirus/workit-cursor@");
+  if (staleHook) {
+    return {
+      id: "stale_install",
+      status: "fail",
+      detail: `stale_install: sessionStart hook runs a legacy selector (canonical: ${canonicalHook})`,
+      fix: "Re-run install-cursor-plugin.sh — it rewrites the sessionStart hook to the canonical @latest selector"
+    };
+  }
+  const installed = installedPluginVersion(res);
+  const source = res.dev ? readJson(path10.join(res.dev, "packages/workit-cursor/package.json"))?.version ?? null : readJson(path10.join(packageRoot(), "package.json"))?.version ?? null;
+  const localDist = mcpSelectors === null && hookCmd !== null && hookCmd.startsWith("node ");
+  if (localDist && installed !== null && source !== null && !semverAtLeast(installed, source)) {
+    return {
+      id: "stale_install",
+      status: "fail",
+      detail: `stale_install: installed workit-cursor ${installed} is behind the current runtime ${source}`,
+      fix: "Re-run install-cursor-plugin.sh — it refreshes the plugin directory and rewrites the workit MCP/hook entries"
+    };
+  }
+  if (installed !== null && localDist) {
+    const expected = registryLatestVersion(res);
+    if (expected === null) {
+      return {
+        id: "registry_unreachable",
+        status: "warn",
+        registryProbed: true,
+        detail: "registry_unreachable: cannot compare installed workit-cursor against the published runtime",
+        fix: "Retry when the npm registry is reachable, or re-run install-cursor-plugin.sh to refresh the install"
+      };
+    }
+    if (!semverAtLeast(installed, expected)) {
+      return {
+        id: "stale_install",
+        status: "fail",
+        registryProbed: true,
+        detail: `stale_install: local-dist workit-cursor ${installed} is behind the published runtime ${expected}`,
+        fix: "Re-run install-cursor-plugin.sh — it refreshes the plugin directory with the current build"
+      };
+    }
+    return {
+      id: "stale_install",
+      status: "pass",
+      registryProbed: true,
+      detail: `installed local-dist workit-cursor ${installed} matches the published runtime ${expected}`
+    };
+  }
+  return {
+    id: "stale_install",
+    status: "pass",
+    detail: installed === null ? "installed workit-cursor selectors are canonical" : `installed workit-cursor ${installed} is metadata on the canonical @latest install (fresh at launch)`
+  };
+};
 var checkDuplicateRegistration = (res) => {
   const problems = [];
   const opencodeHost = res.host !== "cursor";
@@ -1704,7 +1833,11 @@ var checkDuplicateRegistration = (res) => {
     }
   }
   if (problems.length === 0) {
-    return { id: "duplicate_registration", status: "pass", detail: "no duplicate registrations" };
+    return {
+      id: "duplicate_registration",
+      status: "pass",
+      detail: "no duplicate registrations"
+    };
   }
   return {
     id: "duplicate_registration",
@@ -1730,7 +1863,11 @@ var checkMalformedConfig = (res) => {
     files.push(res.cursorMcp);
   const bad = files.filter((p) => !parsesAsConfigObject(p));
   if (bad.length === 0)
-    return { id: "malformed_config", status: "pass", detail: "config files parse" };
+    return {
+      id: "malformed_config",
+      status: "pass",
+      detail: "config files parse"
+    };
   return {
     id: "malformed_config",
     status: "fail",
@@ -1741,10 +1878,18 @@ var checkMalformedConfig = (res) => {
 var checkWorkspaceMismatch = (res) => {
   const file = path10.join(res.configDir, "workspaces.json");
   if (!existsSync7(file))
-    return { id: "workspace_mismatch", status: "pass", detail: "no workspaces configured" };
+    return {
+      id: "workspace_mismatch",
+      status: "pass",
+      detail: "no workspaces configured"
+    };
   const ws = readJson(file);
   if (!Array.isArray(ws?.workspaces)) {
-    return { id: "workspace_mismatch", status: "pass", detail: "no workspaces configured" };
+    return {
+      id: "workspace_mismatch",
+      status: "pass",
+      detail: "no workspaces configured"
+    };
   }
   const match = resolveWorkspaceFrom(res.cwd, res.configDir);
   if (match)
@@ -1786,7 +1931,11 @@ var checkCredentialMetadata = (res) => {
     }
   }
   if (tokenPaths.length === 0) {
-    return { id: "credential_metadata", status: "pass", detail: "no credentials configured" };
+    return {
+      id: "credential_metadata",
+      status: "pass",
+      detail: "no credentials configured"
+    };
   }
   const problems = [];
   for (const raw of tokenPaths) {
@@ -1824,7 +1973,11 @@ var checkLogWritable = (res) => {
     mkdirSync3(logsDir, { recursive: true, mode: 448 });
     writeFileSync6(probe, `{"probe":true}
 `, { mode: 384 });
-    return { id: "log_writable", status: "pass", detail: "log directory writable" };
+    return {
+      id: "log_writable",
+      status: "pass",
+      detail: "log directory writable"
+    };
   } catch (err) {
     return {
       id: "log_writable",
@@ -1845,6 +1998,7 @@ var RUN_CHECKS = [
   checkLauncher,
   checkUtility,
   checkStalePin,
+  checkStaleInstall,
   checkDuplicateRegistration,
   checkMalformedConfig,
   checkWorkspaceMismatch,
@@ -1857,21 +2011,27 @@ var INSTALLER_REQUIRED = new Set([
   "launcher",
   "utility",
   "stale_pin",
+  "stale_install",
   "duplicate_registration",
   "malformed_config"
 ]);
 var runDoctor = (options = {}) => {
   const res = resolve(options);
   const raw = RUN_CHECKS.map((fn) => fn(res));
-  const checks = res.installer ? raw.map((c) => c.status === "fail" && !INSTALLER_REQUIRED.has(c.id) ? { ...c, status: "warn", detail: `${c.detail} (not enforced by installer)` } : c) : raw;
+  const checks = res.installer ? raw.map((c) => c.status === "fail" && !INSTALLER_REQUIRED.has(c.id) ? {
+    ...c,
+    status: "warn",
+    detail: `${c.detail} (not enforced by installer)`
+  } : c) : raw;
   const failed = checks.filter((c) => c.status === "fail").length;
   const warned = checks.filter((c) => c.status === "warn").length;
   const passed = checks.filter((c) => c.status === "pass").length;
   const exitCode = failed > 0 ? 1 : 0;
+  const offline = !raw.some((c) => ("registryProbed" in c) && c.registryProbed);
   const report = {
     ok: failed === 0,
     exitCode,
-    offline: true,
+    offline,
     host: res.host,
     checked_at: new Date().toISOString(),
     summary: { passed, warned, failed, total: checks.length },
@@ -1881,7 +2041,7 @@ var runDoctor = (options = {}) => {
   getDiagnosticLogger()?.info(EVENT.doctor, {
     host: res.host,
     exit_code: exitCode,
-    offline: true,
+    offline,
     failed: checks.filter((c) => c.status === "fail").map((c) => c.id),
     total: checks.length
   });
@@ -3713,6 +3873,7 @@ import {
   fsyncSync,
   mkdirSync as mkdirSync9,
   openSync,
+  readdirSync as readdirSync6,
   readFileSync as readFileSync16,
   renameSync as renameSync2,
   rmSync as rmSync2,
@@ -4427,6 +4588,58 @@ function sddAppendProgress({
   const rel = posix2(path19.relative(contained.base, path_));
   return { ok: true, line: trimmed, progress_path: rel };
 }
+function sddAppendAdvisory({
+  advisories_path,
+  task_id,
+  text,
+  workspace_root
+}) {
+  if (typeof task_id !== "number" || !Number.isSafeInteger(task_id) || task_id <= 0) {
+    return { error: "task_id must be a positive safe integer", code: "advisory_task_invalid" };
+  }
+  if (typeof text !== "string") {
+    return {
+      error: "advisory text must be a string of 1-1000 characters after normalization",
+      code: "advisory_text_invalid"
+    };
+  }
+  if (text.includes("\r") || text.includes(`
+`)) {
+    return {
+      error: "advisory text must be a single line (no CR/LF)",
+      code: "advisory_text_invalid"
+    };
+  }
+  const collapsed = text.trim().replace(/[ \t]+/g, " ");
+  if (collapsed.length === 0 || collapsed.length > 1000) {
+    return {
+      error: "advisory text must be 1-1000 characters after trim and horizontal-space collapse",
+      code: "advisory_text_invalid"
+    };
+  }
+  if (!/^docs\/[^/]+\/sdd\/advisories\.md$/.test(advisories_path)) {
+    return {
+      error: `advisories_path must be docs/<slug>/sdd/advisories.md: ${advisories_path}`,
+      code: "advisory_path_invalid"
+    };
+  }
+  const contained = resolveDocsPath({ workspace_root, path: advisories_path });
+  if (!contained.ok)
+    return { error: contained.error, code: "advisory_path_invalid" };
+  const abs = contained.path;
+  if (existsSync12(abs) && statSync5(abs).isDirectory()) {
+    return {
+      error: `advisory target is a directory: ${advisories_path}`,
+      code: "advisory_target_invalid"
+    };
+  }
+  mkdirSync8(path19.dirname(abs), { recursive: true });
+  const line = `- Task ${task_id}: ${collapsed}
+`;
+  appendFileSync(abs, line, "utf8");
+  const rel = posix2(path19.relative(contained.base, abs));
+  return { ok: true, advisory: collapsed, advisories_path: rel };
+}
 
 // packages/workit-core/src/core/verify-project.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -5038,7 +5251,7 @@ root: ${cwd}
 }
 
 // packages/workit-core/src/core/flow-state.ts
-var COORDINATOR_RECOVERY_TEXT = "A subagent-driven plan is active: coordinator product edits are blocked. " + "Delegate product mutations (task briefs, progress, review packages) to an " + "authenticated delegated worker via `task` / `wk-implement` instead of " + "editing in the coordinator session.";
+var COORDINATOR_RECOVERY_TEXT = "A subagent-driven plan is active: coordinator product edits are blocked. " + "Delegate product mutations to an authenticated delegated worker via `task` / `wk-implement` instead of " + "editing in the coordinator session.";
 var CURSOR_SUBAGENT_UNSUPPORTED_TEXT = "Cursor cannot execute subagent-driven plans: the MCP has no child-session " + "support. Choose Inline, Handoff, or a review option in this session, or " + "run the plan in OpenCode with `wk-implement`.";
 var MENU_CHOICES = [
   "subagent-driven",
@@ -5098,7 +5311,8 @@ var normalizeState = (parsed, slug) => {
     execution: {
       status: execution.status ?? "pending",
       mode: execution.mode ?? null,
-      evidence: execution.evidence ?? null
+      evidence: execution.evidence ?? null,
+      coordinator_session_id: execution.coordinator_session_id ?? null
     },
     handoff_destination: p.handoff_destination ?? false,
     updated_at: p.updated_at ?? Date.now()
@@ -5110,7 +5324,7 @@ var emptyState = (slug) => ({
   spec: { path: "", status: "draft", evidence: null, approved_digest: null },
   plan: { path: "", status: "draft", evidence: null, approved_digest: null },
   menu: { presented: false, chosen: "", evidence: null },
-  execution: { status: "pending", mode: null, evidence: null },
+  execution: { status: "pending", mode: null, evidence: null, coordinator_session_id: null },
   handoff_destination: false,
   updated_at: Date.now()
 });
@@ -5226,6 +5440,12 @@ var validateState = (parsed, slug) => {
   if (execRaw?.evidence !== undefined && !validateEvidenceValue(execRaw.evidence, true)) {
     return { ok: false, error: "flow state execution.evidence has an unsupported shape" };
   }
+  if (execRaw?.coordinator_session_id !== undefined && execRaw.coordinator_session_id !== null && typeof execRaw.coordinator_session_id !== "string") {
+    return {
+      ok: false,
+      error: "flow state execution.coordinator_session_id must be a string or null"
+    };
+  }
   return {
     ok: true,
     state: {
@@ -5241,7 +5461,8 @@ var validateState = (parsed, slug) => {
       execution: {
         status: execRaw?.status ?? "pending",
         mode: execRaw?.mode ?? null,
-        evidence: execRaw?.evidence ?? null
+        evidence: execRaw?.evidence ?? null,
+        coordinator_session_id: execRaw?.coordinator_session_id ?? null
       },
       handoff_destination: parsed.handoff_destination ?? false,
       updated_at: parsed.updated_at ?? Date.now()
@@ -5378,7 +5599,7 @@ var resetForSpecDrift = (state) => ({
   spec: { ...state.spec, status: "draft", evidence: null, approved_digest: null },
   plan: { ...state.plan, status: "draft", evidence: null, approved_digest: null },
   menu: { presented: false, chosen: "", evidence: null },
-  execution: { status: "pending", mode: null, evidence: null },
+  execution: { status: "pending", mode: null, evidence: null, coordinator_session_id: null },
   handoff_destination: false,
   updated_at: Date.now()
 });
@@ -5421,9 +5642,14 @@ var reconcileState = (root2, slug, state) => {
 var deriveLegacyExecution = (root2, slug, state) => {
   const ledger = ledgerCompletion(root2, slug);
   if (state.plan.status === "approved" && state.menu.chosen === "subagent-driven" && ledger.started && !ledger.complete) {
-    return { status: "active", mode: "subagent-driven", evidence: null };
+    return {
+      status: "active",
+      mode: "subagent-driven",
+      evidence: null,
+      coordinator_session_id: null
+    };
   }
-  return { status: "pending", mode: null, evidence: null };
+  return { status: "pending", mode: null, evidence: null, coordinator_session_id: null };
 };
 var normalizeCompatibility = (root2, slug, parsed, state) => {
   if (!isRecord(parsed) || !("execution" in parsed)) {
@@ -5432,6 +5658,11 @@ var normalizeCompatibility = (root2, slug, parsed, state) => {
     if (derived.status !== current.status || derived.mode !== current.mode) {
       return { state: { ...state, execution: derived, updated_at: Date.now() }, changed: true };
     }
+    return { state, changed: false };
+  }
+  const execRaw = isRecord(parsed.execution) ? parsed.execution : undefined;
+  if (execRaw && !("coordinator_session_id" in execRaw)) {
+    return { state: { ...state, updated_at: Date.now() }, changed: true };
   }
   return { state, changed: false };
 };
@@ -5566,15 +5797,6 @@ var assertMutationWorkspace = (root2, ctx) => {
   }
   return { ok: true };
 };
-var assertCoordinatorBoundary = (ctx, state) => {
-  if (ctx?.role === "coordinator" && state.execution.status === "active" && state.execution.mode === "subagent-driven") {
-    return err2("coordinator_blocked", COORDINATOR_RECOVERY_TEXT);
-  }
-  if (ctx?.role === "delegated" && !ctx.taskIdentity) {
-    return err2("delegated_unauthenticated", "delegated mutations require an authenticated task identity (taskIdentity) — re-run inside the delegated worker session");
-  }
-  return { ok: true };
-};
 var MAX_CLOCK_SKEW_MS = 60000;
 var MAX_RECEIPTS_PER_SESSION = 10;
 var RECEIPT_FRESHNESS_MS = 10 * 60 * 1000;
@@ -5603,19 +5825,49 @@ var isNegativeLabel = (label) => {
     return firstWord.replace(/[^a-z]/g, "") === entry;
   });
 };
+var receiptPurposeForLabel = (label) => {
+  const n = normalizeLabel(label);
+  if (n === "approve spec" || n === "approve spec recommended")
+    return "spec-approval";
+  if (n === "approve plan" || n === "approve plan recommended")
+    return "plan-approval";
+  if (n === "approve")
+    return;
+  if (n === "pause plan")
+    return "plan-pause";
+  if (n === "resume plan")
+    return "plan-resume";
+  if (n === "complete plan")
+    return "plan-complete";
+  const exec = new Set([
+    "subagent driven",
+    "inline",
+    "handoff",
+    "review spec",
+    "review plan",
+    "change model"
+  ]);
+  if (exec.has(n))
+    return "execution-menu";
+  return;
+};
 
 class HostReceiptStore {
   #bySession = new Map;
-  record(sessionId, callID, selectedLabel, recordedAt = Date.now(), question) {
-    const label = selectedLabel.trim();
-    if (!label)
+  record(sessionId, callID, selectedLabel, recordedAt = Date.now(), question = "", purpose) {
+    const trimmed = selectedLabel.trim();
+    if (!trimmed)
       return;
     if (recordedAt > Date.now() + MAX_CLOCK_SKEW_MS)
       return;
+    const derived = purpose ?? receiptPurposeForLabel(selectedLabel);
+    if (derived === undefined)
+      return;
+    const q = question ?? "";
     const queue = this.#bySession.get(sessionId) ?? [];
     if (queue.length >= MAX_RECEIPTS_PER_SESSION)
       queue.shift();
-    queue.push({ sessionId, callID, selectedLabel: label, recordedAt, question });
+    queue.push({ sessionId, callID, selectedLabel, recordedAt, question: q, purpose: derived });
     this.#bySession.set(sessionId, queue);
   }
   count(sessionId) {
@@ -5632,10 +5884,40 @@ class HostReceiptStore {
     if (!queue || queue.length === 0) {
       return err2("receipt_missing", "no host-observed native-question receipt for this session — ask the native " + "`question` tool and have the user answer before calling this tool");
     }
-    const index = queue.length - 1;
+    let index = -1;
+    if (opts.purpose !== undefined) {
+      const top = queue[queue.length - 1];
+      if (top && top.purpose === opts.purpose && isNegativeLabel(top.selectedLabel)) {
+        const filtered = queue.filter((r) => r.purpose !== opts.purpose);
+        if (filtered.length === 0)
+          this.#bySession.delete(sessionId);
+        else
+          this.#bySession.set(sessionId, filtered);
+        return err2("receipt_rejected", `the user's most recent answer (${JSON.stringify(top.selectedLabel)}) is a ` + "negative answer — it cannot authorize an approval; ask the native question again");
+      }
+      for (let i = queue.length - 1;i >= 0; i--) {
+        if (queue[i].purpose === opts.purpose) {
+          index = i;
+          break;
+        }
+      }
+      if (index === -1) {
+        return err2("receipt_missing", `no host-observed receipt for purpose ${JSON.stringify(opts.purpose)} — ask the native question for that purpose`);
+      }
+    } else {
+      index = queue.length - 1;
+    }
     const receipt = queue[index];
     if (isNegativeLabel(receipt.selectedLabel)) {
-      this.#bySession.delete(sessionId);
+      if (opts.purpose !== undefined) {
+        const filtered = queue.filter((r) => r.purpose !== opts.purpose);
+        if (filtered.length === 0)
+          this.#bySession.delete(sessionId);
+        else
+          this.#bySession.set(sessionId, filtered);
+      } else {
+        this.#bySession.delete(sessionId);
+      }
       return err2("receipt_rejected", `the user's most recent answer (${JSON.stringify(receipt.selectedLabel)}) is a ` + "negative answer — it cannot authorize an approval; ask the native question again");
     }
     if (opts.label !== undefined && !sameChoiceLabel(receipt.selectedLabel, opts.label)) {
@@ -5769,7 +6051,7 @@ var prepareFlowState = (root2, slug, opts = {}, ctx) => {
         spec: { path: specPath, status: "draft", evidence: null, approved_digest: null },
         plan: { path: planPath, status: "draft", evidence: null, approved_digest: null },
         menu: { presented: false, chosen: "", evidence: null },
-        execution: { status: "pending", mode: null, evidence: null },
+        execution: { status: "pending", mode: null, evidence: null, coordinator_session_id: null },
         handoff_destination: false,
         updated_at: Date.now()
       });
@@ -5915,13 +6197,24 @@ var recordMenuChoice = (root2, slug, planPath, choice, evidence, ctx) => {
       return err2("recursive_handoff", "this flow is already a handoff destination — a second handoff is rejected");
     }
     const executing = choice === "subagent-driven" || choice === "inline";
+    const coordinatorSessionId = choice === "subagent-driven" && recorded.evidence.host === "opencode" ? ctx?.sessionId ?? null : null;
     return {
       ok: true,
       next: {
         ...state,
         plan: { ...state.plan, path: state.plan.path || `docs/${slug}/plan.md` },
         menu: { presented: true, chosen: choice, evidence: recorded.evidence },
-        execution: executing ? { status: "active", mode: choice, evidence: recorded.evidence } : { status: "pending", mode: null, evidence: recorded.evidence },
+        execution: executing ? {
+          status: "active",
+          mode: choice,
+          evidence: recorded.evidence,
+          coordinator_session_id: coordinatorSessionId
+        } : {
+          status: "pending",
+          mode: null,
+          evidence: recorded.evidence,
+          coordinator_session_id: null
+        },
         updated_at: Date.now()
       }
     };
@@ -6015,7 +6308,7 @@ var completeExecution = (root2, slug, deps) => {
     }
     const next = {
       ...reconciled.state,
-      execution: { ...exec, status: "completed" },
+      execution: { ...exec, status: "completed", coordinator_session_id: null },
       handoff_destination: false,
       updated_at: Date.now()
     };
@@ -6079,7 +6372,7 @@ var slugFromSddPath = (p) => {
   const match = p.split(path22.sep).join("/").match(/^docs\/([^/]+)\/sdd(\/|$|['"])/);
   return match?.[1] ?? "";
 };
-var assertFlowGates = (root2, planPath, opts = {}) => {
+var assertHandoffReady = (root2, planPath) => {
   const doc = resolveDoc(root2, "", planPath, "plan");
   if (!doc.ok)
     return err2("path_invalid", doc.error);
@@ -6094,12 +6387,15 @@ var assertFlowGates = (root2, planPath, opts = {}) => {
   if (state.plan.status !== "approved") {
     return err2("plan_not_approved", `plan not approved (status: ${state.plan.status}). Run workflow_plan_approve after the user's approval.`);
   }
-  if (opts.requireMenu && !state.menu.presented) {
-    return err2("menu_not_presented", "post-plan menu not presented. Ask the native question menu (Subagent-driven/Inline/Handoff/Review spec/Review plan) and record the answer with workflow_plan_menu.");
+  if (state.handoff_destination) {
+    return err2("recursive_handoff", "this flow is already a handoff destination — a second handoff is rejected");
+  }
+  if (!state.menu.presented || state.menu.chosen !== "handoff") {
+    return err2("handoff_not_chosen", `handoff requires the execution menu choice "handoff" (chosen: ${JSON.stringify(state.menu.chosen)}, presented: ${state.menu.presented})`);
   }
   return { ok: true };
 };
-var assertProductGates = (root2, slug, opts = {}, ctx) => {
+var assertSddControlGates = (root2, slug, opts = {}, ctx) => {
   const bound = assertMutationWorkspace(root2, ctx);
   if (!bound.ok)
     return bound;
@@ -6125,9 +6421,12 @@ var assertProductGates = (root2, slug, opts = {}, ctx) => {
     if (validated.ok === false)
       return err2("docs_invalid", validated.error);
   }
-  return assertCoordinatorBoundary(ctx, state);
+  if (state.execution.status === "active" && state.execution.mode === "subagent-driven" && roleFromParentage(ctx?.parentSessionId, state.execution.coordinator_session_id) === "delegated") {
+    return err2("sdd_control_denied", "SDD control metadata is coordinator-owned while a subagent-driven plan is active — delegated workers cannot mutate task briefs, review packages, progress, or advisories");
+  }
+  return { ok: true };
 };
-var roleFromParentage = (parentID) => parentID ? "delegated" : "coordinator";
+var roleFromParentage = (parentID, coordinatorSessionId) => typeof parentID === "string" && parentID !== "" && parentID === coordinatorSessionId ? "delegated" : "coordinator";
 var COORDINATOR_WRITE_TOOLS = [
   "write",
   "edit",
@@ -6152,9 +6451,6 @@ var COORDINATOR_WRITE_TOOLS = [
   "workflow_docs_promote",
   "workflow_docs_layout",
   "workflow_docs_repo_link",
-  "workflow_sdd_task_brief",
-  "workflow_sdd_review_package",
-  "workflow_sdd_append_progress",
   "workflow_youtrack_post",
   "workflow_youtrack_log_time"
 ];
@@ -6459,10 +6755,34 @@ var isCoordinatorBashAllowed = (command) => {
 };
 var COORDINATOR_SHELL_DENIED_TEXT = "Coordinator shell commands are restricted while a subagent-driven plan is " + "active: only bounded read/test/review commands are allowed (the exact " + "allowlist is in flow-state.ts, isCoordinatorBashAllowed). " + COORDINATOR_RECOVERY_TEXT;
 var subagentDrivenInterception = (input) => {
-  if (input.parentID)
+  const ids = Array.from(new Set((input.activeCoordinatorIds ?? []).filter((id) => typeof id === "string" && id !== "")));
+  const parent = typeof input.parentID === "string" && input.parentID !== "" ? input.parentID : null;
+  const legacyActive = input.active === true;
+  if (!legacyActive && ids.length === 0)
     return { ok: true };
-  if (!input.active)
+  if (parent !== null && ids.length === 1 && ids[0] === parent) {
+    if (input.tool === "bash") {
+      const tokens = (input.command ?? "").split(/[\s'"]+/).filter(Boolean);
+      const launchesOpencode = tokens.some((t) => t.split("/").pop() === "opencode");
+      if (launchesOpencode) {
+        return err2("delegation_lineage_denied", "nested opencode launch is denied while a subagent-driven plan is active");
+      }
+    }
+    if ([
+      "workflow_sdd_task_brief",
+      "workflow_sdd_review_package",
+      "workflow_sdd_append_progress",
+      "workflow_sdd_append_advisory"
+    ].includes(input.tool)) {
+      return err2("delegation_lineage_denied", "SDD control metadata is coordinator-owned — workers execute briefs, not bookkeeping");
+    }
     return { ok: true };
+  }
+  if (parent !== null) {
+    if (!legacyActive || ids.length > 0) {
+      return err2("delegation_lineage_denied", "delegated writes require an exact direct-parent match to the activating coordinator");
+    }
+  }
   if (COORDINATOR_WRITE_TOOLS.includes(input.tool)) {
     return err2("coordinator_write_denied", COORDINATOR_RECOVERY_TEXT);
   }
@@ -6473,6 +6793,24 @@ var subagentDrivenInterception = (input) => {
   }
   return { ok: true };
 };
+var findActiveSubagentDrivenContexts = (root2) => {
+  let entries = [];
+  try {
+    entries = readdirSync6(path22.join(root2, "docs"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const slug of entries) {
+    try {
+      const state = readFlowState(root2, slug);
+      if (state.execution.status === "active" && state.execution.mode === "subagent-driven") {
+        out.push({ slug, coordinator_session_id: state.execution.coordinator_session_id });
+      }
+    } catch {}
+  }
+  return out;
+};
 
 // packages/workit-core/src/core/detector.ts
 var detectConfigGapError = (text) => text.includes(CONFIG_GAP_MARKER);
@@ -6593,7 +6931,7 @@ var scanActiveSubagentDrivenPlans = (root2) => {
     if (exec.status === "active" && exec.mode === "subagent-driven")
       slugs.push(slug);
   };
-  for (const slug of readdirSync6(docsDir)) {
+  for (const slug of readdirSync7(docsDir)) {
     const file = path23.join(docsDir, slug, "sdd", "flow.json");
     if (!existsSync16(file))
       continue;
@@ -19808,15 +20146,21 @@ var opencodeMutationContext = async (context2, client) => {
     const session = await client?.session.get({ path: { id: context2.sessionID } });
     parentID = session?.data?.parentID;
   } catch {}
-  const role = roleFromParentage(parentID);
+  const role = roleFromParentage(parentID, undefined);
   return {
     hostWorkspace: context2.directory,
     role,
     sessionId: context2.sessionID,
+    parentSessionId: parentID,
     taskIdentity: role === "delegated" ? context2.sessionID : undefined
   };
 };
 function createFlowTools(receipts, client) {
+  const purposeForLifecycle = {
+    "Pause plan": "plan-pause",
+    "Resume plan": "plan-resume",
+    "Complete plan": "plan-complete"
+  };
   const lifecycleTool = (action, label, description) => tool({
     description,
     args: {
@@ -19827,7 +20171,10 @@ function createFlowTools(receipts, client) {
       if ("error" in slugged)
         return output2(fail(slugged.error));
       const slug = slugged.slug;
-      const consumed = receipts.consume(context2.sessionID, { label });
+      const consumed = receipts.consume(context2.sessionID, {
+        purpose: purposeForLifecycle[label],
+        label
+      });
       if (!consumed.ok)
         return output2(fail(consumed.error, { code: consumed.code }));
       const result = transitionExecution(context2.directory, slug, plan_path, action, createOpenCodeEvidence(consumed.receipt), await opencodeMutationContext(context2, client));
@@ -19897,7 +20244,7 @@ function createFlowTools(receipts, client) {
         if ("error" in slugged)
           return output2(fail(slugged.error));
         const slug = slugged.slug;
-        const consumed = receipts.consume(context2.sessionID);
+        const consumed = receipts.consume(context2.sessionID, { purpose: "spec-approval" });
         if (!consumed.ok)
           return output2(fail(consumed.error, { code: consumed.code }));
         const result = transitionSpec(context2.directory, slug, spec_path, createOpenCodeEvidence(consumed.receipt), await opencodeMutationContext(context2, client));
@@ -19916,7 +20263,7 @@ function createFlowTools(receipts, client) {
         if ("error" in slugged)
           return output2(fail(slugged.error));
         const slug = slugged.slug;
-        const consumed = receipts.consume(context2.sessionID);
+        const consumed = receipts.consume(context2.sessionID, { purpose: "plan-approval" });
         if (!consumed.ok)
           return output2(fail(consumed.error, { code: consumed.code }));
         const result = transitionPlan(context2.directory, slug, plan_path, createOpenCodeEvidence(consumed.receipt), await opencodeMutationContext(context2, client));
@@ -19942,7 +20289,10 @@ function createFlowTools(receipts, client) {
         if ("error" in slugged)
           return output2(fail(slugged.error));
         const slug = slugged.slug;
-        const consumed = receipts.consume(context2.sessionID, { label: choice });
+        const consumed = receipts.consume(context2.sessionID, {
+          purpose: "execution-menu",
+          label: choice
+        });
         if (!consumed.ok)
           return output2(fail(consumed.error, { code: consumed.code }));
         const result = recordMenuChoice(context2.directory, slug, plan_path, choice, createOpenCodeEvidence(consumed.receipt), await opencodeMutationContext(context2, client));
@@ -19961,11 +20311,11 @@ function createFlowTools(receipts, client) {
 // packages/workit-opencode/src/tools/sdd.ts
 var output3 = (value) => JSON.stringify(value, null, 2);
 var requireConfirmed2 = (confirmed) => confirmed === true ? null : output3(fail("confirmed: true required"));
-var gateProductWrite = async (root2, sddPath, context2, client) => {
+var gateSddControl = async (root2, sddPath, context2, client) => {
   const slug = slugFromSddPath(sddPath);
   if (!slug)
     return output3(fail("could not derive slug — expected docs/<slug>/sdd/..."));
-  const gate = assertProductGates(root2, slug, { requireMenu: true, requireDocs: true }, await opencodeMutationContext(context2, client));
+  const gate = assertSddControlGates(root2, slug, { requireMenu: true, requireDocs: true }, await opencodeMutationContext(context2, client));
   if (!gate.ok)
     return output3(fail(gate.error, { code: gate.code }));
   return null;
@@ -20112,7 +20462,7 @@ function createSddTools(state, client) {
         const rejected = requireConfirmed2(confirmed);
         if (rejected)
           return rejected;
-        const gated = await gateProductWrite(context2.directory, sdd_dir, context2, client);
+        const gated = await gateSddControl(context2.directory, sdd_dir, context2, client);
         if (gated)
           return gated;
         return invoke(() => {
@@ -20145,7 +20495,7 @@ function createSddTools(state, client) {
         } catch (error45) {
           return output3(fail(error45 instanceof Error ? error45.message : "workflow operation failed"));
         }
-        const gated = await gateProductWrite(context2.directory, sdd_dir, context2, client);
+        const gated = await gateSddControl(context2.directory, sdd_dir, context2, client);
         if (gated)
           return gated;
         return invoke(() => sddReviewPackage({
@@ -20167,7 +20517,7 @@ function createSddTools(state, client) {
         const rejected = requireConfirmed2(confirmed);
         if (rejected)
           return rejected;
-        const gated = await gateProductWrite(context2.directory, progress_path, context2, client);
+        const gated = await gateSddControl(context2.directory, progress_path, context2, client);
         if (gated)
           return gated;
         return invoke(() => {
@@ -20175,6 +20525,32 @@ function createSddTools(state, client) {
           return sddAppendProgress({ progress_path, line, workspace_root: context2.directory });
         });
       }
+    }),
+    workflow_sdd_append_advisory: tool({
+      description: "Append a validated advisory line to docs/<slug>/sdd/advisories.md (coordinator-owned).",
+      args: {
+        confirmed: tool.schema.boolean(),
+        advisories_path: tool.schema.string(),
+        task_id: tool.schema.number(),
+        text: tool.schema.string()
+      },
+      execute: async ({ confirmed, advisories_path, task_id, text }, context2) => {
+        const rejected = requireConfirmed2(confirmed);
+        if (rejected)
+          return rejected;
+        const gated = await gateSddControl(context2.directory, advisories_path, context2, client);
+        if (gated)
+          return gated;
+        return invoke(() => {
+          relativePath(context2.directory, advisories_path);
+          return sddAppendAdvisory({
+            advisories_path,
+            task_id,
+            text,
+            workspace_root: context2.directory
+          });
+        });
+      }
     })
   };
 }
@@ -20186,12 +20562,12 @@ import path32 from "node:path";
 import path31 from "node:path";
 
 // packages/workit-core/src/core/handoff-context.ts
-import { existsSync as existsSync18, readFileSync as readFileSync20, readdirSync as readdirSync7, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync8 } from "node:fs";
 import path30 from "node:path";
 var DOC_RE = /docs\/([A-Za-z0-9][A-Za-z0-9._-]*)\/(spec|plan)\.md/g;
 var listMd = (dir) => {
   try {
-    return readdirSync7(dir).filter((f) => f.endsWith(".md")).sort();
+    return readdirSync8(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -20217,7 +20593,7 @@ var resolveActivePair = (root2) => {
   let best = null;
   let entries = [];
   try {
-    entries = readdirSync7(docsDir);
+    entries = readdirSync8(docsDir);
   } catch {
     return { error: "no pair" };
   }
@@ -20394,21 +20770,13 @@ function createHandoffTools(client, state) {
         const active = built;
         const slug = slugFromPath(active.plan);
         try {
-          const gate = assertFlowGates(context2.directory, active.plan);
-          if (!gate.ok)
-            return output4(fail(gate.error));
-          const preflight = readEffectiveFlowState(context2.directory, slug);
-          if (!preflight.ok)
-            return output4(fail(preflight.error, { code: preflight.code }));
-          if (preflight.state.handoff_destination) {
-            return output4(fail("this flow is already a handoff destination — a second handoff is rejected", {
-              code: "recursive_handoff"
-            }));
-          }
+          const ready = assertHandoffReady(context2.directory, active.plan);
+          if (!ready.ok)
+            return output4(fail(ready.error, { code: ready.code }));
           state.set(context2.sessionID, { spec: active.spec, plan: active.plan, sdd: active.sdd });
           return output4(await handoffSession(client, {
             directory: context2.directory,
-            title: `Continue ${path32.basename(path32.dirname(active.plan))}`,
+            title: `Workit: ${path32.basename(path32.dirname(active.plan))}`,
             prompt: active.prompt,
             stay: /(?:^|\s)--stay(?:\s|$)/.test(userMessage),
             afterSeed: () => idempotentMarkDestination(context2.directory, slug, active.plan)
@@ -20903,7 +21271,7 @@ function createPresentTools() {
 }
 
 // packages/workit-core/src/core/docs-repo.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync22, writeFileSync as writeFileSync12, readdirSync as readdirSync8 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync22, writeFileSync as writeFileSync12, readdirSync as readdirSync9 } from "node:fs";
 import { execFileSync as execFileSync5 } from "node:child_process";
 import path35 from "node:path";
 var configPath2 = () => process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path35.join(configDir(), "docs-repo.json");
@@ -20949,7 +21317,7 @@ var listSpecs = (workspaceRoot) => {
   const specs = [];
   const docsDir = path35.join(workspaceRoot, "docs");
   if (existsSync19(docsDir)) {
-    for (const slug of readdirSync8(docsDir)) {
+    for (const slug of readdirSync9(docsDir)) {
       if (slug.startsWith("."))
         continue;
       const spec = path35.posix.join("docs", slug, "spec.md");
@@ -20960,7 +21328,7 @@ var listSpecs = (workspaceRoot) => {
       if (repoPath) {
         const featuresDir = path35.join(repoPath, "features");
         if (existsSync19(featuresDir)) {
-          const match = readdirSync8(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d));
+          const match = readdirSync9(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d));
           if (match) {
             promoted = true;
             target = path35.join(repoPath, "features", match);
@@ -21052,7 +21420,7 @@ var promoteSpec = (workspaceRoot, slug, opts) => {
   }
   const prefix = monthPrefix();
   const featuresDir = path35.join(repoPath, "features");
-  const existing = existsSync19(featuresDir) ? readdirSync8(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d)) : undefined;
+  const existing = existsSync19(featuresDir) ? readdirSync9(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d)) : undefined;
   const targetDir = path35.join(featuresDir, existing ?? `${prefix}-${slug}`);
   mkdirSync10(targetDir, { recursive: true });
   const files = ["spec.md"];
@@ -21114,7 +21482,7 @@ import {
   existsSync as existsSync20,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync11,
-  readdirSync as readdirSync9,
+  readdirSync as readdirSync10,
   readFileSync as readFileSync23,
   realpathSync as realpathSync5,
   renameSync as renameSync3,
@@ -21169,7 +21537,7 @@ var detectLegacyDocs = (workspace_root) => {
   const root2 = legacyRoot(workspace_root);
   const raw = [];
   if (existsSync20(root2)) {
-    for (const entry of readdirSync9(root2, { withFileTypes: true })) {
+    for (const entry of readdirSync10(root2, { withFileTypes: true })) {
       const abs = path36.join(root2, entry.name);
       const rel = posix3(path36.relative(workspace_root, abs));
       if (entry.isDirectory()) {
@@ -21311,7 +21679,7 @@ var planTree = (workspace, legacyAbs, legacyRel, destRelRoot, destAbsRoot, legac
   if (visits.has(real))
     return { ok: true };
   visits.add(real);
-  for (const entry of readdirSync9(real, { withFileTypes: true })) {
+  for (const entry of readdirSync10(real, { withFileTypes: true })) {
     const fromAbs = path36.join(real, entry.name);
     const fromRel = posix3(path36.join(legacyRel, entry.name));
     const toRel = posix3(path36.join(destRelRoot, entry.name));
@@ -21682,7 +22050,7 @@ SDD: ${value.sdd}` : null;
 }
 
 // packages/workit-core/src/core/logger.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync12, readdirSync as readdirSync10, unlinkSync as unlinkSync3 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync12, readdirSync as readdirSync11, unlinkSync as unlinkSync3 } from "node:fs";
 import os4 from "node:os";
 import path37 from "node:path";
 var REDACTED = "[REDACTED]";
@@ -21817,7 +22185,7 @@ var dailyFileName = (date5) => {
 };
 var pruneOldFiles = (dir) => {
   try {
-    const files = readdirSync10(dir).filter((name) => DAY_FILE.test(name)).sort().reverse();
+    const files = readdirSync11(dir).filter((name) => DAY_FILE.test(name)).sort().reverse();
     for (const file2 of files.slice(RETAINED_DAYS)) {
       try {
         unlinkSync3(path37.join(dir, file2));
@@ -21984,7 +22352,7 @@ var hasMarkedDestination = (root3) => {
     return false;
   let slugs;
   try {
-    slugs = readdirSync11(docsDir);
+    slugs = readdirSync12(docsDir);
   } catch {
     return false;
   }
@@ -22016,6 +22384,32 @@ var questionAnswerLabel = (result) => {
   const label = first[0];
   return typeof label === "string" ? label : undefined;
 };
+var classifyQuestion = (input, label) => {
+  const args = input;
+  const qs = args?.questions;
+  if (Array.isArray(qs)) {
+    if (qs.length !== 1)
+      return null;
+    const q = qs[0];
+    if (!q || typeof q !== "object")
+      return null;
+    if (q.multiple === true)
+      return null;
+    const opts = q.options;
+    if (Array.isArray(opts) && opts.length === 0 && q.custom === true)
+      return null;
+    if (!Array.isArray(opts) || opts.length === 0)
+      return null;
+    const purpose2 = receiptPurposeForLabel(label);
+    if (purpose2 === undefined)
+      return null;
+    return { purpose: purpose2, questionText: typeof q.question === "string" ? q.question : undefined };
+  }
+  const purpose = receiptPurposeForLabel(label);
+  if (purpose !== undefined)
+    return { purpose, questionText: undefined };
+  return null;
+};
 var plugin = async ({ client, directory }) => {
   openCodeClient = client;
   installUncaughtHandlers();
@@ -22025,6 +22419,17 @@ var plugin = async ({ client, directory }) => {
   setDiagnosticLogger(logger);
   const state = new WorkflowStateStore;
   const receipts = new HostReceiptStore;
+  const authorizedWorkerFor = async (sessionID) => {
+    const ids = findActiveSubagentDrivenContexts(directory).map((c) => c.coordinator_session_id).filter((id) => typeof id === "string" && id !== "");
+    if (ids.length !== 1)
+      return false;
+    try {
+      const session = await client.session.get({ path: { id: sessionID } });
+      return session?.data?.parentID === ids[0];
+    } catch {
+      return false;
+    }
+  };
   return {
     tool: createTools(adaptPluginHandoffClient(client), state, client, receipts),
     "tool.execute.after": async (input, output10) => {
@@ -22033,9 +22438,11 @@ var plugin = async ({ client, directory }) => {
       const label = questionAnswerLabel(output10);
       if (label === undefined)
         return;
-      const args = input.args;
-      const questionText = args?.question ?? args?.title;
-      receipts.record(input.sessionID, input.callID, label, Date.now(), questionText);
+      const classified = classifyQuestion(input.args, label);
+      if (!classified)
+        return;
+      const questionText = classified.questionText ?? input.args?.question ?? input.args?.title;
+      receipts.record(input.sessionID, input.callID, label, Date.now(), questionText, classified.purpose);
     },
     "tool.execute.before": async (input, output10) => {
       if (input.tool !== "bash" && !COORDINATOR_WRITE_TOOLS.includes(input.tool))
@@ -22047,12 +22454,12 @@ var plugin = async ({ client, directory }) => {
         parentID = session?.data?.parentID;
         sessionDirectory = session?.data?.directory;
       } catch {}
-      const active = findActiveSubagentDrivenPlans(sessionDirectory ?? directory).length > 0;
+      const activeCoordinatorIds = findActiveSubagentDrivenContexts(sessionDirectory ?? directory).map((c) => c.coordinator_session_id).filter((id) => typeof id === "string" && id !== "");
       const decision = subagentDrivenInterception({
         tool: input.tool,
         command: output10.args?.command,
         parentID,
-        active
+        activeCoordinatorIds
       });
       if (!decision.ok)
         throw new Error(decision.error);
@@ -22105,7 +22512,8 @@ var plugin = async ({ client, directory }) => {
           const firstAnchor = firstUser.parts.find((part) => part.type === "text") ?? firstUser.parts[0];
           const firstText = firstUser.parts.filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
 `);
-          const bootstrap = getWorkitBootstrap();
+          const workerAuthorized = await authorizedWorkerFor(firstAnchor.sessionID);
+          const bootstrap = workerAuthorized ? null : getWorkitBootstrap();
           if (bootstrap && !firstText.includes("<workit-contract>")) {
             firstUser.parts.unshift({
               id: firstAnchor.id,
@@ -22114,6 +22522,14 @@ var plugin = async ({ client, directory }) => {
               type: "text",
               text: bootstrap
             });
+          } else if (workerAuthorized && !firstText.includes("workflow-sdd-worker")) {
+            firstUser.parts.unshift({
+              id: firstAnchor.id,
+              sessionID: firstAnchor.sessionID,
+              messageID: firstAnchor.messageID,
+              type: "text",
+              text: SDD_WORKER_REMINDER_TEXT
+            });
           }
         }
         const anchor = currentUser.parts.find((part) => part.type === "text") ?? currentUser.parts[0];
@@ -22148,8 +22564,12 @@ var plugin = async ({ client, directory }) => {
           }
         }
         const activePlans = findActiveSubagentDrivenPlans(directory);
-        if (activePlans.length > 0 && shouldInjectSddReminder(currentText)) {
-          currentUser.parts.unshift(makePart(SDD_REMINDER_TEXT, "sdd"));
+        if (activePlans.length > 0) {
+          const workerAuthorized = await authorizedWorkerFor(anchor.sessionID);
+          const sddText = workerAuthorized ? SDD_WORKER_REMINDER_TEXT : SDD_REMINDER_TEXT;
+          if (!currentText.includes(sddText)) {
+            currentUser.parts.unshift(makePart(sddText, "sdd"));
+          }
         }
         if (detectConfigGapError(assistantText) && shouldInjectConfigGuard(currentText)) {
           currentUser.parts.unshift(makePart(CONFIG_GUARD_TEXT, "cg"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-opencode",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "private": false,
   "description": "Workit OpenCode plugin (thin wrapper over @brainervirus/workit-core)",
   "keywords": [
@@ -34,7 +34,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^0.8.7"
+    "@brainervirus/workit-core": "^0.8.9"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "1.17.7"