@wrongstack/cli 0.9.7 → 0.9.20

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import * as path24 from 'path';
 import * as fsp3 from 'fs/promises';
-import { color, DefaultPathResolver, TOKENS, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, EventBus, SlashCommandRegistry, createDelegateTool, FLEET_ROSTER, createMcpControlTool, EternalAutonomyEngine, DefaultLogger, DefaultModelsRegistry, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, AutoCompactionMiddleware, estimateRequestTokens, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, AutoApprovePermissionPolicy, PhaseStore, AutoPhasePlanner, PhaseGraphBuilder, WorktreeManager, PhaseOrchestrator, makeLLMClassifier, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, atomicWrite, DefaultPluginAPI, makeAgentSubagentRunner, NULL_FLEET_BUS, buildChildEnv, formatContextWindowModeList, repairToolUseAdjacency, getContextWindowMode, resolveContextWindowPolicy, AGENTS_BY_PHASE, dispatchAgent, formatTodosList, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, DefaultTaskStore, TaskTracker, renderProgress, renderTaskGraph, loadGoal, goalFilePath, summarizeUsage, saveGoal, emptyGoal, buildGoalPreamble, formatGoal, pendingBtwCount, setBtwNote, decryptConfigSecrets, encryptConfigSecrets as encryptConfigSecrets$1, InputBuilder, FsError, ERROR_CODES, SpecVersioning, ParallelEternalEngine, allServers as allServers$1 } from '@wrongstack/core';
+import { color, DefaultPathResolver, TOKENS, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, EventBus, SlashCommandRegistry, createDelegateTool, FLEET_ROSTER, createMcpControlTool, EternalAutonomyEngine, DefaultLogger, DefaultModelsRegistry, runProviderWithRetry, ReplayLogStore, ReplayProviderRunner, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, AutoCompactionMiddleware, estimateRequestTokens, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, makeFleetEmitTool, makeFleetStatusTool, AutoApprovePermissionPolicy, PhaseStore, AutoPhasePlanner, PhaseGraphBuilder, WorktreeManager, PhaseOrchestrator, makeLLMClassifier, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, DefaultSessionReader, ToolAuditLog, DefaultSessionRewinder, DefaultSessionStore, atomicWrite, DefaultPluginAPI, makeAgentSubagentRunner, NULL_FLEET_BUS, buildChildEnv, formatContextWindowModeList, repairToolUseAdjacency, getContextWindowMode, resolveContextWindowPolicy, AGENTS_BY_PHASE, dispatchAgent, formatTodosList, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, DefaultTaskStore, TaskTracker, renderProgress, renderTaskGraph, SessionRecovery, loadGoal, goalFilePath, summarizeUsage, saveGoal, emptyGoal, buildGoalPreamble, formatGoal, pendingBtwCount, setBtwNote, decryptConfigSecrets, encryptConfigSecrets as encryptConfigSecrets$1, InputBuilder, FsError, ERROR_CODES, SpecVersioning, ParallelEternalEngine, allServers as allServers$1 } from '@wrongstack/core';
 import { createRequire } from 'module';
 import * as os3 from 'os';
 import os3__default from 'os';
@@ -380,12 +380,9 @@ function buildSddCommand(opts) {
     name: "sdd",
     description: "AI-driven SDD: /sdd [new|approve|execute|cancel|status|list|show|templates]",
     async run(args) {
-      opts.context;
       if (!opts.paths) return { message: "SDD not available \u2014 paths not configured." };
       const specsDir = opts.paths.projectSpecs;
-      const graphsDir = opts.paths.projectTaskGraphs;
       const specStore = new SpecStore({ baseDir: specsDir });
-      new TaskGraphStore({ baseDir: graphsDir });
       const versioning = sddState.getVersioning();
       const [verb, ...rest] = args.trim().split(/\s+/);
       const restJoined = rest.join(" ").trim();
@@ -1024,8 +1021,8 @@ Start executing the tasks one by one.`
             return { message: lines2.join("\n") };
           }
           try {
-            const graphStore2 = new TaskGraphStore({ baseDir: opts.paths.projectTaskGraphs });
-            const stored = await graphStore2.load(graphId);
+            const graphStore = new TaskGraphStore({ baseDir: opts.paths.projectTaskGraphs });
+            const stored = await graphStore.load(graphId);
             if (stored) {
               return { message: renderTaskGraph(stored, { compact: false }) };
             }
@@ -1245,8 +1242,8 @@ ${lines.join("\n")}`
             return { message: "No task graph found. Generate tasks first." };
           }
           try {
-            const graphStore2 = new TaskGraphStore({ baseDir: opts.paths.projectTaskGraphs });
-            const graph = await graphStore2.load(graphId);
+            const graphStore = new TaskGraphStore({ baseDir: opts.paths.projectTaskGraphs });
+            const graph = await graphStore.load(graphId);
             if (!graph) {
               return { message: "Could not load task graph." };
             }
@@ -1659,7 +1656,7 @@ async function checkForUpdate(signal, homeFn) {
       outdated: isNewer(latest, current),
       checkFailed: false
     };
-  } catch (err) {
+  } catch (_err) {
     if (aborted()) {
       return { current, latest: current, outdated: false, checkFailed: true };
     }
@@ -1980,7 +1977,7 @@ async function runWebUI(opts) {
       }
     }
   }
