@wrongstack/cli 0.1.10 → 0.3.1

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { color, DefaultPathResolver, Container, DefaultConfigStore, TOKENS, DefaultSecretScrubber, DefaultRetryPolicy, DefaultErrorHandler, DefaultTokenCounter, DefaultModeStore, DefaultSessionStore, DefaultMemoryStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultPermissionPolicy, HybridCompactor, ProviderRegistry, ToolRegistry, createContextManagerTool, EventBus, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, createDefaultPipelines, AutoCompactionMiddleware, Agent, SlashCommandRegistry, loadPlugins, FLEET_ROSTER, DefaultLogger, DefaultModelsRegistry, makeDirectorSessionFactory, makeAgentSubagentRunner, Director, DefaultMultiAgentCoordinator, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, DefaultSessionReader, atomicWrite, formatTodosList, InputBuilder, decryptConfigSecrets, encryptConfigSecrets, DefaultPluginAPI } from '@wrongstack/core';
+import { color, DefaultPathResolver, Container, DefaultConfigStore, TOKENS, DefaultSecretScrubber, DefaultRetryPolicy, DefaultErrorHandler, DefaultTokenCounter, DefaultModeStore, DefaultSessionStore, DefaultMemoryStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultPermissionPolicy, HybridCompactor, ProviderRegistry, ToolRegistry, createContextManagerTool, EventBus, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, AutoCompactionMiddleware, Agent, SlashCommandRegistry, loadPlugins, createDelegateTool, FLEET_ROSTER, DefaultLogger, DefaultModelsRegistry, makeDirectorSessionFactory, Director, DefaultMultiAgentCoordinator, makeAgentSubagentRunner, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, DefaultSessionReader, atomicWrite, AutoApprovePermissionPolicy, formatTodosList, emptyPlan, clearPlan, savePlan, removePlanItem, formatPlan, setPlanItemStatus, addPlanItem, InputBuilder, decryptConfigSecrets, encryptConfigSecrets, DefaultPluginAPI } from '@wrongstack/core';
 import * as fs3 from 'fs/promises';
 import { WebSocketServer, WebSocket } from 'ws';
 import { writeFileSync } from 'fs';
@@ -8,7 +8,7 @@ import * as path13 from 'path';
 import { MCPRegistry } from '@wrongstack/mcp';
 import { buildProviderFactoriesFromRegistry, makeProviderFromConfig, capabilitiesFor } from '@wrongstack/providers';
 import { rememberTool, forgetTool } from '@wrongstack/tools';
-import { builtinTools } from '@wrongstack/tools/builtin';
+import { builtinToolsPack } from '@wrongstack/tools/pack';
 import * as os3 from 'os';
 import * as readline from 'readline';
 import { randomUUID } from 'crypto';
