@wrongstack/cli 0.9.19 → 0.10.0

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, makeFleetEmitTool, 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';
@@ -13,6 +13,7 @@ import { MCPRegistry } from '@wrongstack/mcp';
 import { buildProviderFactoriesFromRegistry, makeProviderFromConfig, capabilitiesFor } from '@wrongstack/providers';
 import { createDefaultContainer, routeImagesForModel, readClipboardImage } from '@wrongstack/runtime';
 import { builtinToolsPack, rememberTool, forgetTool } from '@wrongstack/tools';
+import { fileURLToPath } from 'url';
 import * as readline from 'readline';
 import * as fs10 from 'fs';
 import { writeFileSync } from 'fs';
@@ -380,12 +381,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 +1022,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 +1243,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 +1657,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 +1978,7 @@ async function runWebUI(opts) {
       }
     }
   }
-  async function handleUserMessage(ws, client, content) {
+  async function handleUserMessage(ws, _client, content) {
     if (abortController) {
       send(ws, {
         type: "error",
@@ -2356,6 +2354,7 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "recover",
   "no-alt-screen",
   "alt-screen",
+  "mouse",
   "output-json",
   "prompt",
   "metrics",
@@ -3553,8 +3552,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 +3641,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 +3666,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 +4291,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 +4352,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 +4360,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 +5475,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 +5882,7 @@ function buildBuiltinSlashCommands(opts) {
     buildAutoPhaseCommand(opts),
     buildWorktreeCommand(opts),
     buildSettingsCommand(opts),
+    buildCollabCommand(opts),
     buildStatuslineCommand({
       cwd: opts.cwd,
       hiddenItems: opts.statuslineHiddenItems ?? [],
@@ -7848,9 +8207,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 }));
@@ -9084,6 +9443,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;
@@ -9150,6 +9670,8 @@ var subcommands = {
   sessions: sessionsCmd,
   config: configCmd,
   rewind: rewindCmd,
+  replay: replayCmd,
+  audit: auditCmd,
   tools: toolsCmd,
   skills: skillsCmd,
   providers: providersCmd,
@@ -9186,27 +9708,35 @@ 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 };
   }
 }
 
 // src/boot.ts
 init_update_check();
+var GITHUB_PROVIDERS_OVERLAY_URL = "https://raw.githubusercontent.com/WrongStack/WrongStack/main/packages/cli/data/providers.json";
+function resolveBundledOverlayFile() {
+  try {
+    return fileURLToPath(new URL("../data/providers.json", import.meta.url));
+  } catch {
+    return void 0;
+  }
+}
 function resolveBundledSkillsDir() {
   try {
     const req2 = createRequire(import.meta.url);
@@ -9222,6 +9752,10 @@ async function boot(argv) {
     flags["resume"] = positional[1];
     positional.splice(0, 2);
   }
+  if (positional.length === 0) {
+    if (flags["help"] === true) positional.push("help");
+    else if (flags["version"] === true) positional.push("version");
+  }
   let bootResult;
   try {
     bootResult = await bootConfig(flags);
@@ -9238,7 +9772,12 @@ async function boot(argv) {
   const reader = new ReadlineInputReader({ historyFile: wpaths.historyFile });
   const modelsRegistry = new DefaultModelsRegistry({
     cacheFile: wpaths.modelsCache,
-    ttlSeconds: 24 * 3600
+    ttlSeconds: 24 * 3600,
+    // Curated overlay merged on top of models.dev: fetched from GitHub raw for
+    // freshness, with the bundled file as the offline floor.
+    overlayUrl: GITHUB_PROVIDERS_OVERLAY_URL,
+    overlayFile: resolveBundledOverlayFile(),
+    overlayCacheFile: wpaths.modelsOverlayCache
   });
   let updateInfo;
   if (!flags["no-check"] && !process.env["WRONGSTACK_NO_CHECK"]) {
@@ -9691,7 +10230,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) {
@@ -9805,7 +10344,7 @@ ${color.dim(taskList2)}
                   }
                 }
               }
-            } catch (runErr) {
+            } catch (_runErr) {
               opts.renderer.writeWarning("AI auto-trigger failed. You can continue manually.");
             }
           }
@@ -10391,9 +10930,15 @@ async function execute(deps) {
           // Default OFF so the terminal's native scrollback works for chat
           // history out of the box (mouse wheel / Shift+PgUp). Users who hit
           // resize/overlay-leak artifacts can opt back into alt-screen with
-          // `--alt-screen` or `/altscreen on`. `--no-alt-screen` still wins
-          // when both are passed.
+          // `--alt-screen`. `--no-alt-screen` still wins when both are passed.
           altScreen: flags["alt-screen"] === true && flags["no-alt-screen"] !== true,
+          // Full mouse mode: clickable pickers + in-app wheel scroll. Opt-in
+          // via --mouse. The TUI combines altScreen || mouse to determine
+          // whether to use the managed viewport (ScrollableHistory + in-app
+          // scroll); --mouse alone enables that without requiring --alt-screen.
+          // Mouse mode takes ownership of the terminal's mouse, suspending
+          // native scroll/copy until `/mouse off`.
+          mouse: flags.mouse === true,
           director,
           fleetRoster,
           onAfterExit: () => {
@@ -10505,7 +11050,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();
@@ -10535,6 +11080,10 @@ var MultiAgentHost = class {
    *  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;
@@ -10571,7 +11120,7 @@ var MultiAgentHost = class {
   getDirector() {
     return this.director;
   }
-  async ensureCoordinator(config) {
+  async ensureCoordinator(_config) {
     await this.buildDirector();
   }
   async buildDirector() {
@@ -10638,6 +11187,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",
       ({
@@ -10652,6 +11210,7 @@ var MultiAgentHost = class {
       }
     );
     this.fleetEmitTool = makeFleetEmitTool(this.director);
+    this.fleetStatusTool = makeFleetStatusTool(this.director);
     const runner = await this.buildSubagentRunner(config);
     this.getCoordinator().setRunner(runner);
   }
@@ -10674,7 +11233,11 @@ var MultiAgentHost = class {
   makeSubagentFactory(config) {
     return async (subCfg) => {
       const events = new EventBus();
-      const provider = await this.buildSubagentProvider(config, subCfg.provider);
+      const provider = await this.buildSubagentProvider(
+        config,
+        subCfg.provider,
+        subCfg.model ?? config.model
+      );
       const subCwd = subCfg.cwd ?? this.deps.cwd;
       const baseSystem = await this.deps.systemPromptBuilder.build({
         cwd: subCwd,
@@ -10709,11 +11272,17 @@ var MultiAgentHost = class {
       }
       const tools = subCfg.tools ? [...subCfg.tools] : void 0;
       let injectedFleetEmit;
-      if (tools?.includes("fleet_emit")) {
-        const fleetTool = this.fleetEmitTool;
-        if (fleetTool) {
-          tools.splice(tools.indexOf("fleet_emit"), 1);
-          injectedFleetEmit = fleetTool;
+      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({
@@ -10729,6 +11298,7 @@ var MultiAgentHost = class {
       });
       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,
@@ -10805,17 +11375,28 @@ var MultiAgentHost = class {
    * not configured (so a typo doesn't crash the whole run — we just
    * use the leader and the calling code can decide to error later).
    */
-  async buildSubagentProvider(config, overrideId) {
+  async buildSubagentProvider(config, overrideId, model) {
     const providerId = overrideId && config.providers?.[overrideId] ? overrideId : config.provider;
     const newCfg = config.providers?.[providerId] ?? {
       type: providerId,
       apiKey: config.apiKey,
       baseUrl: config.baseUrl
     };
-    return makeProviderFromConfig(providerId, {
+    const provider = makeProviderFromConfig(providerId, {
       ...newCfg,
       type: providerId
     });
+    if (this.deps.modelsRegistry) {
+      const resolvedModel = model ?? config.model;
+      const caps = await capabilitiesFor(
+        this.deps.modelsRegistry,
+        providerId,
+        resolvedModel
+      ).catch(() => void 0);
+      const mc = caps?.maxContext ?? config.context?.effectiveMaxContext ?? provider.capabilities.maxContext;
+      if (mc && mc > 0) provider.capabilities.maxContext = mc;
+    }
+    return provider;
   }
   async spawnACP(subagentId, task, config) {
     const taskId = randomUUID();
@@ -11140,9 +11721,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) {
@@ -11150,6 +11731,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();
@@ -11577,6 +12178,13 @@ function renderProgress3(ratio, width) {
   const capped = Math.min(width, filled);
   return FILLED2.repeat(capped) + EMPTY2.repeat(width - capped);
 }
+var createSessionEventBridge = (_writer, level) => ({
+  append: async (_e) => {
+  },
+  level: level ?? "standard",
+  allows: () => true
+});
+var resolveAuditLevel = (cfg) => cfg?.session?.auditLevel ?? "standard";
 function setupPipelines(params) {
   const { events, logger } = params;
   const pipelines = createDefaultPipelines();
@@ -11603,11 +12211,13 @@ function setupPipelines(params) {
   return pipelines;
 }
 async function setupCompaction(params) {
-  const { compactor, events, modelsRegistry, context, config, provider, pipelines } = params;
+  const { compactor, events, modelsRegistry, context, config, provider, pipelines, fullConfig, sessionWriter, sessionBridge: providedBridge } = params;
   const resolvedCaps = await capabilitiesFor(modelsRegistry, provider.id, context.model).catch(() => void 0);
   const effectiveMaxContext = config.context.effectiveMaxContext ?? resolvedCaps?.maxContext ?? provider.capabilities.maxContext;
   let autoCompactor;
   if (config.context.autoCompact !== false) {
+    const auditLevel = resolveAuditLevel(fullConfig ?? config);
+    const sessionBridge = providedBridge ?? createSessionEventBridge(sessionWriter, auditLevel);
     autoCompactor = new AutoCompactionMiddleware(
       compactor,
       effectiveMaxContext,
@@ -11619,7 +12229,12 @@ async function setupCompaction(params) {
         soft: config.context.softThreshold,
         hard: config.context.hardThreshold
       },
-      { aggressiveOn: "soft", failureMode: "throw_on_hard", events }
+      {
+        aggressiveOn: "soft",
+        failureMode: "throw_on_hard",
+        events,
+        sessionBridge
+      }
     );
     pipelines.contextWindow.use({ name: "AutoCompaction", handler: autoCompactor.handler() });
   }
@@ -11628,7 +12243,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,
@@ -11993,6 +12607,21 @@ async function setupSession(params) {
 }
 
 // src/index.ts
+var createSessionEventBridge2 = (_writer, level, _opts) => ({
+  append: async (_e) => {
+  },
+  level: level ?? "standard",
+  allows: () => true
+});
+var resolveAuditLevel2 = (cfg) => cfg?.session?.auditLevel ?? "standard";
+var resolveSessionLoggingConfig = (cfg) => ({
+  auditLevel: resolveAuditLevel2(cfg),
+  sampling: {
+    toolProgress: {
+      sampleRate: cfg?.session?.sampling?.toolProgress?.sampleRate ?? 8
+    }
+  }
+});
 function resolveBundledSkillsDir2() {
   try {
     const req2 = createRequire(import.meta.url);
@@ -12012,7 +12641,6 @@ async function main(argv) {
     wpaths,
     cwd,
     projectRoot,
-    userHome,
     flags,
     positional,
     modelsRegistry,
@@ -12054,6 +12682,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);
@@ -12121,7 +12765,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;
   })();
@@ -12200,7 +12844,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;
@@ -12208,18 +12851,99 @@ async function main(argv) {
   const planPath = sessResult.planPath;
   const detachTodosCheckpoint = sessResult.detachTodosCheckpoint;
   const priorFleetState = sessResult.priorFleetState;
+  const sessionConfig = resolveSessionLoggingConfig(config);
+  const sessionBridge = createSessionEventBridge2(
+    session,
+    sessionConfig.auditLevel);
   const stats = new SessionStats(events, tokenCounter);
   const errorRing = [];
   events.on("error", (e) => {
     const err = e.err;
     const code = err && typeof err === "object" && "code" in err && typeof err.code === "string" ? err.code : "UNKNOWN";
     const message = e.err instanceof Error ? e.err.message : String(e.err);
-    errorRing.push({ ts: (/* @__PURE__ */ new Date()).toISOString(), phase: e.phase, code, message });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    errorRing.push({ ts, phase: e.phase, code, message });
     if (errorRing.length > 5) errorRing.shift();
+    sessionBridge.append({
+      type: "error",
+      ts,
+      message,
+      phase: e.phase
+    }).catch(() => {
+    });
+  });
+  events.on("tool.started", (e) => {
+    sessionBridge.append({
+      type: "tool_call_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      name: e.name,
+      id: e.id,
+      input: e.input
+    }).catch(() => {
+    });
+  });
+  events.on("tool.executed", (e) => {
+    sessionBridge.append({
+      type: "tool_call_end",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      name: e.name,
+      id: e.id ?? "",
+      durationMs: e.durationMs,
+      outputSize: e.outputBytes ?? 0,
+      ok: e.ok,
+      outputBytes: e.outputBytes,
+      outputTokens: e.outputTokens,
+      outputLines: e.outputLines
+    }).catch(() => {
+    });
+  });
+  events.on("tool.progress", (e) => {
+    sessionBridge.append({
+      type: "tool_progress",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      name: e.name,
+      id: e.id,
+      event: { type: e.event.type, text: e.event.text, data: e.event.data }
+    }).catch(() => {
+    });
+  });
+  events.on("provider.retry", (e) => {
+    sessionBridge.append({
+      type: "provider_retry",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      providerId: e.providerId,
+      attempt: e.attempt,
+      delayMs: e.delayMs,
+      status: e.status,
+      description: e.description
+    }).catch(() => {
+    });
+  });
+  events.on("provider.error", (e) => {
+    sessionBridge.append({
+      type: "provider_error",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      providerId: e.providerId,
+      status: e.status,
+      description: e.description,
+      retryable: e.retryable
+    }).catch(() => {
+    });
   });
   const pipelines = setupPipelines({ events, logger });
   const compactor = container.resolve(TOKENS.Compactor);
-  const { effectiveMaxContext, autoCompactor } = await setupCompaction({ compactor, events, modelsRegistry, context, config, provider, pipelines });
+  const { effectiveMaxContext, autoCompactor } = await setupCompaction({
+    compactor,
+    events,
+    modelsRegistry,
+    context,
+    config,
+    provider,
+    pipelines,
+    fullConfig: config,
+    sessionBridge
+    // share the same bridge for consistent audit logging (compaction + errors + future)
+  });
   const refreshMaxContext = async (providerId, modelId) => {
     if (!autoCompactor) return;
     const cap = await capabilitiesFor(modelsRegistry, providerId, modelId).catch(() => void 0);
@@ -12316,6 +13040,7 @@ async function main(argv) {
       toolRegistry,
       providerRegistry,
       configStore,
+      modelsRegistry,
       events,
       systemPromptBuilder: promptBuilder,
       session,