-  async function handleUserMessage(ws, client, content) {
+  async function handleUserMessage(ws, _client, content) {
     if (abortController) {
       send(ws, {
         type: "error",
@@ -3553,8 +3550,85 @@ function buildLoadCommand(opts) {
   return {
     name: "resume",
     aliases: ["load", "sessions"],
-    description: "List recent sessions.",
-    async run() {
+    description: "List recent sessions, show incomplete ones (--incomplete), or plan a recovery (--recover <id>).",
+    async run(args) {
+      const parts = args.split(/\s+/).filter(Boolean);
+      const showIncomplete = parts.includes("--incomplete") || parts.includes("-i");
+      const recoverIdx = parts.findIndex((p) => p === "--recover");
+      const recoverTarget = recoverIdx >= 0 ? parts[recoverIdx + 1] : void 0;
+      if (recoverTarget) {
+        if (!opts.paths) {
+          return { message: color.yellow("No paths configured \u2014 cannot build a recovery plan.") };
+        }
+        const recovery = new SessionRecovery(opts.paths.projectSessions);
+        const plan = await recovery.recover(recoverTarget);
+        if (!plan) {
+          return {
+            message: color.yellow(
+              `No session log found for ${recoverTarget} (or it is empty).`
+            )
+          };
+        }
+        const lines2 = [
+          color.bold(`Recovery plan for ${plan.sessionId}`),
+          `  Stale: ${plan.stale ? color.yellow("yes") : color.green("no")}`
+        ];
+        if (plan.context) {
+          lines2.push(`  Last in-flight context: ${color.cyan(plan.context)}`);
+        }
+        if (plan.lastCheckpoint && plan.lastCheckpoint.type === "checkpoint") {
+          const cp = plan.lastCheckpoint;
+          lines2.push(
+            `  Last checkpoint: promptIndex=${cp.promptIndex} preview=${color.dim(`"${cp.promptPreview}"`)} at ${color.dim(cp.ts)}`
+          );
+        } else {
+          lines2.push(`  Last checkpoint: ${color.dim("(none \u2014 full re-execution)")}`);
+        }
+        lines2.push(
+          `  Pending events: ${plan.pendingEvents.length} (the work that would re-run on resume)`
+        );
+        if (plan.pendingEvents.length > 0) {
+          const summary = summarizePending(plan.pendingEvents);
+          lines2.push(...summary);
+        }
+        lines2.push("");
+        lines2.push(
+          color.dim(
+            plan.stale ? "  This session crashed mid-iteration. The full re-execution kernel is coming in a follow-up; for now use this plan to decide whether to start fresh." : "  This session ended cleanly; the plan above describes the most recent turn(s) for context."
+          )
+        );
+        return { message: lines2.join("\n") };
+      }
+      if (showIncomplete) {
+        if (!opts.paths) {
+          return { message: color.yellow("No paths configured \u2014 cannot scan for incomplete sessions.") };
+        }
+        const recovery = new SessionRecovery(opts.paths.projectSessions);
+        const resumable = await recovery.listResumable();
+        if (resumable.length === 0) {
+          return {
+            message: color.dim("No incomplete sessions. (Every recorded run ended cleanly.)")
+          };
+        }
+        const lines2 = [
+          color.bold(`${resumable.length} incomplete session(s)`),
+          color.dim("  (process died mid-iteration; the last event was in_flight_start)"),
+          ""
+        ];
+        for (const s of resumable) {
+          const t = color.dim(s.lastEventTs.slice(0, 19).replace("T", " "));
+          lines2.push(
+            `  ${color.cyan(s.sessionId)}  ${t}  ${color.dim(`${s.eventCount} events`)}  ${s.context}`
+          );
+        }
+        lines2.push("");
+        lines2.push(
+          color.dim(
+            "  Resuming re-executes the in-flight work from the last checkpoint. Full resume is coming in a follow-up; for now use this list to identify crashes and decide whether to restart fresh."
+          )
+        );
+        return { message: lines2.join("\n") };
+      }
       if (!opts.sessionStore) return { message: "No session store configured." };
       const list = await opts.sessionStore.list(10);
       if (list.length === 0) return { message: "No saved sessions." };
@@ -3565,7 +3639,8 @@ function buildLoadCommand(opts) {
 ${lines.join("\n")}
 
 ${color.dim(`Resume one with: wstack resume ${list[0]?.id ?? "<id>"}
-`)}`;
+`)}
+${color.dim("Tip: /resume --incomplete \u2014 list sessions that crashed mid-iteration")}`;
       opts.renderer.write(msg);
       return { message: msg };
     }
@@ -3589,6 +3664,47 @@ function buildExitCommand(opts) {
     }
   };
 }
+function summarizePending(events) {
+  const lines = [];
+  const cap = 12;
+  for (const ev of events.slice(-cap)) {
+    const t = "ts" in ev ? color.dim(String(ev.ts).slice(11, 19)) : color.dim("--:--:--");
+    const kind = color.cyan(String(ev.type).padEnd(18));
+    lines.push(`    ${t}  ${kind}  ${summariseEvent(ev)}`);
+  }
+  if (events.length > cap) {
+    lines.push(color.dim(`    \u2026 and ${events.length - cap} more`));
+  }
+  return lines;
+}
+function summariseEvent(ev) {
+  switch (ev.type) {
+    case "user_input": {
+      const text = "text" in ev && typeof ev.text === "string" ? ev.text : Array.isArray(ev.content) ? "\u2026" : "";
+      return color.dim(text.length > 60 ? text.slice(0, 59) + "\u2026" : text);
+    }
+    case "llm_response":
+      return color.dim("(model reply)");
+    case "tool_use":
+      return color.dim(`name=${ev.name ?? "?"}`);
+    case "tool_result":
+      return color.dim(`name=${ev.name ?? "?"}`);
+    case "in_flight_start":
+      return color.dim(`context="${ev.context ?? ""}"`);
+    case "in_flight_end":
+      return color.dim(`reason=${ev.reason ?? "?"}`);
+    case "checkpoint":
+      return color.dim(
+        `promptIndex=${ev.promptIndex ?? "?"}`
+      );
+    case "compaction":
+      return color.dim("(compaction)");
+    case "error":
+      return color.red(String(ev.message ?? ""));
+    default:
+      return color.dim("\u2026");
+  }
+}
 
 // src/slash-commands/spawn-agents.ts
 function buildSpawnCommand(opts) {
@@ -4173,8 +4289,48 @@ ${lines.join("\n")}`;
     }
   };
 }
-
-// src/slash-commands/mode.ts
+async function runModePicker(modeStore, reader) {
+  const modes = await modeStore.listModes();
+  const active = await modeStore.getActiveMode();
+  const activeIdx = modes.findIndex((m) => m.id === active?.id);
+  let cursor = activeIdx >= 0 ? activeIdx : 0;
+  const render = (currentCursor) => {
+    const lines = [];
+    lines.push(`
+${color.bold(color.amber("WrongStack") + color.dim(" \u2014 Mode Selection"))}
+`);
+    lines.push(color.dim("  \u2191\u2193 navigate   Enter select   q quit\n"));
+    lines.push("");
+    for (let i = 0; i < modes.length; i++) {
+      const m = modes[i];
+      const mark = m.id === active?.id ? color.green(" [active]") : "";
+      const prefix = i === currentCursor ? color.bold("\u276F ") : "  ";
+      const name = i === currentCursor ? color.bold(m.name) : m.name;
+      lines.push(`  ${prefix}${name}  ${color.dim(m.description)}${mark}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  };
+  process.stdout.write(render(cursor));
+  const options = [
+    { key: "\x1B[A", label: "\u2191", value: "up" },
+    { key: "\x1B[B", label: "\u2193", value: "down" },
+    { key: "\r", label: "Enter", value: "enter" },
+    { key: "q", label: "q", value: "quit" }
+  ];
+  while (true) {
+    const answer = await reader.readKey("", options);
+    if (answer === "quit") return void 0;
+    if (answer === "enter") return modes[cursor];
+    if (answer === "up") {
+      cursor = cursor > 0 ? cursor - 1 : modes.length - 1;
+    } else if (answer === "down") {
+      cursor = cursor < modes.length - 1 ? cursor + 1 : 0;
+    }
+    process.stdout.write("\x1B[J");
+    process.stdout.write(render(cursor));
+  }
+}
 function buildModeCommand(opts) {
   return {
     name: "mode",
@@ -4194,7 +4350,7 @@ function buildModeCommand(opts) {
       "  /mode brief    Switch to brief mode",
       "  /mode teach    Switch to teach mode"
     ].join("\n"),
-    async run(args) {
+    async run(args, _ctx) {
       const modeStore = opts.modeStore;
       if (!modeStore) {
         return { message: "Mode store not available in this context." };
@@ -4202,6 +4358,17 @@ function buildModeCommand(opts) {
       const modes = await modeStore.listModes();
       const active = await modeStore.getActiveMode();
       if (!args.trim()) {
+        if (opts.inputReader) {
+          const selected = await runModePicker(modeStore, opts.inputReader);
+          if (!selected) {
+            return { message: "Mode selection cancelled." };
+          }
+          await modeStore.setActiveMode(selected.id);
+          return {
+            message: `Switched to "${selected.name}" mode.
+${selected.description}`
+          };
+        }
         const lines = [`Current mode: ${active?.name ?? "none"}`, "", "Available modes:"];
         for (const m of modes) {
           const mark = m.id === active?.id ? " [active]" : "";
@@ -5306,6 +5473,195 @@ function buildAutoPhaseCommand(opts) {
     }
   };
 }
+function buildCollabCommand(opts) {
+  return {
+    name: "collab",
+    description: "Live collaboration helpers (status / invite / history).",
+    async run(args, ctx) {
+      const parts = args.split(/\s+/).filter(Boolean);
+      const sub = (parts[0] ?? "status").toLowerCase();
+      switch (sub) {
+        case "status":
+          return statusCommand(ctx.session?.id);
+        case "invite":
+          return inviteCommand(ctx.session?.id);
+        case "history":
+          return historyCommand(opts, ctx.session?.id, parts.slice(1));
+        case "annotations":
+        case "notes":
+          return annotationsCommand(opts, ctx.session?.id);
+        case "help":
+        case "--help":
+        case "-h":
+          return helpCommand();
+        default:
+          return {
+            message: color.yellow(
+              `Unknown subcommand: ${sub}. Try: /collab status | invite | history | annotations`
+            )
+          };
+      }
+    }
+  };
+}
+function statusCommand(sessionId) {
+  const lines = [];
+  lines.push(color.bold("Live collaboration"));
+  lines.push(`  Session: ${color.cyan(sessionId ?? "(none)")}`);
+  lines.push(`  Observers: ${color.dim("unknown (check webui)")}`);
+  lines.push("");
+  lines.push(
+    color.dim(
+      "  Tip: /collab invite \u2014 print a webui join link for a teammate"
+    )
+  );
+  lines.push(
+    color.dim("       /collab history 20 \u2014 show the last 20 events of this session")
+  );
+  return { message: lines.join("\n") };
+}
+function inviteCommand(sessionId) {
+  if (!sessionId) {
+    return { message: color.yellow("No active session to invite to.") };
+  }
+  const url = `http://127.0.0.1:3457/?session=${encodeURIComponent(sessionId)}`;
+  const lines = [
+    color.bold("Live-collaboration invite"),
+    `  Session ID: ${color.cyan(sessionId)}`,
+    `  Share this URL with a teammate (they must be able to reach your machine):`,
+    `    ${color.cyan(url)}`,
+    "",
+    color.dim(
+      '  The teammate opens the URL in their browser, then clicks "Join as observer"'
+    ),
+    color.dim("  on the panel that appears above the chat. They will see a live mirror"),
+    color.dim("  of tool calls, iterations, and subagent spawns \u2014 read-only."),
+    "",
+    color.dim("  Reminder: expose the port with: pnpm --filter @wrongstack/webui dev")
+  ];
+  return { message: lines.join("\n") };
+}
+async function historyCommand(opts, sessionId, args) {
+  const limit = Math.max(1, Math.min(200, Number.parseInt(args[0] ?? "20", 10) || 20));
+  if (!sessionId) return { message: color.yellow("No active session.") };
+  if (!opts.sessionStore) {
+    return { message: color.yellow("No session store configured.") };
+  }
+  const { DefaultSessionReader: DefaultSessionReader2 } = await import('@wrongstack/core');
+  const reader = new DefaultSessionReader2({ store: opts.sessionStore });
+  const events = [];
+  try {
+    for await (const ev of reader.replay(sessionId)) {
+      events.push(ev);
+    }
+  } catch (err) {
+    return {
+      message: color.yellow(
+        `Failed to read session: ${err instanceof Error ? err.message : String(err)}`
+      )
+    };
+  }
+  const tail = events.slice(-limit);
+  if (tail.length === 0) {
+    return { message: color.dim("No events recorded yet for this session.") };
+  }
+  const lines = [
+    color.bold(`Last ${tail.length} events of ${sessionId}`),
+    ""
+  ];
+  for (const raw of tail) {
+    const ev = raw;
+    const t = ev.ts ? color.dim(ev.ts.slice(11, 19)) : color.dim("--:--:--");
+    const kind = color.cyan((ev.type ?? "unknown").padEnd(16));
+    const summary = summarise(ev);
+    lines.push(`  ${t}  ${kind}  ${summary}`);
+  }
+  return { message: lines.join("\n") };
+}
+async function annotationsCommand(opts, sessionId) {
+  if (!sessionId) return { message: color.yellow("No active session.") };
+  if (!opts.sessionStore) {
+    return { message: color.yellow("No session store configured.") };
+  }
+  const { DefaultSessionReader: DefaultSessionReader2, AnnotationsStore } = await import('@wrongstack/core');
+  new DefaultSessionReader2({ store: opts.sessionStore });
+  const storeDir = opts.sessionStore.dir;
+  if (!storeDir) {
+    return {
+      message: color.yellow(
+        "Annotations view needs the session store dir; not exposed in this build."
+      )
+    };
+  }
+  const annotations = new AnnotationsStore({ dir: storeDir });
+  const open = await annotations.listOpen(sessionId);
+  if (open.length === 0) {
+    return {
+      message: color.dim("No open annotations for this session.")
+    };
+  }
+  const lines = [
+    color.bold(`${open.length} open annotation(s) for ${sessionId}`),
+    ""
+  ];
+  for (const a of open) {
+    const t = color.dim(a.createdAt.slice(11, 19));
+    const author = color.cyan(a.authorId.slice(0, 8));
+    const idx = color.dim(`#${a.atEventIndex}`);
+    lines.push(`  ${t}  ${idx}  ${author}  ${a.text}`);
+  }
+  return { message: lines.join("\n") };
+}
+function summarise(ev) {
+  switch (ev["type"]) {
+    case "user_input": {
+      const text = typeof ev["text"] === "string" ? ev["text"] : "";
+      return color.dim(truncate(text, 80));
+    }
+    case "llm_response": {
+      const text = typeof ev["text"] === "string" ? ev["text"] : "";
+      return color.dim(truncate(text, 80));
+    }
+    case "tool_result": {
+      const name = String(ev["name"] ?? "?");
+      const ok = ev["ok"] === false ? color.red("(failed)") : color.green("(ok)");
+      return `${name} ${ok}`;
+    }
+    case "compaction": {
+      const before = ev["before"];
+      const after = ev["after"];
+      return `tokens ${before}\u2192${after}`;
+    }
+    case "error": {
+      return color.red(String(ev["message"] ?? "(no message)"));
+    }
+    default: {
+      return color.dim(JSON.stringify(ev).slice(0, 80));
+    }
+  }
+}
+function truncate(s, n) {
+  if (s.length <= n) return s;
+  return `${s.slice(0, n - 1)}\u2026`;
+}
+function helpCommand() {
+  const lines = [
+    color.bold("/collab \u2014 live collaboration (read-only observers)"),
+    "",
+    "Subcommands:",
+    `  ${color.cyan("status")}             Show current session's collaboration status`,
+    `  ${color.cyan("invite")}            Print a webui join link for a teammate`,
+    `  ${color.cyan("history [N]")}       Show the last N events of this session (default 20, max 200)`,
+    `  ${color.cyan("annotations")}       List open (unresolved) annotations from webui annotators`,
+    `  ${color.cyan("help")}              Show this help`,
+    "",
+    color.dim(
+      "  The observer flow itself lives in the webui: open the URL printed"
+    ),
+    color.dim('  by `invite` and click "Join as observer" on the panel above the chat.')
+  ];
+  return { message: lines.join("\n") };
+}
 
 // src/slash-commands/worktree.ts
 function buildWorktreeCommand(opts) {
@@ -5524,6 +5880,7 @@ function buildBuiltinSlashCommands(opts) {
     buildAutoPhaseCommand(opts),
     buildWorktreeCommand(opts),
     buildSettingsCommand(opts),
+    buildCollabCommand(opts),
     buildStatuslineCommand({
       cwd: opts.cwd,
       hiddenItems: opts.statuslineHiddenItems ?? [],
@@ -5753,7 +6110,11 @@ async function bootConfig(flags) {
     }
   }
   const configLoader = new DefaultConfigLoader({ paths: wpaths, vault });
-  const config = await configLoader.load({ cliFlags: flagsToConfigPatch(flags) });
+  let config = await configLoader.load({ cliFlags: flagsToConfigPatch(flags) });
+  const syncConfig = await configLoader.loadSyncConfig();
+  if (syncConfig) {
+    config = Object.freeze({ ...config, sync: syncConfig });
+  }
   return {
     paths: { cwd, projectRoot, userHome, wpaths, pathResolver },
     config,
@@ -5906,7 +6267,7 @@ var ReadlineInputReader = class {
    * user gets visual confirmation that bytes are arriving (especially on
    * paste, which previously felt like nothing happened). Pasted chunks
    * are echoed as a run of bullets, Backspace/DEL erases one bullet, and
-   * Ctrl+U / Ctrl+W are honored. Non-TTY input is read normally — there's
+   * Ctrl+U / Ctrl+T are honored. Non-TTY input is read normally — there's
    * nothing to hide when piped, and echoing bullets to a file is noise.
    *
    * Returns the raw entered string (no trim — caller decides).
@@ -7844,9 +8205,9 @@ var updateCmd = async (args, deps) => {
         cwd,
         stdio: "pipe"
       });
-      let stderr = "";
+      let _stderr = "";
       child.stderr?.on("data", (d) => {
-        stderr += d;
+        _stderr += d;
       });
       child.on("error", reject);
       child.on("close", (code) => resolve4({ code: code ?? 0 }));
@@ -9080,6 +9441,167 @@ ${result.errors.length} error(s):
     return 1;
   }
 };
+var replayCmd = async (args, deps) => {
+  const wpaths = resolveWstackPaths({
+    projectRoot: deps.projectRoot,
+    userHome: deps.userHome
+  });
+  const store = new ReplayLogStore({ dir: wpaths.projectSessions });
+  if (args[0] === "--list" || args[0] === "-l") {
+    const all = await store.list();
+    if (all.length === 0) {
+      deps.renderer.write(
+        color.dim("No replay logs recorded yet. Run with --record to start one.") + "\n"
+      );
+      return 0;
+    }
+    const lines2 = [
+      color.bold(`${all.length} replay log(s)`),
+      color.dim("  Sorted by session id. Each entry has at least one recorded request/response."),
+      ""
+    ];
+    for (const r of all) {
+      lines2.push(
+        `  ${color.cyan(r.sessionId)}  ${color.dim(`${r.entryCount} entries`)}  ${color.dim(r.path)}`
+      );
+    }
+    lines2.push("");
+    lines2.push(
+      color.dim(
+        "  Inspect:  wstack replay <sessionId>"
+      )
+    );
+    lines2.push(
+      color.dim(
+        "  Replay:   wstack --replay <sessionId>"
+      )
+    );
+    deps.renderer.write(lines2.join("\n") + "\n");
+    return 0;
+  }
+  const sessionId = args[0];
+  if (!sessionId) {
+    deps.renderer.writeError(
+      "Usage: wstack replay <sessionId>\n       wstack replay --list\n\nLists recorded provider responses for the session. To actually\nre-run the agent with frozen responses, use:\n  wstack --replay " + color.cyan("<sessionId>") + "\n  wstack --record                   # start a fresh recording\n"
+    );
+    return 1;
+  }
+  const entries = await store.load(sessionId);
+  if (entries.length === 0) {
+    deps.renderer.write(
+      color.yellow(
+        `No replay entries recorded for session ${sessionId}.
+Run a session with --record first, then --replay to re-execute it.`
+      ) + "\n"
+    );
+    return 0;
+  }
+  const lines = [
+    color.bold(`Replay log for ${sessionId}`),
+    `  ${entries.length} recorded request/response pair(s)`,
+    `  Log file: ${color.dim(`${sessionId}.replay.jsonl`)}`,
+    "",
+    "To replay this session deterministically:",
+    `  ${color.cyan(`wstack --replay ${sessionId}`)}`,
+    "",
+    "Recorded timestamps (oldest first):"
+  ];
+  for (const e of entries.slice(-10)) {
+    lines.push(
+      `  ${color.dim(e.ts.slice(11, 19))}  ${e.hash.slice(0, 16)}\u2026  ${e.request.model}`
+    );
+  }
+  if (entries.length > 10) {
+    lines.push(color.dim(`  \u2026 and ${entries.length - 10} more`));
+  }
+  deps.renderer.write(lines.join("\n") + "\n");
+  return 0;
+};
+var auditCmd = async (args, deps) => {
+  const wpaths = resolveWstackPaths({
+    projectRoot: deps.projectRoot,
+    userHome: deps.userHome
+  });
+  const log = new ToolAuditLog({ dir: wpaths.projectSessions });
+  if (args[0] === "--list" || args[0] === "-l") {
+    return listAudits(log, wpaths.projectSessions, deps);
+  }
+  const sessionId = args[0];
+  if (!sessionId) {
+    deps.renderer.writeError(
+      "Usage: wstack audit <sessionId>\n       wstack audit --list\n\nInspects a session's tamper-evident tool audit log. Each entry\nis chained to the previous via SHA-256; any post-hoc modification\nbreaks the chain. Use this to verify a session was not tampered\nwith after recording.\n"
+    );
+    return 1;
+  }
+  const entries = await log.load(sessionId);
+  if (entries.length === 0) {
+    deps.renderer.write(
+      color.yellow(
+        `No audit entries for session ${sessionId}. (The audit log is written when tools are recorded \u2014 check that the session ran with audit enabled.)`
+      ) + "\n"
+    );
+    return 0;
+  }
+  const verify = await log.verify(sessionId);
+  const lines = [
+    color.bold(`Audit log for ${sessionId}`),
+    verify.ok ? `  ${color.green("\u2713 Verified")}  ${entries.length} entries, chain intact` : `  ${color.red("\u2717 BROKEN")}  at entry ${verify.brokenAt}: ${verify.reason}`,
+    "",
+    "  Entries (oldest first):"
+  ];
+  const cap = 12;
+  for (const e of entries.slice(0, cap)) {
+    const t = color.dim(e.ts.slice(11, 19));
+    const idx = color.dim(`#${e.index}`.padStart(4));
+    const tool = e.toolName;
+    const err = e.isError ? color.red("(error)") : "";
+    lines.push(
+      `    ${t}  ${idx}  ${color.cyan(tool.padEnd(14))} ${err}  ${color.dim(e.hash.slice(0, 12) + "\u2026")}`
+    );
+  }
+  if (entries.length > cap) {
+    lines.push(color.dim(`    \u2026 and ${entries.length - cap} more`));
+  }
+  deps.renderer.write(lines.join("\n") + "\n");
+  return verify.ok ? 0 : 1;
+};
+async function listAudits(log, dir, deps) {
+  const fs22 = await import('fs/promises');
+  let entries;
+  try {
+    entries = await fs22.readdir(dir);
+  } catch {
+    deps.renderer.write(
+      color.dim(`No sessions dir found at ${dir}. Run a session first.`) + "\n"
+    );
+    return 0;
+  }
+  const out = [];
+  for (const name of entries) {
+    if (!name.endsWith(".audit.jsonl")) continue;
+    const sessionId = name.slice(0, -".audit.jsonl".length);
+    const all = await log.load(sessionId);
+    const verify = await log.verify(sessionId);
+    out.push({ sessionId, entryCount: all.length, ok: verify.ok });
+  }
+  out.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+  if (out.length === 0) {
+    deps.renderer.write(color.dim("No audit logs recorded yet.") + "\n");
+    return 0;
+  }
+  const lines = [
+    color.bold(`${out.length} audit log(s)`),
+    ""
+  ];
+  for (const r of out) {
+    const status = r.ok ? color.green("\u2713 intact") : color.red("\u2717 broken");
+    lines.push(
+      `  ${color.cyan(r.sessionId)}  ${color.dim(`${r.entryCount} entries`)}  ${status}`
+    );
+  }
+  deps.renderer.write(lines.join("\n") + "\n");
+  return 0;
+}
 var toolsCmd = async (_args, deps) => {
   const reg = deps.toolRegistry;
   if (!reg) return 0;
@@ -9146,6 +9668,8 @@ var subcommands = {
   sessions: sessionsCmd,
   config: configCmd,
   rewind: rewindCmd,
+  replay: replayCmd,
+  audit: auditCmd,
   tools: toolsCmd,
   skills: skillsCmd,
   providers: providersCmd,
@@ -9182,22 +9706,22 @@ function fmtDuration(ms) {
   const remMin = m - h * 60;
   return `${h}h${remMin}m`;
 }
-function fmtTaskResultLine(r, color37) {
+function fmtTaskResultLine(r, color41) {
   const stats = `${r.iterations}it ${r.toolCalls}tc ${fmtDuration(r.durationMs)}`;
   const errMsg = typeof r.error === "string" ? r.error : r.error?.message;
   const errKind = typeof r.error === "object" ? r.error?.kind : void 0;
   const errTail = errMsg ? ` \u2014 ${errMsg.replace(/\s+/g, " ").slice(0, 80)}${errMsg.length > 80 ? "\u2026" : ""}` : "";
-  const errKindChip = errKind ? color37.dim(` [${errKind}]`) : "";
-  const errSnip = errMsg || errKind ? `${errKindChip}${color37.dim(errTail)}` : "";
+  const errKindChip = errKind ? color41.dim(` [${errKind}]`) : "";
+  const errSnip = errMsg || errKind ? `${errKindChip}${color41.dim(errTail)}` : "";
   switch (r.status) {
     case "success":
-      return { mark: color37.green("\u2713"), stats, tail: "" };
+      return { mark: color41.green("\u2713"), stats, tail: "" };
     case "timeout":
-      return { mark: color37.yellow("\u23F1"), stats: `${color37.yellow("timeout")} ${stats}`, tail: errSnip };
+      return { mark: color41.yellow("\u23F1"), stats: `${color41.yellow("timeout")} ${stats}`, tail: errSnip };
     case "stopped":
-      return { mark: color37.dim("\u2298"), stats: `${color37.dim("stopped")} ${stats}`, tail: errSnip };
+      return { mark: color41.dim("\u2298"), stats: `${color41.dim("stopped")} ${stats}`, tail: errSnip };
     case "failed":
-      return { mark: color37.red("\u2717"), stats: `${color37.red("failed")} ${stats}`, tail: errSnip };
+      return { mark: color41.red("\u2717"), stats: `${color41.red("failed")} ${stats}`, tail: errSnip };
   }
 }
 
@@ -9687,7 +10211,7 @@ async function runRepl(opts) {
           );
           interrupts = 0;
           try {
-            const ok = await engine.runOneIteration();
+            await engine.runOneIteration();
             const afterGoal = await loadGoalSafe(opts);
             const last = afterGoal?.journal[afterGoal.journal.length - 1];
             if (coord) {
@@ -9801,7 +10325,7 @@ ${color.dim(taskList2)}
                   }
                 }
               }
-            } catch (runErr) {
+            } catch (_runErr) {
               opts.renderer.writeWarning("AI auto-trigger failed. You can continue manually.");
             }
           }
@@ -10501,7 +11025,7 @@ async function execute(deps) {
     fleetStatusLine?.stop();
     try {
       stats.render(renderer);
-    } catch (err) {
+    } catch (_err) {
     }
     await Promise.resolve(detachTodosCheckpoint?.()).catch(() => void 0);
     await mcpRegistry.stopAll();
@@ -10526,6 +11050,15 @@ var MultiAgentHost = class {
   /** Own FleetManager — created in buildDirector(), used for pending task
    *  tracking so status() can show descriptions without host-side state. */
   fleetManager;
+  /** Own FleetEmitTool — created in buildDirector() so subagents in director
+   *  mode can publish structured events (bug.found, refactor.plan,
+   *  critic.evaluation) onto the fleet bus without needing the tool registered
+   *  in the host's ToolRegistry. */
+  fleetEmitTool;
+  /** Own FleetStatusTool — created in buildDirector() so subagents in director
+   *  mode can read fleet state (subagent statuses, task progress) without the
+   *  tool being in the host's ToolRegistry. */
+  fleetStatusTool;
   /** Lazily built alongside the director — produces per-subagent JSONL
    *  writers under `<sessionsRoot>/<runId>/`. Null without sessionsRoot. */
   sessionFactory;
@@ -10562,7 +11095,7 @@ var MultiAgentHost = class {
   getDirector() {
     return this.director;
   }
-  async ensureCoordinator(config) {
+  async ensureCoordinator(_config) {
     await this.buildDirector();
   }
   async buildDirector() {
@@ -10629,6 +11162,15 @@ var MultiAgentHost = class {
         totalExtensions: payload.totalExtensions
       });
     });
+    this.director.fleet.filter("ctx.pct", (e) => {
+      const payload = e.payload;
+      this.deps.events.emit("subagent.ctx_pct", {
+        subagentId: e.subagentId,
+        load: payload.load,
+        tokens: payload.tokens,
+        maxContext: payload.maxContext
+      });
+    });
     this.getCoordinator().on(
       "task.assigned",
       ({
@@ -10642,9 +11184,19 @@ var MultiAgentHost = class {
         });
       }
     );
+    this.fleetEmitTool = makeFleetEmitTool(this.director);
+    this.fleetStatusTool = makeFleetStatusTool(this.director);
     const runner = await this.buildSubagentRunner(config);
     this.getCoordinator().setRunner(runner);
   }
+  /**
+   * Returns the FleetEmitTool for director-mode subagents, if the director
+   * has been built. Used by makeSubagentFactory to inject the tool into
+   * the filtered tool registry so collab session agents can emit fleet events.
+   */
+  getFleetEmitTool() {
+    return this.fleetEmitTool;
+  }
   /**
    * Build a per-role subagent factory: given a SubagentConfig, construct a
    * fresh, isolated Agent with the role's filtered tools and (when the config
@@ -10689,6 +11241,21 @@ var MultiAgentHost = class {
           append: (ev) => parentSession.append({ ...ev })
         };
       }
+      const tools = subCfg.tools ? [...subCfg.tools] : void 0;
+      let injectedFleetEmit;
+      let injectedFleetStatus;
+      if (tools) {
+        const emitIdx = tools.indexOf("fleet_emit");
+        if (emitIdx >= 0 && this.fleetEmitTool) {
+          tools.splice(emitIdx, 1);
+          injectedFleetEmit = this.fleetEmitTool;
+        }
+        const statusIdx = tools.indexOf("fleet_status");
+        if (statusIdx >= 0 && this.fleetStatusTool) {
+          tools.splice(statusIdx, 1);
+          injectedFleetStatus = this.fleetStatusTool;
+        }
+      }
       const ctx = new Context({
         systemPrompt: baseSystem,
         provider,
@@ -10698,9 +11265,12 @@ var MultiAgentHost = class {
         cwd: subCwd,
         projectRoot: this.deps.projectRoot,
         model: subCfg.model ?? config.model,
-        tools: this.filterTools(subCfg.tools)
+        tools: this.filterTools(tools)
       });
-      const toolExecutor = new ToolExecutor(this.subagentToolRegistry(subCfg.tools), {
+      const baseRegistry = this.subagentToolRegistry(tools);
+      if (injectedFleetEmit) baseRegistry.register(injectedFleetEmit);
+      if (injectedFleetStatus) baseRegistry.register(injectedFleetStatus);
+      const toolExecutor = new ToolExecutor(baseRegistry, {
         permissionPolicy: new AutoApprovePermissionPolicy(),
         secretScrubber: this.deps.secretScrubber,
         renderer: this.deps.renderer,
@@ -10712,7 +11282,7 @@ var MultiAgentHost = class {
       });
       const agent = new Agent({
         container: this.deps.container,
-        tools: this.subagentToolRegistry(subCfg.tools),
+        tools: baseRegistry,
         providers: this.deps.providerRegistry,
         events,
         pipelines: createDefaultPipelines(),
@@ -11111,9 +11681,9 @@ function makeConfirmAwaiter(reader) {
 function stringifyInput(input) {
   if (!input || typeof input !== "object") return "";
   const obj = input;
-  return Object.entries(obj).filter(([k]) => k !== "content" && k !== "new_string").map(([k, v]) => `${k}: ${truncate(JSON.stringify(v), 80)}`).join("  ");
+  return Object.entries(obj).filter(([k]) => k !== "content" && k !== "new_string").map(([k, v]) => `${k}: ${truncate2(JSON.stringify(v), 80)}`).join("  ");
 }
-function truncate(s, max) {
+function truncate2(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 function hasDiff(input) {
@@ -11121,6 +11691,26 @@ function hasDiff(input) {
     input && typeof input === "object" && "diff" in input
   );
 }
+function bindReplayToContainer(opts) {
+  const { container, wpaths, sessionId, mode, logger } = opts;
+  if (!opts.container.has(TOKENS.ProviderRunner)) {
+    container.bind(TOKENS.ProviderRunner, () => ({
+      run: (o) => runProviderWithRetry(o)
+    }));
+  }
+  const inner = container.resolve(TOKENS.ProviderRunner);
+  const log = new ReplayLogStore({ dir: wpaths.projectSessions });
+  const wrapped = new ReplayProviderRunner(inner, {
+    log,
+    sessionId,
+    mode,
+    logger: logger ? {
+      debug: (m) => logger.debug?.(m),
+      warn: (m) => logger.warn?.(m)
+    } : void 0
+  });
+  container.bind(TOKENS.ProviderRunner, () => wrapped);
+}
 var SessionStats = class {
   tokenCounter;
   startedAt = Date.now();
@@ -11599,7 +12189,6 @@ async function setupCompaction(params) {
 function createAgent(params) {
   const secretScrubber = params.container.resolve(TOKENS.SecretScrubber);
   const renderer = params.container.has(TOKENS.Renderer) ? params.container.resolve(TOKENS.Renderer) : void 0;
-  params.container.resolve(TOKENS.Logger);
   const toolExecutor = new ToolExecutor(params.tools, {
     permissionPolicy: params.permissionPolicy ?? params.container.resolve(TOKENS.PermissionPolicy),
     secretScrubber,
@@ -11983,7 +12572,6 @@ async function main(argv) {
     wpaths,
     cwd,
     projectRoot,
-    userHome,
     flags,
     positional,
     modelsRegistry,
@@ -12025,6 +12613,22 @@ async function main(argv) {
     compactor: { preserveK: config.context.preserveK, eliseThreshold: config.context.eliseThreshold },
     bundledSkillsDir: config.features.skills ? resolveBundledSkillsDir2() : void 0
   });
+  const replayFlag = flags["replay"];
+  const recordFlag = flags["record"];
+  if (typeof replayFlag === "string" || recordFlag === true) {
+    const sessionId = typeof replayFlag === "string" ? replayFlag : `record-${Date.now()}`;
+    const mode = recordFlag === true ? "record" : "replay";
+    bindReplayToContainer({
+      container,
+      wpaths,
+      sessionId,
+      mode,
+      logger
+    });
+    logger.info(
+      `replay: ProviderRunner bound in '${mode}' mode for session ${sessionId}`
+    );
+  }
   const configStore = container.resolve(TOKENS.ConfigStore);
   container.bind(TOKENS.PathResolver, () => pathResolver);
   container.bind(TOKENS.Renderer, () => renderer);
@@ -12092,7 +12696,7 @@ async function main(argv) {
   }
   const events = new EventBus();
   events.setLogger(logger);
-  const { metricsSink, healthRegistry, metricsServerHandle } = (() => {
+  const { metricsSink, healthRegistry } = (() => {
     const ms = setupMetrics({ flags, wpaths, events, logger, config: { provider: config.provider, model: config.model } });
     return ms;
   })();
@@ -12171,7 +12775,6 @@ async function main(argv) {
   });
   const session = sessResult.session;
   sessionRef.current = session;
-  sessResult.restoredMessages;
   const context = sessResult.context;
   const attachments = sessResult.attachments;
   const recoveryLock = sessResult.recoveryLock;