ai-whisper 0.14.0 → 0.15.0

package/dist/bin/companion-agent.js

@@ -8230,12 +8230,19 @@ var TurnGate = class {
   get held() {
     return this.heldCount > 0;
   }
-  /** Resolves with a release function once every earlier acquirer released. */
+  /** Resolves with a release function once every earlier acquirer released.
+   * The release is idempotent: calling it twice must not double-decrement
+   * `heldCount` (a corrupted count would report `held === false` while a
+   * later acquirer still holds the gate). */
   acquire() {
     this.heldCount += 1;
     let release;
     const held = new Promise((r) => {
+      let released = false;
       release = () => {
+        if (released)
+          return;
+        released = true;
         this.heldCount -= 1;
         r();
       };
@@ -9283,17 +9290,20 @@ function decidePolicy(name, configPolicy, mode) {
 }
 
 // ../../node_modules/.pnpm/@ai-ezio+mcp-host@file+..+ai-ezio+packages+mcp-host_zod@3.25.76/node_modules/@ai-ezio/mcp-host/dist/host.js
+var DEFAULT_INJECT_ARGS = ["worktreePath", "path"];
 var McpHost = class {
   opts;
   id = "mcp";
   routes = new RouteMap();
   // reassignable for idempotent init()
   clients = /* @__PURE__ */ new Map();
+  serversByName;
   /** Namespaced name → def (for schema-aware cwd injection). */
   defsByName = /* @__PURE__ */ new Map();
   advertised = [];
   constructor(opts) {
     this.opts = opts;
+    this.serversByName = new Map(opts.servers.map((s) => [s.name, s]));
   }
   /** Connect servers + list tools, building the route map and advertised defs.
    * Idempotent: tears down any prior connection state before reconnecting, so a
@@ -9375,14 +9385,17 @@ var McpHost = class {
     const injected = this.injectCwd(name, args);
     return withTimeout(client.callTool(route.tool, injected), this.opts.callTimeoutMs ?? 6e4, `host call ${name}`);
   }
-  /** Force repo-root args (worktreePath/path) to the session cwd. Overrides any
-   * model-supplied value (drift-proof) AND fills when omitted — but ONLY for args
-   * the tool's own schema declares, so we never add a property the server would
-   * reject and never clobber an unrelated `path`. */
+  /** Force repo-root args (worktreePath/path by default) to the session cwd.
+   * Overrides any model-supplied value (drift-proof) AND fills when omitted —
+   * but ONLY for args the tool's own schema declares, so we never add a
+   * property the server would reject. The list resolves per server:
+   * `ServerConfig.injectArgs` ?? the host-level option ?? the ai-* default
+   * ([] at either level disables injection). */
   injectCwd(name, args) {
     const schema = this.defsByName.get(name)?.parametersSchema;
     const props = schema?.properties ?? {};
-    const injectArgs = this.opts.injectArgs ?? ["worktreePath", "path"];
+    const server = this.routes.resolve(name)?.server;
+    const injectArgs = (server !== void 0 ? this.serversByName.get(server)?.injectArgs : void 0) ?? this.opts.injectArgs ?? DEFAULT_INJECT_ARGS;
     const out = { ...args };
     for (const arg of injectArgs)
       if (arg in props)
@@ -9430,12 +9443,14 @@ function parseConfig(text) {
     name,
     command: s.command,
     args: s.args ?? [],
-    env: s.env
+    env: s.env,
+    injectArgs: s.injectArgs
   }));
   return {
     servers,
     toolPolicy: raw.toolPolicy ?? {},
-    hostPrivateTools: raw.hostPrivateTools ?? []
+    hostPrivateTools: raw.hostPrivateTools ?? [],
+    injectArgs: raw.injectArgs
   };
 }
 function loadConfig2(env = process.env) {
@@ -9454,6 +9469,7 @@ function createMcpHost(cfg, opts) {
     servers: cfg.servers,
     toolPolicy: cfg.toolPolicy,
     hostPrivateTools: [.../* @__PURE__ */ new Set([...DEFAULT_HOST_PRIVATE, ...cfg.hostPrivateTools])],
+    injectArgs: cfg.injectArgs,
     confirm: opts.confirm,
     connect: opts.connect
   });
@@ -9637,9 +9653,10 @@ var SubagentHost = class {
       reply(callId, `subagent failed: ${e.message}`, "error");
     }
   }
-  async stop() {
+  stop() {
     this.inFlight?.cancel();
     this.inFlight = void 0;
+    return Promise.resolve();
   }
 };
 
@@ -10703,7 +10720,7 @@ async function runResumeFlow(deps) {
   let chosen;
   await deps.runOverlay(async (io) => {
     chosen = await runResumePicker({
-      listSessions: async () => JSON.stringify(rows),
+      listSessions: () => Promise.resolve(JSON.stringify(rows)),
       // already parsed+filtered; re-serialize for the picker
       keys: io.keys,
       write: io.write,

package/dist/bin/whisper.js

@@ -11668,12 +11668,19 @@ var TurnGate = class {
   get held() {
     return this.heldCount > 0;
   }
-  /** Resolves with a release function once every earlier acquirer released. */
+  /** Resolves with a release function once every earlier acquirer released.
+   * The release is idempotent: calling it twice must not double-decrement
+   * `heldCount` (a corrupted count would report `held === false` while a
+   * later acquirer still holds the gate). */
   acquire() {
     this.heldCount += 1;
     let release;
     const held = new Promise((r) => {
+      let released = false;
       release = () => {
+        if (released)
+          return;
+        released = true;
         this.heldCount -= 1;
         r();
       };
@@ -12722,17 +12729,20 @@ function decidePolicy(name, configPolicy, mode) {
 }
 
 // ../../node_modules/.pnpm/@ai-ezio+mcp-host@file+..+ai-ezio+packages+mcp-host_zod@3.25.76/node_modules/@ai-ezio/mcp-host/dist/host.js
+var DEFAULT_INJECT_ARGS = ["worktreePath", "path"];
 var McpHost = class {
   opts;
   id = "mcp";
   routes = new RouteMap();
   // reassignable for idempotent init()
   clients = /* @__PURE__ */ new Map();
+  serversByName;
   /** Namespaced name → def (for schema-aware cwd injection). */
   defsByName = /* @__PURE__ */ new Map();
   advertised = [];
   constructor(opts) {
     this.opts = opts;
+    this.serversByName = new Map(opts.servers.map((s) => [s.name, s]));
   }
   /** Connect servers + list tools, building the route map and advertised defs.
    * Idempotent: tears down any prior connection state before reconnecting, so a
@@ -12814,14 +12824,17 @@ var McpHost = class {
     const injected = this.injectCwd(name, args);
     return withTimeout(client.callTool(route.tool, injected), this.opts.callTimeoutMs ?? 6e4, `host call ${name}`);
   }
-  /** Force repo-root args (worktreePath/path) to the session cwd. Overrides any
-   * model-supplied value (drift-proof) AND fills when omitted — but ONLY for args
-   * the tool's own schema declares, so we never add a property the server would
-   * reject and never clobber an unrelated `path`. */
+  /** Force repo-root args (worktreePath/path by default) to the session cwd.
+   * Overrides any model-supplied value (drift-proof) AND fills when omitted —
+   * but ONLY for args the tool's own schema declares, so we never add a
+   * property the server would reject. The list resolves per server:
+   * `ServerConfig.injectArgs` ?? the host-level option ?? the ai-* default
+   * ([] at either level disables injection). */
   injectCwd(name, args) {
     const schema = this.defsByName.get(name)?.parametersSchema;
     const props = schema?.properties ?? {};
-    const injectArgs = this.opts.injectArgs ?? ["worktreePath", "path"];
+    const server = this.routes.resolve(name)?.server;
+    const injectArgs = (server !== void 0 ? this.serversByName.get(server)?.injectArgs : void 0) ?? this.opts.injectArgs ?? DEFAULT_INJECT_ARGS;
     const out = { ...args };
     for (const arg of injectArgs)
       if (arg in props)
@@ -12869,12 +12882,14 @@ function parseConfig(text) {
     name,
     command: s.command,
     args: s.args ?? [],
-    env: s.env
+    env: s.env,
+    injectArgs: s.injectArgs
   }));
   return {
     servers,
     toolPolicy: raw.toolPolicy ?? {},
-    hostPrivateTools: raw.hostPrivateTools ?? []
+    hostPrivateTools: raw.hostPrivateTools ?? [],
+    injectArgs: raw.injectArgs
   };
 }
 function loadConfig2(env = process.env) {
@@ -12893,6 +12908,7 @@ function createMcpHost(cfg, opts) {
     servers: cfg.servers,
     toolPolicy: cfg.toolPolicy,
     hostPrivateTools: [.../* @__PURE__ */ new Set([...DEFAULT_HOST_PRIVATE, ...cfg.hostPrivateTools])],
+    injectArgs: cfg.injectArgs,
     confirm: opts.confirm,
     connect: opts.connect
   });
@@ -13076,9 +13092,10 @@ var SubagentHost = class {
       reply(callId, `subagent failed: ${e.message}`, "error");
     }
   }
-  async stop() {
+  stop() {
     this.inFlight?.cancel();
     this.inFlight = void 0;
+    return Promise.resolve();
   }
 };
 
@@ -14142,7 +14159,7 @@ async function runResumeFlow(deps) {
   let chosen;
   await deps.runOverlay(async (io) => {
     chosen = await runResumePicker({
-      listSessions: async () => JSON.stringify(rows),
+      listSessions: () => Promise.resolve(JSON.stringify(rows)),
       // already parsed+filtered; re-serialize for the picker
       keys: io.keys,
       write: io.write,
@@ -14958,9 +14975,9 @@ function compareSemver(a, b) {
 // src/generated/ezio-provenance.ts
 var EZIO_PROVENANCE = {
   ezioCliVersion: "0.4.0",
-  ezioGitSha: "77a3b48",
-  builtAt: "2026-07-06T01:57:14.462Z",
-  whisperVersion: "0.14.0"
+  ezioGitSha: "7dd7e90",
+  builtAt: "2026-07-12T18:26:06.860Z",
+  whisperVersion: "0.15.0"
 };
 
 // src/ezio-provenance-types.ts
@@ -16582,8 +16599,8 @@ function applyFreshnessFloor(refs, promptDeliveredAtMs, clockSkewMs) {
   const floor = promptDeliveredAtMs - clockSkewMs;
   return refs.filter((ref) => ref.mtimeMs >= floor);
 }
-function pickActiveTranscript(refs, turnText, readFile, limit) {
-  const top = refs.slice(0, limit).map((ref) => ({ path: ref.path, analysis: analyzeTurn(readFile(ref.path)) }));
+function pickActiveTranscript(refs, turnText, readFile2, limit) {
+  const top = refs.slice(0, limit).map((ref) => ({ path: ref.path, analysis: analyzeTurn(readFile2(ref.path)) }));
   if (top.length === 0) return null;
   const turn = turnText.trim();
   if (turn.length > 0) {
@@ -16607,7 +16624,7 @@ function sha256(text) {
 }
 async function captureCursorHandback(input) {
   const listTranscripts = input.listTranscripts ?? (() => listCursorTranscripts());
-  const readFile = input.readFile ?? ((path4) => readFileSync10(path4, "utf8"));
+  const readFile2 = input.readFile ?? ((path4) => readFileSync10(path4, "utf8"));
   const sleep3 = input.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const budgetMs = input.budgetMs ?? 15e3;
   const pollIntervalMs = input.pollIntervalMs ?? 500;
@@ -16651,11 +16668,11 @@ async function captureCursorHandback(input) {
     let pick;
     try {
       if (expectedPrompt.length > 0) {
-        const result = pickByPrompt({ refs, expectedPrompt, readFile, limit });
+        const result = pickByPrompt({ refs, expectedPrompt, readFile: readFile2, limit });
         matchedCount = result.matchedCount;
         pick = result.pick;
       } else {
-        pick = pickActiveTranscript(refs, input.turnText, readFile, limit);
+        pick = pickActiveTranscript(refs, input.turnText, readFile2, limit);
       }
     } catch {
       pick = null;
@@ -20203,13 +20220,51 @@ function runWorkflowStats(deps) {
 }
 
 // src/commands/skill/install.ts
-import { cp, mkdir, readdir, stat } from "node:fs/promises";
+import { cp, mkdir, readdir, readFile, stat } from "node:fs/promises";
 import path3 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
+
+// src/commands/skill/version.ts
+var VALID_VERSION_RE = /^\d+(\.\d+){0,2}$/;
+function parseSkillVersion(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return null;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "---") return null;
+    const m = /^version:\s*(.+?)\s*$/.exec(line);
+    if (m) {
+      const raw = (m[1] ?? "").replace(/^["']/, "").replace(/["']$/, "");
+      return VALID_VERSION_RE.test(raw) ? raw : null;
+    }
+  }
+  return null;
+}
+function compareSemver2(a, b) {
+  const pa = a.split(".");
+  const pb = b.split(".");
+  for (let i = 0; i < 3; i++) {
+    const da = Number.parseInt(pa[i] ?? "0", 10);
+    const db = Number.parseInt(pb[i] ?? "0", 10);
+    if (da !== db) return da < db ? -1 : 1;
+  }
+  return 0;
+}
+
+// src/commands/skill/install.ts
 function defaultBundledSkillsDir() {
   const here = path3.dirname(fileURLToPath6(import.meta.url));
   return path3.resolve(here, "..", "..", "skills");
 }
+async function readSkillVersion(skillMdPath) {
+  let content;
+  try {
+    content = await readFile(skillMdPath, "utf8");
+  } catch {
+    return null;
+  }
+  return parseSkillVersion(content);
+}
 function homeForTarget(target, fakeHome) {
   const home = fakeHome ?? process.env.HOME ?? process.env.USERPROFILE ?? "";
   if (!home) throw new Error("Could not determine $HOME for skill install destination");
@@ -20251,6 +20306,7 @@ async function runSkillInstall(input) {
     throw new Error(`No skills found in ${bundledDir}.`);
   }
   const targets = input.target === "all" ? ["claude", "codex", "cursor", "ezio", "agy"] : [input.target];
+  const results = [];
   const installedAt = [];
   for (const t of targets) {
     const destBase = homeForTarget(t, input.fakeHome);
@@ -20265,16 +20321,33 @@ async function runSkillInstall(input) {
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
       }
-      if (destExists && !input.force) {
-        throw new Error(
-          `Skill destination already exists at ${dest}. Re-run with --force to overwrite.`
-        );
+      const bundledVersion = await readSkillVersion(path3.join(src, "SKILL.md"));
+      const installedVersion = destExists ? await readSkillVersion(path3.join(dest, "SKILL.md")) : null;
+      let action;
+      if (!destExists || installedVersion === null) {
+        action = "installed";
+      } else {
+        const cmp = compareSemver2(bundledVersion ?? "0.0.0", installedVersion);
+        action = cmp > 0 ? "installed" : cmp === 0 ? "up-to-date" : "skipped-newer";
+      }
+      const forced = action !== "installed" && input.force === true;
+      if (forced) action = "installed";
+      results.push({
+        skill,
+        target: t,
+        dest,
+        action,
+        bundledVersion,
+        installedVersion,
+        ...forced ? { forced: true } : {}
+      });
+      if (action === "installed") {
+        await cp(src, dest, { recursive: true, force: true });
+        installedAt.push(path3.join(dest, "SKILL.md"));
       }
-      await cp(src, dest, { recursive: true, force: true });
-      installedAt.push(path3.join(dest, "SKILL.md"));
     }
   }
-  return { installedAt };
+  return { results, installedAt };
 }
 
 // src/commands/env/report.ts
@@ -20837,13 +20910,28 @@ Not attached (stdin/stdout is not a TTY). To view the tmux session, run:
     "Install the bundled ai-whisper skills into your agent skill directories"
   ).addOption(
     new Option("--target <target>", "Agent install target").choices(["claude", "codex", "cursor", "ezio", "agy", "all"]).default("all")
-  ).option("--force", "Overwrite existing skill destinations").action(async (opts) => {
+  ).option(
+    "--force",
+    "Reinstall even when the installed copy is same-version or newer (downgrade)"
+  ).action(async (opts) => {
     const result = await runSkillInstall({
       target: opts.target,
       ...opts.force ? { force: true } : {}
     });
-    for (const p of result.installedAt) {
-      console.log(`Installed: ${p}`);
+    for (const e of result.results) {
+      if (e.action === "installed" && e.forced) {
+        console.log(
+          `Installed (forced): ${e.skill} \u2192 ${e.dest} (replaced ${e.installedVersion ?? "unversioned"})`
+        );
+      } else if (e.action === "installed") {
+        console.log(`Installed: ${e.skill} \u2192 ${e.dest}`);
+      } else if (e.action === "up-to-date") {
+        console.log(`Up to date: ${e.skill} @ ${e.installedVersion} \u2192 ${e.dest}`);
+      } else {
+        console.log(
+          `Skipped (newer installed): ${e.skill} \u2014 installed ${e.installedVersion} > bundled ${e.bundledVersion ?? "unversioned"}; use --force to downgrade \u2192 ${e.dest}`
+        );
+      }
     }
   });
   cli.command("env").description(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-whisper",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Terminal-first relay for paired AI coding agents (Claude + Codex), driven by structured workflows.",
   "license": "Apache-2.0",
   "repository": {
@@ -52,13 +52,13 @@
     "@types/better-sqlite3": "^7.6.12",
     "@types/react": "^19.2.14",
     "ink-testing-library": "^4.0.0",
-    "@ai-whisper/adapter-claude": "0.0.0",
     "@ai-whisper/adapter-ai-ezio": "0.0.0",
+    "@ai-whisper/adapter-antigravity": "0.0.0",
+    "@ai-whisper/adapter-claude": "0.0.0",
     "@ai-whisper/adapter-codex": "0.0.0",
     "@ai-whisper/adapter-cursor": "0.0.0",
-    "@ai-whisper/broker": "0.0.0",
-    "@ai-whisper/adapter-antigravity": "0.0.0",
     "@ai-whisper/companion-core": "0.0.0",
+    "@ai-whisper/broker": "0.0.0",
     "@ai-whisper/shared": "0.0.0"
   },
   "files": [

package/skills/ai-whisper-bugfix/SKILL.md

@@ -1,172 +1,70 @@
 ---
 name: ai-whisper-bugfix
-description: Kick off the complex-bug-fixing workflow on a given bug report. Use when the user says things like "run bugfix on <path>", "fix this bug report <path>", "kick off complex-bug-fixing with <path>", "/aiw-bugfix <path>", "$aiw-bugfix <path>", or otherwise asks to start the complex-bug-fixing workflow on a specific bug report.
+description: Use when the user reaches for the ai-whisper-bugfix skill by name or asks to run bugfix / complex-bug-fixing on a bug report file — a name-preserving alias that applies the ai-whisper-workflow skill with workflow type complex-bug-fixing.
+version: 0.1.0
 ---
 
 # ai-whisper-bugfix
 
-Kick off the ai-whisper complex-bug-fixing workflow on a specific bug report. This skill is fire-and-forget: it verifies the collab is ready, runs `whisper workflow start`, and exits. **Do NOT continue polling or narrating after kickoff** — continuous activity from the calling agent keeps it busy, which blocks the broker's idle detection and stalls the workflow. The dashboard (`whisper collab dashboard`) is the inspection surface during the run.
+## Intent
 
-## When to invoke
+A name-preserving alias. The pre-collapse kickoff skills became the
+`ai-whisper-workflow` skill; this one keeps the `ai-whisper-bugfix` picker
+name alive and delegates to that skill with workflow type
+`complex-bug-fixing`. No behavior of its own.
 
-Match phrases like:
-- *"run bugfix on docs/bug.md"* / *"fix this bug report @docs/bug.md"*
-- *"kick off complex-bug-fixing with docs/bug.md"*
-- *"/aiw-bugfix docs/bug.md"* (Claude picker form)
-- *"$aiw-bugfix docs/bug.md"* (Codex picker form)
+## Inputs
 
-If the user references a bug report ambiguously (e.g., "run bugfix on the bug we just discussed"), ASK them for the path ONCE before proceeding. Do not guess.
+- The bug report file path (the workflow's `--spec` input): symptoms,
+  reproduction steps, expected-vs-actual — not a spec or open-ended goal. An
+  `@`-prefixed form is accepted; strip the `@` before resolving.
 
-## Steps
+## Preconditions
 
-### 1. Resolve the bug-report path
+- The `ai-whisper-workflow` skill is installed alongside this one — it is the
+  delegation target and owns the full procedure.
+- Its preconditions apply unchanged: `whisper` CLI on PATH, a ready collab
+  with two bound agents, a readable bug report.
 
-The user names a path. If it begins with `@`, strip the `@`. Resolve to an absolute path. Verify it's a readable file via the Read tool. If not readable:
+## Procedure
 
-> Bug report `<path>` is not readable. Check the path and try again.
+1. Read the `ai-whisper-workflow` skill's SKILL.md — it is installed in the
+   adjacent directory of the same skills root.
+2. Apply it with workflow type `complex-bug-fixing` and the given bug-report
+   path — vetting, collab readiness, kickoff, and the one-line report all
+   follow that skill verbatim.
+3. Only if the delegation target is not installed, use the inline fallback:
+   vet the bug-report path, gate on `whisper collab status --json`, then run:
 
-The file is a **bug report** (markdown or plain text): symptoms, reproduction steps, and expected-vs-actual behavior — not a spec or open-ended goal. A bug report implies a human (dev or QA) already observed and reproduced the bug, so the workflow's implementer is expected to reproduce it too, not theorize from reading code. The better the reproduction in the report, the faster the diagnosis converges. This framing is guidance for preparing the bug report before kickoff; it is not runtime output.
+   ```bash
+   whisper workflow start --type=complex-bug-fixing --spec=<resolved-absolute-path>
+   ```
 
-### 2. Verify collab readiness
+   Report exactly one line — Workflow `<workflowId>` started. Track progress
+   with `whisper collab dashboard`. — then stop.
 
-Run:
+## Output
 
-```bash
-whisper collab status --json
-```
+Identical to ai-whisper-workflow's output contract: exactly one
+workflow-started line on success, or the matching gate error verbatim, and
+nothing more after kickoff.
 
-Parse the JSON. The expected shape is:
+## Examples
 
-```json
-{
-  "collabId": "collab_xyz",
-  "workspaceRoot": "/path",
-  "status": "active",
-  "daemon": { "host": "127.0.0.1", "port": 4311, "pid": 12345 },
-  "agents": [
-    { "agentType": "codex",  "bindingState": "bound" | "pending_attach" | "unbound" | null },
-    { "agentType": "claude", "bindingState": "bound" | "pending_attach" | "unbound" | null },
-    { "agentType": "ezio",   "bindingState": "bound" | "pending_attach" | "unbound" | null },
-    { "agentType": "agy",    "bindingState": "bound" | "pending_attach" | "unbound" | null },
-    { "agentType": "cursor", "bindingState": "bound" | "pending_attach" | "unbound" | null }
-  ],
-  "recovery": { "state": "normal" | "recovery_required" | "recovered" },
-  "evaluator": { "ready": true | false, "status": "ready" | "missing_anthropic_key" | "invalid_config" | "disabled" | "unknown" }
-}
-```
+Input: the user says "run bugfix on docs/reports/login-crash.md".
 
-Required for readiness:
-- `daemon !== null`
-- `status === "active"`
-- `recovery.state === "normal"`
-- **EXACTLY TWO agents bound** — among the supported agent types (`codex`, `claude`,
-  `ezio`, `agy`, `cursor`), exactly two must have `bindingState === "bound"` (the
-  implementer + reviewer pair). **`ezio`, `agy`, and `cursor` are replacement
-  roles**: any of them stands in for `codex` or `claude`, so do NOT require
-  `codex` and `claude` specifically — any pair of two distinct supported agents
-  passes. (The displaced slots read `null`/`unbound` and that is expected when a
-  replacement agent takes a seat.)
-- `evaluator.status` is NOT `"missing_anthropic_key"` or `"invalid_config"` (i.e., `ready`, `disabled`, and `unknown` all pass this gate; only the two true-misconfiguration statuses block)
+The agent reads the ai-whisper-workflow skill and applies it with type
+`complex-bug-fixing`; the report is readable, the collab is ready, and the
+kickoff succeeds.
 
-If the JSON has `{ "error": "no_collab_for_cwd", ... }`:
+Output: Workflow `wf_58c2de` started. Track progress with `whisper collab dashboard`.
 
-> No collab found in this workspace. Mount any **two** agents (e.g. `whisper collab mount ezio` in one terminal and `whisper collab mount codex` — or `claude` / `agy` / `cursor` — in another), then re-run this skill.
+## Anti-patterns
 
-If `recovery.state === "recovery_required"`:
-
-> The collab is in recovery_required state. Run `whisper collab recover`, then re-run this skill.
-
-If `recovery.state === "recovered"`:
-
-> The collab has been recovered and still needs reconnect. Run `whisper collab reconnect <agent>` for each bound agent, then re-run this skill.
-
-If FEWER than two agents are bound (count `bindingState === "bound"` across
-the supported agent types):
-
-> Only <N> agent(s) bound (<list bound agentTypes>). A workflow needs two — an
-> implementer and a reviewer. Mount another agent (`whisper collab mount <codex|claude|ezio|agy|cursor>`)
-> in a separate terminal, then re-run this skill. `ezio`, `agy`, or `cursor` may replace `codex` or `claude`.
-
-(Do NOT append permission flags — mount already spawns the agent in full-permission mode; passing `--dangerously-skip-permissions` / `--dangerously-bypass-approvals-and-sandbox` again can crash the agent on a duplicate-argument error.)
-
-If `evaluator.status === "missing_anthropic_key"` (i.e., `evaluator.ready === false` AND status is `missing_anthropic_key`):
-
-> The evaluator has no Anthropic API key. Create `~/.ai-whisper/auth.json` with `{ "ANTHROPIC_API_KEY": "sk-ant-..." }` (chmod 600), then restart the daemon (`whisper collab stop` and re-mount, or restart the broker), and re-run this skill. See the README "Evaluator configuration" section.
-
-If `evaluator.status === "invalid_config"` (i.e., `evaluator.ready === false` AND status is `invalid_config`):
-
-> The evaluator config is malformed. Fix the JSON in `~/.ai-whisper/auth.json` or `~/.ai-whisper/config.json`, then restart the daemon and re-run this skill. See the README "Evaluator configuration" section.
-
-If `evaluator.status === "disabled"`: this means the orchestrator is intentionally off — it is NOT a misconfiguration and does NOT block this skill gate. Proceed to step 3; `workflow start` will surface the orchestrator-disabled error itself.
-
-(Note: `evaluator.ready` is `false` for `missing_anthropic_key`, `invalid_config`, AND `disabled`; it is `true` only for `ready` and `unknown`. That's why this gate keys off `status` rather than `ready` — so `disabled` does not block the skill while the two true-misconfiguration statuses do.)
-
-### 3. Kick off the workflow
-
-Run:
-
-```bash
-whisper workflow start --type=complex-bug-fixing --spec=<resolved-absolute-path>
-```
-
-(No `--implementer` / `--reviewer` needed — the agent triggering this skill becomes the implementer and the other agent the reviewer. Pass `--implementer <agent> --reviewer <agent>` only to override. `--spec` names the bug report.)
-
-Parse the workflowId from stdout (format: `Workflow started: <workflowId>`).
-
-### 4. Report and exit
-
-Print exactly this one line — it is the **only** runtime output the skill emits after kickoff:
-
-> Workflow `<workflowId>` started. Track progress with `whisper collab dashboard`.
-
-Then stop. Do NOT poll `whisper workflow inspect`. Do NOT narrate. Do NOT print the "What it does" documentation below. The workflow runs in the broker driver; your job is done.
-
-## What complex-bug-fixing does (static documentation — NEVER printed at runtime)
-
-This section is reference prose for the invoking agent's understanding. It is documentation, not a runtime step, and must NOT be emitted after kickoff (doing so would violate the exactly-one-line report/exit contract in step 4).
-
-Once kicked off, the workflow runs a fixed three-phase pipeline: **diagnosis → fix-and-verify → post-mortem**. In diagnosis, the implementer reproduces the bug themselves (a committed RED test is strongly preferred) and writes a diagnosis artifact (root cause + proposed fix + blast radius + residual risks); an adversarial reviewer independently reproduces it and refuses to open the gate until both agree the cause is proven and the fix is net-safe. In fix-and-verify, the implementer applies the approved fix, turns the reproduction GREEN, and verifies across the blast radius, while the reviewer runs an adversarial acceptance review including test-coverage adequacy. In post-mortem, the implementer records cause, fix, coverage gaps, residual risks, and lessons learned. The diagnosis and post-mortem are self-verification artifacts for the human after the run; they live in the gitignored run dir `.ai-whisper/bugfix/<workflowId>/` and are NOT committed — only the fix and the reproduction test land in the repo. Watch all of this on `whisper collab dashboard`; do not babysit it from chat.
-
-## Why fire-and-forget
-
-The broker's relay handoff system uses **idle detection** to know when an agent is ready to receive the next handoff. If this skill polled the workflow's status every few seconds, the calling agent (you) would emit output continuously, the broker would never see you as idle, and the workflow's first handoff couldn't be delivered to you — the workflow stalls. Kick off and exit; observation belongs to the dashboard.
-
-## Duo roleplay
-
-The mount may have assigned you a movie-duo character for this collab session — check the `AI_WHISPER_CHARACTER` / `AI_WHISPER_CHARACTER_ROLE` env vars, or the `[ai-whisper duo]` brief injected at session start, to find out. If so, staying in character is welcome — but **conversational prose only**: chat, status updates, banter with the operator or your teammate.
-
-Never let character flavor into code, commit messages, PR descriptions, file contents, or the diagnosis/post-mortem artifacts. The reviewer/evaluator protocol output (verdict labels, approve/findings/escalate) stays protocol-exact regardless of who you're playing.
-
-## Resume / cancel
-
-If the user asks to resume a halted workflow, run:
-
-```bash
-whisper workflow resume <workflowId>
-```
-
-If they ask to cancel:
-
-```bash
-whisper workflow cancel <workflowId>
-```
-
-Same fire-and-forget shape: invoke, report one line, exit.
-
-## Pausing the workflow (operator control)
-
-If the user interrupts you mid-workflow and asks to pause it (e.g. "pause the workflow, I need to fix X"):
-
-1. Find the active workflow id: `whisper workflow list`.
-2. Run `whisper workflow pause <workflowId>`.
-3. Acknowledge and **stop working** — do not start the next change.
-
-The operator edits artifacts while paused, then resumes:
-
-```bash
-whisper workflow resume <workflowId> --message "what I changed and why"
-```
-
-On resume the agents receive a notice listing the changed files plus the operator note, and must re-read those files before continuing.
-
-Provider gotcha: the Codex CLI **exits its session** on Ctrl+C at an idle prompt (a mid-task Ctrl+C only interrupts the running task). The user typically interrupts a *busy* agent before issuing the pause instruction — do not assume Ctrl+C is a safe no-op.
+- Re-implementing the ai-whisper-workflow procedure here — delegate; the
+  target owns it.
+- Bending this alias to another workflow type — SDD, deliberation, and ralph
+  asks go to their own entry points.
+- Fixing the bug directly when the user handed you a bug-report file for the
+  workflow — kickoff is the ask; the workflow's implementer does the fixing.
+- Polling or narrating after kickoff — fire-and-forget applies unchanged.