@@ -1470,7 +1470,7 @@ function buildStatsCommand(opts) {
 function buildFleetCommand(opts) {
   return {
     name: "fleet",
-    description: "Inspect or control the subagent fleet: /fleet [status|usage|kill <id>|manifest|help]",
+    description: "Inspect or control the subagent fleet: /fleet [status|usage|kill <id>|manifest|retry [taskId]|log <id>|stream on|off|help]",
     help: [
       "Usage:",
       "  /fleet                  Show fleet status (alias for /fleet status).",
@@ -1478,6 +1478,13 @@ function buildFleetCommand(opts) {
       "  /fleet usage            Per-subagent runtime cost.",
       "  /fleet kill <id>        Terminate a running subagent.",
       "  /fleet manifest         Print the director manifest.",
+      "  /fleet retry            List interrupted tasks from the last run.",
+      "  /fleet retry <taskId>   Re-spawn the matching subagent and re-assign the task.",
+      "  /fleet retry all        Re-assign every interrupted task at once.",
+      "  /fleet log              List subagent transcripts available on disk.",
+      "  /fleet log <id>         Print a compact summary of a subagent transcript.",
+      "  /fleet log <id> raw     Dump the full per-subagent JSONL.",
+      "  /fleet stream on|off    Show/hide subagent activity in the main history.",
       "  /fleet help             Show this help."
     ].join("\n"),
     async run(args) {
@@ -1496,6 +1503,38 @@ function buildFleetCommand(opts) {
           if (!target) return { message: "Usage: /fleet kill <subagent-id>" };
           return { message: await opts.onFleet("kill", target) };
         }
+        case "retry": {
+          if (!opts.onFleetRetry) {
+            return { message: "Retry is only available when director mode is active." };
+          }
+          const msg = await opts.onFleetRetry(target);
+          return { message: msg };
+        }
+        case "log": {
+          if (!opts.onFleetLog) {
+            return { message: "Log inspection is only available when a fleet root is configured." };
+          }
+          const [id, ...modeRest] = rest;
+          const mode = modeRest.join(" ").trim() === "raw" ? "raw" : "summary";
+          return { message: await opts.onFleetLog(id, mode) };
+        }
+        case "stream": {
+          const ctrl = opts.fleetStreamController;
+          if (!ctrl) {
+            return { message: "Stream toggle is only available in the TUI." };
+          }
+          const arg = (target ?? "").toLowerCase();
+          if (arg === "" || arg === "status") {
+            return { message: `Fleet streaming is ${ctrl.enabled ? "on" : "off"}.` };
+          }
+          if (arg !== "on" && arg !== "off") {
+            return { message: "Usage: /fleet stream on|off" };
+          }
+          const enabled = arg === "on";
+          ctrl.setEnabled(enabled);
+          ctrl.enabled = enabled;
+          return { message: `Fleet streaming ${enabled ? "enabled" : "disabled"}.` };
+        }
         case "help":
         case "?":
           return {
@@ -1713,6 +1752,66 @@ function buildMetricsCommand(opts) {
     }
   };
 }
+function buildPlanCommand(opts) {
+  return {
+    name: "plan",
+    description: "Strategic plan board: /plan [show|add <title>|done <id|#>|remove <id|#>|clear]",
+    async run(args) {
+      const planPath = opts.planPath;
+      if (!planPath) return { message: "Plan storage is not configured for this session." };
+      const ctx = opts.context;
+      const sessionId = ctx?.session.id ?? "unknown";
+      const [verb, ...rest] = args.trim().split(/\s+/);
+      const restJoined = rest.join(" ").trim();
+      const plan = await loadPlan(planPath) ?? emptyPlan(sessionId);
+      switch (verb) {
+        case "":
+        case "show":
+        case "list": {
+          return { message: formatPlan(plan) };
+        }
+        case "add": {
+          if (!restJoined) return { message: "Usage: /plan add <title>" };
+          const { plan: updated, item } = addPlanItem(plan, restJoined);
+          await savePlan(planPath, updated);
+          return { message: `Added: ${item.title}
+${formatPlan(updated)}` };
+        }
+        case "start":
+        case "progress": {
+          if (!restJoined) return { message: "Usage: /plan start <id|index>" };
+          const updated = setPlanItemStatus(plan, restJoined, "in_progress");
+          await savePlan(planPath, updated);
+          return { message: formatPlan(updated) };
+        }
+        case "done":
+        case "complete": {
+          if (!restJoined) return { message: "Usage: /plan done <id|index>" };
+          const updated = setPlanItemStatus(plan, restJoined, "done");
+          await savePlan(planPath, updated);
+          return { message: formatPlan(updated) };
+        }
+        case "remove":
+        case "delete":
+        case "rm": {
+          if (!restJoined) return { message: "Usage: /plan remove <id|index>" };
+          const updated = removePlanItem(plan, restJoined);
+          await savePlan(planPath, updated);
+          return { message: formatPlan(updated) };
+        }
+        case "clear": {
+          const updated = clearPlan(plan);
+          await savePlan(planPath, updated);
+          return { message: "Plan cleared." };
+        }
+        default:
+          return {
+            message: `Unknown subcommand "${verb}". Try: show | add <title> | start <id|#> | done <id|#> | remove <id|#> | clear`
+          };
+      }
+    }
+  };
+}
 function buildSaveCommand(opts) {
   return {
     name: "save",
@@ -1922,6 +2021,7 @@ function buildBuiltinSlashCommands(opts) {
     buildHealthCommand(opts),
     buildMemoryCommand(opts),
     buildTodosCommand(opts),
+    buildPlanCommand(opts),
     buildSaveCommand(opts),
     buildLoadCommand(opts),
     buildExitCommand(opts)
@@ -3704,6 +3804,35 @@ function fmtTok(n) {
 function patchConfig(base, patch) {
   return Object.freeze({ ...base, ...patch });
 }
+function fmtDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const s = ms / 1e3;
+  if (s < 60) return `${s.toFixed(s < 10 ? 1 : 0)}s`;
+  const m = Math.floor(s / 60);
+  const remSec = Math.round(s - m * 60);
+  if (m < 60) return remSec === 0 ? `${m}m` : `${m}m${remSec}s`;
+  const h = Math.floor(m / 60);
+  const remMin = m - h * 60;
+  return `${h}h${remMin}m`;
+}
+function fmtTaskResultLine(r, color28) {
+  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 ? color28.dim(` [${errKind}]`) : "";
+  const errSnip = errMsg || errKind ? `${errKindChip}${color28.dim(errTail)}` : "";
+  switch (r.status) {
+    case "success":
+      return { mark: color28.green("\u2713"), stats, tail: "" };
+    case "timeout":
+      return { mark: color28.yellow("\u23F1"), stats: `${color28.yellow("timeout")} ${stats}`, tail: errSnip };
+    case "stopped":
+      return { mark: color28.dim("\u2298"), stats: `${color28.dim("stopped")} ${stats}`, tail: errSnip };
+    case "failed":
+      return { mark: color28.red("\u2717"), stats: `${color28.red("failed")} ${stats}`, tail: errSnip };
+  }
+}
 
 // src/boot.ts
 function resolveBundledSkillsDir() {
@@ -3747,7 +3876,10 @@ async function boot(argv) {
       bundledDir: resolveBundledSkillsDir()
     });
     const toolRegistryForSubcmd = new ToolRegistry();
-    for (const t of builtinTools) toolRegistryForSubcmd.register(t);
+    toolRegistryForSubcmd.registerAllOrThrow(
+      [...builtinToolsPack.tools ?? []],
+      builtinToolsPack.name
+    );
     const code = await subcommands[first](positional.slice(1), {
       config,
       renderer,
@@ -4013,7 +4145,10 @@ async function execute(deps) {
     savedProviderCfg,
     resolvedProvider,
     getPickableProviders,
-    switchProviderAndModel
+    switchProviderAndModel,
+    director,
+    fleetRoster,
+    fleetStreamController
   } = deps;
   let code = 0;
   try {
@@ -4021,6 +4156,11 @@ async function execute(deps) {
     if (promptFlag) {
       positional.unshift(promptFlag);
     }
+    const goalFlag = typeof flags["goal"] === "string" ? flags["goal"] : void 0;
+    const askFlag = typeof flags["ask"] === "string" ? flags["ask"] : void 0;
+    if ((goalFlag || askFlag) && positional.length === 0 && !promptFlag) {
+      flags.tui = true;
+    }
     if (positional.length > 0 || promptFlag) {
       const query = positional.join(" ");
       const ctrl = new AbortController();
@@ -4107,7 +4247,14 @@ async function execute(deps) {
           getPickableProviders,
           switchProviderAndModel,
           effectiveMaxContext,
-          altScreen: flags["alt-screen"] === true,
+          // 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.
+          altScreen: flags["alt-screen"] === true && flags["no-alt-screen"] !== true,
+          director,
+          fleetRoster,
           onAfterExit: () => {
             process.stdout.write(
               color.dim(`Session saved: ${session.id} \u2014 resume with `) + color.cyan(`wstack resume ${session.id}`) + "\n"
@@ -4116,7 +4263,10 @@ async function execute(deps) {
           onClearHistory: (dispatch) => {
             dispatch({ type: "clearHistory" });
             dispatch({ type: "resetContextChip" });
-          }
+          },
+          fleetStreamController,
+          initialGoal: goalFlag,
+          initialAsk: askFlag
         });
       } finally {
         renderer.setSilent(false);
@@ -4185,6 +4335,13 @@ var MultiAgentHost = class {
   pending = /* @__PURE__ */ new Map();
   results = [];
   opts;
+  /**
+   * Populated by `promoteToDirector` when it refuses to promote (typically
+   * because a non-director coordinator is already running). The delegate
+   * tool reads this through `getPromotionBlockReason` to render an
+   * actionable error instead of a generic "could not activate director".
+   */
+  promotionBlockReason = null;
   /**
    * Force the lazy build path to run *now* and return the live Director,
    * or null when director mode is off. Used by the CLI to register the
@@ -4208,8 +4365,64 @@ var MultiAgentHost = class {
         directorRunId: this.opts.directorRunId
       });
     }
+    const coordinatorConfig = {
+      coordinatorId: randomUUID(),
+      doneCondition: { type: "all_tasks_done" },
+      maxConcurrent: 8
+      // No defaultBudget. Caps land on a subagent ONLY when the
+      // orchestrator (delegate-tool / spawn_subagent) or the user
+      // (CLI flag) sets them explicitly. The prior defaults
+      // (1000 tools / 200 iter / 4h) silently killed long autonomous
+      // runs; for a "work until done" director we want no implicit
+      // ceilings. The orchestrator can still cap a single subagent
+      // by passing maxToolCalls/maxIterations through the spawn tool.
+    };
+    if (this.opts.directorMode) {
+      this.director = new Director({
+        config: coordinatorConfig,
+        manifestPath: this.opts.manifestPath,
+        sharedScratchpadPath: this.opts.sharedScratchpadPath,
+        stateCheckpointPath: this.opts.stateCheckpointPath,
+        sessionWriter: this.opts.sessionWriter,
+        // Autonomy: allow nested directors a few levels deep. Default
+        // is 2 (root + one tier of workers), which trips the moment a
+        // worker tries to recurse into "let me delegate the parser
+        // analysis to a tighter specialist". 5 lets the director
+        // structure work as deeply as the task requires without us
+        // having to pass a flag every time.
+        maxSpawnDepth: 5
+      });
+      this.director.on("task.completed", ({ task, result }) => {
+        this.results.push(result);
+        this.pending.delete(task.id);
+        this.emitLifecycleCompleted(task.id, result);
+      });
+      this.coordinator = this.director.coordinator;
+    } else {
+      this.coordinator = new DefaultMultiAgentCoordinator(coordinatorConfig, {});
+      this.coordinator.on(
+        "task.completed",
+        ({ task, result }) => {
+          this.results.push(result);
+          this.pending.delete(task.id);
+          this.emitLifecycleCompleted(task.id, result);
+        }
+      );
+    }
+    this.coordinator.on(
+      "task.assigned",
+      ({ task, subagentId }) => {
+        this.deps.events.emit("subagent.task_started", {
+          subagentId,
+          taskId: task.id,
+          description: task.description
+        });
+      }
+    );
     const runner = this.buildSubagentRunner(config);
-    return this.buildCoordinator(runner);
+    const innerCoord = this.opts.directorMode ? this.director.coordinator : this.coordinator;
+    innerCoord.setRunner(runner);
+    return this.coordinator;
   }
   /**
    * Build the per-subagent runner: agent factory → runner. Extracted so
@@ -4224,7 +4437,12 @@ var MultiAgentHost = class {
         projectRoot: this.deps.projectRoot,
         tools: this.filterTools(subCfg.tools),
         model: subCfg.model ?? config.model,
-        provider: subCfg.provider ?? config.provider
+        provider: subCfg.provider ?? config.provider,
+        // Tell the builder this is a subagent build — skips the host's
+        // plan injection so each subagent gets a clean, task-scoped
+        // prompt instead of inheriting strategic context that's
+        // meaningless to a single delegated subtask.
+        subagent: true
       });
       let subSession;
       if (this.sessionFactory) {
@@ -4259,46 +4477,34 @@ var MultiAgentHost = class {
         providers: this.deps.providerRegistry,
         events,
         pipelines: createDefaultPipelines(),
-        context: ctx
-      });
-      return { agent, events };
-    };
-    return makeAgentSubagentRunner({ factory });
-  }
-  /**
-   * Build the coordinator (or Director wrapper) with task-completion
-   * drain wired into the host's result buffer.
-   */
-  buildCoordinator(runner) {
-    const coordinatorConfig = {
-      coordinatorId: randomUUID(),
-      doneCondition: { type: "all_tasks_done" },
-      maxConcurrent: 2,
-      defaultBudget: { maxToolCalls: 20, maxIterations: 20, timeoutMs: 12e4 }
-    };
-    if (this.opts.directorMode) {
-      this.director = new Director({
-        config: coordinatorConfig,
-        runner,
-        manifestPath: this.opts.manifestPath,
-        sharedScratchpadPath: this.opts.sharedScratchpadPath
+        context: ctx,
+        // Subagents cannot answer interactive permission prompts — they
+        // run under a director, not the user. Auto-approve everything
+        // (except tool-level hard denies); the user already authorized
+        // the work when they invoked the leader.
+        permissionPolicy: new AutoApprovePermissionPolicy()
       });
-      this.director.on("task.completed", ({ task, result }) => {
-        this.results.push(result);
-        this.pending.delete(task.id);
+      const hostEvents = this.deps.events;
+      const offToolBridge = events.on("tool.executed", (e) => {
+        hostEvents.emit("subagent.tool_executed", {
+          subagentId: subCfg.id ?? subCfg.name ?? "subagent",
+          name: e.name,
+          durationMs: e.durationMs,
+          ok: e.ok,
+          input: e.input,
+          outputBytes: e.outputBytes
+        });
       });
-      this.coordinator = this.director.coordinator;
-      return this.coordinator;
-    }
-    this.coordinator = new DefaultMultiAgentCoordinator(coordinatorConfig, { runner });
-    this.coordinator.on(
-      "task.completed",
-      ({ task, result }) => {
-        this.results.push(result);
-        this.pending.delete(task.id);
-      }
-    );
-    return this.coordinator;
+      const dispose = async () => {
+        offToolBridge();
+        try {
+          await subSession.close?.();
+        } catch {
+        }
+      };
+      return { agent, events, dispose };
+    };
+    return makeAgentSubagentRunner({ factory, fleetBus: this.director?.fleet });
   }
   /**
    * Build a Provider for a subagent. When `overrideId` is supplied (from
@@ -4348,21 +4554,30 @@ var MultiAgentHost = class {
     const subagentConfig = {
       name: opts?.name ?? "adhoc",
       role: "general",
-      maxToolCalls: 20,
-      maxIterations: 20,
       provider: opts?.provider,
       model: opts?.model,
       tools: opts?.tools
     };
+    const transcriptPath = this.sessionFactory ? path13.join(this.sessionFactory.dir, `${subagentConfig.name}.jsonl`) : void 0;
     if (this.director) {
       const subagentId = await this.director.spawn(subagentConfig);
       const taskId2 = randomUUID();
       this.pending.set(taskId2, { description, subagentId });
+      this.deps.events.emit("subagent.spawned", {
+        subagentId,
+        taskId: taskId2,
+        name: subagentConfig.name,
+        provider: opts?.provider,
+        model: opts?.model,
+        description,
+        transcriptPath
+      });
       await this.director.assign({
         id: taskId2,
         description,
-        subagentId,
-        maxToolCalls: 20
+        subagentId
+        // No maxToolCalls — same reasoning as the spawn config above.
+        // The director / orchestrator owns the budget decision.
       });
       return { subagentId, taskId: taskId2 };
     }
@@ -4370,14 +4585,42 @@ var MultiAgentHost = class {
     const spawned = await coord.spawn(subagentConfig);
     const taskId = randomUUID();
     this.pending.set(taskId, { description, subagentId: spawned.subagentId });
+    this.deps.events.emit("subagent.spawned", {
+      subagentId: spawned.subagentId,
+      taskId,
+      name: subagentConfig.name,
+      provider: opts?.provider,
+      model: opts?.model,
+      description,
+      transcriptPath
+    });
     await coord.assign({
       id: taskId,
       description,
-      subagentId: spawned.subagentId,
-      maxToolCalls: 20
+      subagentId: spawned.subagentId
+      // No maxToolCalls — see comment on the director branch above.
     });
     return { subagentId: spawned.subagentId, taskId };
   }
+  /**
+   * Relay a `task.completed` notification (from either the Director or
+   * the raw coordinator) to the EventBus so non-director TUIs and any
+   * other observer can react. We forward the full result shape rather
+   * than mutating the existing `task.completed` schema — coordination
+   * code already binds to that event, and adding subscribers there
+   * would change ordering semantics for those listeners.
+   */
+  emitLifecycleCompleted(taskId, result) {
+    this.deps.events.emit("subagent.task_completed", {
+      subagentId: result.subagentId,
+      taskId,
+      status: result.status,
+      iterations: result.iterations,
+      toolCalls: result.toolCalls,
+      durationMs: result.durationMs,
+      error: result.error
+    });
+  }
   status() {
     const pending = Array.from(this.pending.entries()).map(([taskId, v]) => ({
       taskId,
@@ -4459,6 +4702,10 @@ var MultiAgentHost = class {
   async promoteToDirector() {
     if (this.director) return this.director;
     if (this.coordinator) {
+      const status = this.coordinator.getStatus();
+      const running = status.subagents.filter((s) => s.status === "running").length;
+      const idle = status.subagents.filter((s) => s.status === "idle").length;
+      this.promotionBlockReason = `Cannot promote to director: a non-director coordinator is already in use (${running} running, ${idle} idle, ${status.pendingTasks} pending tasks). Stop the existing subagents with /fleet kill <id> or wait for them to finish, then retry \u2014 or restart wstack with --director to start in director mode.`;
       return null;
     }
     this.opts.directorMode = true;
@@ -4471,6 +4718,9 @@ var MultiAgentHost = class {
     if (this.opts.fleetRoot && !this.opts.sessionsRoot) {
       this.opts.sessionsRoot = path13.join(this.opts.fleetRoot, "subagents");
     }
+    if (this.opts.fleetRoot && !this.opts.stateCheckpointPath) {
+      this.opts.stateCheckpointPath = path13.join(this.opts.fleetRoot, "director-state.json");
+    }
     await this.ensureDirector();
     return this.director ?? null;
   }
@@ -4482,6 +4732,16 @@ var MultiAgentHost = class {
   isDirectorMode() {
     return !!this.director;
   }
+  /**
+   * Why the most recent `promoteToDirector` call returned null. Cleared
+   * implicitly on the next successful promotion. The delegate tool reads
+   * this so the LLM sees the actual blocker (e.g. "3 running subagents,
+   * wait or /fleet kill") instead of a generic "Director could not be
+   * activated" message that gives no path forward.
+   */
+  getPromotionBlockReason() {
+    return this.promotionBlockReason;
+  }
   /**
    * Terminate a single subagent. Returns true when the subagent existed
    * (regardless of whether stop() succeeded or it was already idle),
@@ -4844,6 +5104,7 @@ async function main(argv) {
     supportsVision: resolvedModel.capabilities.vision,
     supportsReasoning: resolvedModel.capabilities.reasoning
   } : void 0;
+  const sessionRef = {};
   container.bind(
     TOKENS.SystemPromptBuilder,
     () => new DefaultSystemPromptBuilder({
@@ -4852,7 +5113,10 @@ async function main(argv) {
       modeStore,
       modeId,
       modePrompt,
-      modelCapabilities
+      modelCapabilities,
+      // Reads the ref each time — returns undefined until the session
+      // is created, then resolves to the per-session plan JSON path.
+      planPath: () => sessionRef.current ? path13.join(wpaths.projectSessions, `${sessionRef.current.id}.plan.json`) : void 0
     })
   );
   container.bind(TOKENS.Renderer, () => renderer);
@@ -4891,7 +5155,7 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     }
   }
   const toolRegistry = new ToolRegistry();
-  for (const t of builtinTools) toolRegistry.register(t);
+  toolRegistry.registerAllOrThrow([...builtinToolsPack.tools ?? []], builtinToolsPack.name);
   toolRegistry.registerDefault(
     createContextManagerTool({ compactor: container.resolve(TOKENS.Compactor) })
   );
@@ -5091,6 +5355,7 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       provider: config.provider
     });
   }
+  sessionRef.current = session;
   await recoveryLock.write(session.id).catch(() => void 0);
   const attachments = new DefaultAttachmentStore({
     spoolDir: path13.join(wpaths.projectSessions, session.id, "attachments")
@@ -5122,6 +5387,54 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
   if (restoredMessages.length > 0) {
     context.state.replaceMessages(restoredMessages);
   }
+  const todosCheckpointPath = path13.join(wpaths.projectSessions, `${session.id}.todos.json`);
+  if (resumeId) {
+    try {
+      const restoredTodos = await loadTodosCheckpoint(todosCheckpointPath);
+      if (restoredTodos && restoredTodos.length > 0) {
+        context.state.replaceTodos(restoredTodos);
+        renderer.writeInfo(
+          `Restored ${restoredTodos.length} todo${restoredTodos.length === 1 ? "" : "s"} from previous run.`
+        );
+      }
+    } catch {
+    }
+  }
+  attachTodosCheckpoint(
+    context.state,
+    todosCheckpointPath,
+    session.id
+  );
+  const planPath = path13.join(wpaths.projectSessions, `${session.id}.plan.json`);
+  context.state.setMeta("plan.path", planPath);
+  if (resumeId) {
+    try {
+      const fleetRoot2 = path13.join(wpaths.projectSessions, session.id);
+      const dirState = await loadDirectorState(path13.join(fleetRoot2, "director-state.json"));
+      if (dirState) {
+        const tCounts = {};
+        for (const t of dirState.tasks) {
+          tCounts[t.status] = (tCounts[t.status] ?? 0) + 1;
+        }
+        const summary = Object.entries(tCounts).map(([k, v]) => `${v} ${k}`).join(", ");
+        renderer.writeInfo(
+          `Prior fleet state: ${dirState.subagents.length} subagent${dirState.subagents.length === 1 ? "" : "s"}, tasks ${summary || "(none)"}.`
+        );
+      }
+    } catch {
+    }
+    try {
+      const plan = await loadPlan(planPath);
+      if (plan && plan.items.length > 0) {
+        const open = plan.items.filter((p) => p.status !== "done").length;
+        const done = plan.items.length - open;
+        renderer.writeInfo(
+          `Plan: ${plan.items.length} item${plan.items.length === 1 ? "" : "s"} (${open} open, ${done} done). Use /plan to review.`
+        );
+      }
+    } catch {
+    }
+  }
   const pipelines = createDefaultPipelines();
   const installBoundary = (p) => {
     p.setErrorHandler((ev) => {
@@ -5244,7 +5557,14 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
           slashCommandRegistry: slashRegistry,
           mcpRegistry,
           config,
-          log: logger
+          log: logger,
+          extensions: agent.extensions,
+          sessionWriter: {
+            transcriptPath: context.session.transcriptPath,
+            append: (e) => context.session.append(e)
+          },
+          metricsSink,
+          configStore
         })
       });
     }
@@ -5268,10 +5588,12 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     }
   };
   const directorMode = flags["director"] === true;
+  let director = null;
   const fleetRoot = directorMode ? path13.join(wpaths.projectSessions, session.id) : void 0;
   const manifestPath = directorMode ? typeof process.env["WRONGSTACK_FLEET_MANIFEST"] === "string" ? process.env["WRONGSTACK_FLEET_MANIFEST"] : path13.join(fleetRoot, "fleet.json") : void 0;
   const sharedScratchpadPath = directorMode ? path13.join(fleetRoot, "shared") : void 0;
   const subagentSessionsRoot = directorMode ? path13.join(fleetRoot, "subagents") : void 0;
+  const stateCheckpointPath = directorMode ? path13.join(fleetRoot, "director-state.json") : void 0;
   const fleetRootForPromotion = path13.join(wpaths.projectSessions, session.id);
   const multiAgentHost = new MultiAgentHost(
     {
@@ -5292,11 +5614,25 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       sharedScratchpadPath,
       sessionsRoot: subagentSessionsRoot,
       directorRunId: session.id,
-      fleetRoot: fleetRootForPromotion
+      fleetRoot: fleetRootForPromotion,
+      stateCheckpointPath,
+      sessionWriter: session
     }
   );
+  toolRegistry.register(
+    createDelegateTool({
+      host: multiAgentHost,
+      roster: FLEET_ROSTER,
+      // Wire the per-subagent transcript location so the tool can
+      // extract partial output on timeout / budget exhaustion. Without
+      // this, a subagent that hit its iteration cap returns an empty
+      // result and the host LLM has no idea what work was done.
+      sessionsRoot: subagentSessionsRoot,
+      directorRunId: session.id
+    })
+  );
   if (directorMode) {
-    const director = await multiAgentHost.ensureDirector();
+    director = await multiAgentHost.ensureDirector();
     if (director) {
       for (const tool of director.tools(FLEET_ROSTER)) {
         toolRegistry.register(tool);
@@ -5310,6 +5646,12 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       renderer.writeInfo(`Director mode enabled. Fleet manifest \u2192 ${manifestPath}`);
     }
   }
+  const fleetStreamController = {
+    enabled: true,
+    setEnabled(enabled) {
+      this.enabled = enabled;
+    }
+  };
   const slashCmds = buildBuiltinSlashCommands({
     registry: slashRegistry,
     toolRegistry,
@@ -5322,6 +5664,8 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     context,
     metricsSink,
     healthRegistry,
+    planPath,
+    fleetStreamController,
     onSpawn: async (description, spawnOpts) => {
       const { subagentId, taskId } = await multiAgentHost.spawn(description, spawnOpts);
       const tags = [];
@@ -5338,9 +5682,8 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
         lines.push(`  pending  ${p.taskId.slice(0, 8)} \u2192 ${p.description.slice(0, 60)}`);
       }
       for (const r of s.completed) {
-        lines.push(
-          `  ${r.status === "success" ? color.green("\u2713") : color.red("\u2717")}        ${r.taskId.slice(0, 8)} ${r.iterations}it ${r.toolCalls}tc ${r.durationMs}ms`
-        );
+        const fmt = fmtTaskResultLine(r, color);
+        lines.push(`  ${fmt.mark}  ${r.taskId.slice(0, 8)} ${fmt.stats}${fmt.tail}`);
       }
       return lines.join("\n");
     },
@@ -5359,9 +5702,9 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
         if (s.completed.length > 0) {
           lines.push("", color.dim("  Completed"));
           for (const r of s.completed) {
-            const mark = r.status === "success" ? color.green("\u2713") : color.red("\u2717");
+            const fmt = fmtTaskResultLine(r, color);
             lines.push(
-              `    ${mark} ${r.taskId.slice(0, 8)} \u2192 ${r.subagentId.slice(0, 8)} \xB7 ${r.iterations}it ${r.toolCalls}tc ${r.durationMs}ms`
+              `    ${fmt.mark} ${r.taskId.slice(0, 8)} \u2192 ${r.subagentId.slice(0, 8)} \xB7 ${fmt.stats}${fmt.tail}`
             );
           }
         }
@@ -5402,10 +5745,191 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       }
       return `Unknown fleet action: ${action}`;
     },
+    onFleetLog: async (subagentId, mode) => {
+      const subagentsRoot = path13.join(fleetRootForPromotion, "subagents");
+      let runDirs;
+      try {
+        runDirs = await fs3.readdir(subagentsRoot);
+      } catch {
+        return "No fleet transcripts on disk \u2014 no subagents have been spawned for this session.";
+      }
+      const found = [];
+      for (const runId of runDirs) {
+        const runDir = path13.join(subagentsRoot, runId);
+        let files;
+        try {
+          files = await fs3.readdir(runDir);
+        } catch {
+          continue;
+        }
+        for (const f of files) {
+          if (!f.endsWith(".jsonl")) continue;
+          const full = path13.join(runDir, f);
+          try {
+            const stat2 = await fs3.stat(full);
+            found.push({
+              runId,
+              subagentId: f.replace(/\.jsonl$/, ""),
+              file: full,
+              size: stat2.size
+            });
+          } catch {
+          }
+        }
+      }
+      if (found.length === 0) {
+        return "No subagent transcripts found on disk.";
+      }
+      if (!subagentId) {
+        const lines2 = [
+          `${found.length} subagent transcript${found.length === 1 ? "" : "s"} on disk:`
+        ];
+        for (const t2 of found) {
+          lines2.push(
+            `  ${color.cyan(t2.subagentId.padEnd(18))}  ${color.dim(t2.runId.slice(0, 18))}  ${color.dim(`${(t2.size / 1024).toFixed(1)} KB`)}`
+          );
+        }
+        lines2.push("Use `/fleet log <subagentId>` for a summary, or append `raw` for the full JSONL.");
+        return lines2.join("\n");
+      }
+      const matches = found.filter(
+        (t2) => t2.subagentId === subagentId || t2.subagentId.startsWith(subagentId)
+      );
+      if (matches.length === 0) {
+        return `No transcript matched "${subagentId}". Run \`/fleet log\` to list available ids.`;
+      }
+      if (matches.length > 1) {
+        return [
+          `Ambiguous id "${subagentId}" \u2014 ${matches.length} matches:`,
+          ...matches.map((m) => `  ${m.subagentId}  (${m.runId})`)
+        ].join("\n");
+      }
+      const t = matches[0];
+      const raw = await fs3.readFile(t.file, "utf8");
+      if (mode === "raw") return raw;
+      const lines = raw.split("\n").filter((l) => l.trim());
+      const counts = {};
+      let firstUser = null;
+      let lastResponse = null;
+      let totalIterations = 0;
+      const toolNames = /* @__PURE__ */ new Map();
+      for (const line of lines) {
+        try {
+          const ev = JSON.parse(line);
+          counts[ev.type] = (counts[ev.type] ?? 0) + 1;
+          if (ev.type === "user_input" && !firstUser) {
+            const txt = typeof ev.content === "string" ? ev.content : Array.isArray(ev.content) ? ev.content.filter((b) => b.type === "text").map((b) => b.text).join(" ") : "";
+            firstUser = txt.slice(0, 120);
+          }
+          if (ev.type === "llm_response") {
+            if (Array.isArray(ev.content)) {
+              const txt = ev.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join(" ");
+              if (txt) lastResponse = txt.slice(0, 240);
+            }
+            totalIterations += 1;
+          }
+          if (ev.type === "tool_use" && typeof ev.name === "string") {
+            toolNames.set(ev.name, (toolNames.get(ev.name) ?? 0) + 1);
+          }
+        } catch {
+        }
+      }
+      const toolBreakdown = toolNames.size > 0 ? Array.from(toolNames.entries()).sort((a, b) => b[1] - a[1]).map(([n, c]) => `${n}\xD7${c}`).join(", ") : "(none)";
+      const out = [
+        color.bold(`Subagent ${t.subagentId}`) + color.dim(`  (run ${t.runId})`),
+        `  ${lines.length} events  \xB7  ${totalIterations} llm iterations  \xB7  ${(t.size / 1024).toFixed(1)} KB`,
+        `  tools: ${toolBreakdown}`
+      ];
+      if (firstUser) out.push("", color.dim("  task:"), `  ${firstUser}`);
+      if (lastResponse) out.push("", color.dim("  last response:"), `  ${lastResponse}`);
+      out.push("", color.dim("  event mix:"));
+      for (const [type, count] of Object.entries(counts).sort((a, b) => b[1] - a[1])) {
+        out.push(`    ${type.padEnd(20)} ${count}`);
+      }
+      out.push("", color.dim("Use `/fleet log <id> raw` for the full JSONL."));
+      return out.join("\n");
+    },
+    onFleetRetry: async (taskId) => {
+      if (!multiAgentHost.isDirectorMode()) {
+        const promoted = await multiAgentHost.promoteToDirector();
+        if (!promoted) {
+          return "Cannot retry: a coordinator already exists in non-director mode.";
+        }
+        for (const tool of promoted.tools(FLEET_ROSTER)) {
+          toolRegistry.register(tool);
+        }
+      }
+      const dir = await multiAgentHost.ensureDirector();
+      if (!dir) return "Director is not available.";
+      const dirStatePath = path13.join(fleetRootForPromotion, "director-state.json");
+      const prior = await loadDirectorState(dirStatePath);
+      if (!prior) {
+        return "No prior director-state.json found \u2014 nothing to retry.";
+      }
+      const interrupted = prior.tasks.filter(
+        (t) => t.status === "running" || t.status === "pending"
+      );
+      if (interrupted.length === 0) {
+        return "No interrupted tasks: every prior task reached a terminal state.";
+      }
+      if (!taskId) {
+        const lines = [
+          `${interrupted.length} interrupted task${interrupted.length === 1 ? "" : "s"} from prior run:`
+        ];
+        for (const t of interrupted) {
+          const owner = t.subagentId ? prior.subagents.find((s) => s.id === t.subagentId) : void 0;
+          const tag = owner ? `${owner.name ?? owner.id} (${owner.role ?? "no-role"})` : "no-owner";
+          lines.push(
+            `  ${t.taskId.slice(0, 12)}  ${t.status.padEnd(8)} ${tag}  ${(t.description ?? "").slice(0, 60)}`
+          );
+        }
+        lines.push("Run `/fleet retry <taskId>` or `/fleet retry all` to re-assign.");
+        return lines.join("\n");
+      }
+      const targets = taskId === "all" ? interrupted : interrupted.filter(
+        (t) => t.taskId === taskId || t.taskId.startsWith(taskId)
+      );
+      if (targets.length === 0) {
+        return `No interrupted task matched "${taskId}".`;
+      }
+      const results = [];
+      for (const t of targets) {
+        const owner = t.subagentId ? prior.subagents.find((s) => s.id === t.subagentId) : void 0;
+        if (!owner) {
+          results.push(`  - ${t.taskId.slice(0, 12)}: no owner record, skipped.`);
+          continue;
+        }
+        const rosterCfg = owner.role ? FLEET_ROSTER[owner.role] : void 0;
+        const cfg = rosterCfg ? { ...rosterCfg } : {
+          name: owner.name ?? owner.id,
+          role: owner.role,
+          provider: owner.provider,
+          model: owner.model
+        };
+        try {
+          const newSubId = await dir.spawn(cfg);
+          const newTaskId = await dir.assign({
+            id: "",
+            description: t.description ?? "(no description)",
+            subagentId: newSubId
+          });
+          results.push(
+            `  ${color.green("\u2713")} ${t.taskId.slice(0, 12)} \u2192 re-spawned ${newSubId.slice(0, 12)} (task ${newTaskId.slice(0, 12)})`
+          );
+        } catch (err) {
+          results.push(
+            `  ${color.red("\u2717")} ${t.taskId.slice(0, 12)} \u2192 ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      return [`Retried ${targets.length} task${targets.length === 1 ? "" : "s"}:`, ...results].join(
+        "\n"
+      );
+    },
     onDirector: async () => {
-      const director = await multiAgentHost.promoteToDirector();
-      if (!director) return null;
-      for (const tool of director.tools(FLEET_ROSTER)) {
+      const director2 = await multiAgentHost.promoteToDirector();
+      if (!director2) return null;
+      for (const tool of director2.tools(FLEET_ROSTER)) {
         toolRegistry.register(tool);
       }
       const mp = path13.join(fleetRootForPromotion, "fleet.json");
@@ -5477,7 +6001,10 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     savedProviderCfg,
     resolvedProvider: resolvedProvider ?? void 0,
     getPickableProviders: () => buildPickableProviders(modelsRegistry, config),
-    switchProviderAndModel
+    switchProviderAndModel,
+    director: director ?? null,
+    fleetRoster: FLEET_ROSTER,
+    fleetStreamController
   });
 }
 async function promptRecovery(reader, renderer, abandoned, autoRecover) {