squad-kit 0.10.0 → 0.11.0

package/dist/cli.js

@@ -100,6 +100,8 @@ function spinner(text) {
     return {
       update: (t) => process.stderr.write(`  \u25C6 ${t}
 `),
+      setPrefix: () => {
+      },
       succeed: (t) => process.stderr.write(`  \u2713 ${t ?? text}
 `),
       fail: (t) => process.stderr.write(`  \u2717 ${t ?? text}
@@ -119,6 +121,9 @@ function spinner(text) {
     update: (t) => {
       instance.text = t;
     },
+    setPrefix: (t) => {
+      instance.prefixText = t === "" ? " " : t;
+    },
     succeed: (t) => instance.succeed(t),
     fail: (t) => instance.fail(t),
     stop: () => instance.stop()
@@ -169,6 +174,77 @@ function renderError(err2) {
 `);
 }
 
+// src/ui/stage-pipeline.ts
+import kleur2 from "kleur";
+var segSep = () => ` ${dim("\u2500\u2500\u25B6")} `;
+function fmtStage(name, state) {
+  switch (state) {
+    case "pending":
+      return `${dim(`\u25CB${name}`)}`;
+    case "running":
+      return `${kleur2.cyan(`\u25CF${name}`)}${kleur2.cyan(" \u25B0\u25B0\u25B1")}`;
+    case "success":
+      return `${kleur2.green(`\u25CF${name} \u2713`)}`;
+    case "failed":
+      return `${kleur2.red(`\u25CF${name} \u2717`)}`;
+    case "skipped":
+      return `${dim(`\u25CB${name} (skipped)`)}`;
+    default:
+      return dim(`\u25CB${name}`);
+  }
+}
+function formatStagePipeline(line2) {
+  const sep = segSep();
+  return [fmtStage("scout", line2.scout), fmtStage("draft", line2.draft), fmtStage("validation", line2.validation)].join(
+    sep
+  );
+}
+function printStagePipeline(line2) {
+  process.stderr.write(`  ${dim("\u2192")} ${formatStagePipeline(line2)}
+`);
+}
+
+// src/ui/budget-meter.ts
+import kleur3 from "kleur";
+function segmentStyle(ratio) {
+  if (ratio >= 0.9) return kleur3.red;
+  if (ratio >= 0.7) return kleur3.yellow;
+  return (s) => s;
+}
+function fmtRatio(n, cap) {
+  const safeCap = cap > 0 ? cap : 1;
+  const ratio = Math.min(1, n / safeCap);
+  const text = `${n}/${cap}`;
+  return { text, ratio };
+}
+function fmtTimeSeg(elapsedMs, capMs) {
+  const elapsedSec = Math.max(0, Math.round(elapsedMs / 1e3));
+  const capSec = capMs > 0 ? Math.round(capMs / 1e3) : 0;
+  const safeCap = capSec > 0 ? capSec : 1;
+  const ratio = capSec > 0 ? Math.min(1, elapsedSec / safeCap) : 0;
+  return { text: `${elapsedSec}/${capSec}s`, ratio };
+}
+function formatBudgetMeter(b) {
+  const ctxKb = Math.round(b.bytes / 1024);
+  const ctxCapKb = Math.round(b.bytesCap / 1024);
+  const reads = fmtRatio(b.reads, b.readsCap);
+  const ctx = fmtRatio(ctxKb, ctxCapKb);
+  const time = fmtTimeSeg(b.elapsedMs, b.durationMsCap);
+  const readsS = segmentStyle(reads.ratio)(`reads ${reads.text}`);
+  const ctxS = segmentStyle(ctx.ratio)(`ctx ${ctx.text} KB`);
+  const timeS = segmentStyle(time.ratio)(`time ${time.text}`);
+  return `${readsS} \xB7 ${ctxS} \xB7 ${timeS}`;
+}
+
+// src/ui/thinking-line.ts
+import kleur4 from "kleur";
+function formatThinkingLine(opts) {
+  const sec = Math.max(0, Math.round(opts.durationMs / 1e3));
+  const head = opts.running ? "thinking\u2026" : "thought";
+  const body = `${sec}s \xB7 ${opts.chars} chars`;
+  return kleur4.magenta(`${head} ${body}`);
+}
+
 // src/core/cli-exit.ts
 var SquadExit = class extends Error {
   constructor(exitCode, message) {
@@ -303,15 +379,15 @@ function clampPlannerMaxOut(raw) {
     Math.max(MIN_PLANNER_MAX_OUTPUT_TOKENS, Math.round(n))
   );
 }
-function rejectSecretsInYaml(node, configFile, path38 = []) {
+function rejectSecretsInYaml(node, configFile, path39 = []) {
   if (node === null || typeof node !== "object") return;
   for (const [key, value] of Object.entries(node)) {
     if (FORBIDDEN_KEYS.includes(key.toLowerCase())) {
       throw new Error(
-        `Refusing to load ${configFile}: key "${[...path38, key].join(".")}" looks like a secret. Run \`squad config set planner\` or \`squad config set tracker\` to save it to .squad/secrets.yaml, then remove the key from config.yaml. Provider keys also work via ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY.`
+        `Refusing to load ${configFile}: key "${[...path39, key].join(".")}" looks like a secret. Run \`squad config set planner\` or \`squad config set tracker\` to save it to .squad/secrets.yaml, then remove the key from config.yaml. Provider keys also work via ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY.`
       );
     }
-    if (typeof value === "object") rejectSecretsInYaml(value, configFile, [...path38, key]);
+    if (typeof value === "object") rejectSecretsInYaml(value, configFile, [...path39, key]);
   }
 }
 function mergePlanner(base, override) {
@@ -837,40 +913,60 @@ function overlayTrackerEnv(base) {
 
 // src/core/probes.ts
 async function fetchProviderModelIds(provider, apiKey) {
-  switch (provider) {
-    case "anthropic": {
-      const res = await fetch("https://api.anthropic.com/v1/models?limit=200", {
-        headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
-      });
-      if (!res.ok) {
-        return { ok: false, kind: "http", status: res.status, body: await res.text() };
+  const netErr = (err2) => {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    return { ok: false, kind: "http", status: 0, body: msg.slice(0, 500) };
+  };
+  try {
+    switch (provider) {
+      case "anthropic": {
+        const res = await fetch("https://api.anthropic.com/v1/models?limit=200", {
+          headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
+        });
+        if (!res.ok) {
+          return { ok: false, kind: "http", status: res.status, body: (await res.text()).slice(0, 2e3) };
+        }
+        try {
+          const body = await res.json();
+          return { ok: true, ids: new Set((body.data ?? []).map((m) => m.id)) };
+        } catch (err2) {
+          return netErr(err2);
+        }
       }
-      const body = await res.json();
-      return { ok: true, ids: new Set((body.data ?? []).map((m) => m.id)) };
-    }
-    case "openai": {
-      const res = await fetch("https://api.openai.com/v1/models", {
-        headers: { authorization: `Bearer ${apiKey}` }
-      });
-      if (!res.ok) {
-        return { ok: false, kind: "http", status: res.status, body: await res.text() };
+      case "openai": {
+        const res = await fetch("https://api.openai.com/v1/models", {
+          headers: { authorization: `Bearer ${apiKey}` }
+        });
+        if (!res.ok) {
+          return { ok: false, kind: "http", status: res.status, body: (await res.text()).slice(0, 2e3) };
+        }
+        try {
+          const body = await res.json();
+          return { ok: true, ids: new Set((body.data ?? []).map((m) => m.id)) };
+        } catch (err2) {
+          return netErr(err2);
+        }
       }
-      const body = await res.json();
-      return { ok: true, ids: new Set((body.data ?? []).map((m) => m.id)) };
-    }
-    case "google": {
-      const res = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models?pageSize=200&key=${encodeURIComponent(apiKey)}`
-      );
-      if (!res.ok) {
-        return { ok: false, kind: "http", status: res.status, body: await res.text() };
+      case "google": {
+        const res = await fetch(
+          `https://generativelanguage.googleapis.com/v1beta/models?pageSize=200&key=${encodeURIComponent(apiKey)}`
+        );
+        if (!res.ok) {
+          return { ok: false, kind: "http", status: res.status, body: (await res.text()).slice(0, 2e3) };
+        }
+        try {
+          const body = await res.json();
+          return {
+            ok: true,
+            ids: new Set((body.models ?? []).map((m) => m.name.replace(/^models\//, "")))
+          };
+        } catch (err2) {
+          return netErr(err2);
+        }
       }
-      const body = await res.json();
-      return {
-        ok: true,
-        ids: new Set((body.models ?? []).map((m) => m.name.replace(/^models\//, "")))
-      };
     }
+  } catch (err2) {
+    return netErr(err2);
   }
 }
 function jiraMyselfUrl(host) {
@@ -3236,8 +3332,8 @@ function truncate(s, n) {
 }
 
 // src/commands/new-plan.ts
-import fs31 from "fs";
-import path23 from "path";
+import fs32 from "fs";
+import path24 from "path";
 import { confirm as confirm6, select as select6 } from "@inquirer/prompts";
 
 // src/utils/clipboard.ts
@@ -3329,8 +3425,8 @@ function noCandidateReason() {
 }
 
 // src/planner/loop.ts
-import path19 from "path";
-import fs27 from "fs";
+import path20 from "path";
+import fs28 from "fs";
 import { APICallError as APICallError3 } from "ai";
 
 // src/planner/tools/index.ts
@@ -3849,40 +3945,80 @@ function buildPlannerToolDefinitions(opts) {
     parameters: readParams,
     execute: async (args) => {
       const turn = opts.getTurn();
+      const toolCallId = randomUUID();
+      const startedAtMs = Date.now();
       const tc = {
-        id: randomUUID(),
+        id: toolCallId,
         name: "read_file",
         input: { path: args.path, offset: args.offset, limit: args.limit }
       };
-      const before = opts.budget.snapshot().bytes;
-      let result = readFileTool(opts.root, opts.budget, args);
-      let after = opts.budget.snapshot().bytes;
-      let bytesLoaded = after - before;
-      opts.onToolCall?.(tc, bytesLoaded, after);
       opts.bus.emit({
-        kind: "tool_call",
+        kind: "tool_call_started",
         runId: opts.runId,
         turn,
-        toolCall: tc,
-        bytesLoaded,
-        totalBytes: after
+        toolCallId,
+        name: "read_file",
+        input: tc.input
       });
-      if (readBudgetishError(result)) {
-        const decide = opts.decideOnLimit;
-        if (decide) {
-          const d = await decide(opts.getLimitCtx());
-          if (d === "cancel") {
-            throw new PlannerUserCancelledError(opts.getAccumulatedText(), opts.runId, turn, "budget_reads", tc, result);
+      try {
+        const before = opts.budget.snapshot().bytes;
+        let result = readFileTool(opts.root, opts.budget, args);
+        let after = opts.budget.snapshot().bytes;
+        let bytesLoaded = after - before;
+        if (readBudgetishError(result)) {
+          const decide = opts.decideOnLimit;
+          if (decide) {
+            const d = await decide(opts.getLimitCtx());
+            if (d === "cancel") {
+              throw new PlannerUserCancelledError(opts.getAccumulatedText(), opts.runId, turn, "budget_reads", tc, result);
+            }
+            opts.extendSessionLimits();
+            result = readFileTool(opts.root, opts.budget, args);
+            after = opts.budget.snapshot().bytes;
+            bytesLoaded = after - before;
+          } else {
+            opts.setBudgetExhausted(true);
           }
-          opts.extendSessionLimits();
-          result = readFileTool(opts.root, opts.budget, args);
-          after = opts.budget.snapshot().bytes;
-          bytesLoaded = after - before;
-        } else {
-          opts.setBudgetExhausted(true);
         }
+        opts.onToolCall?.(tc, bytesLoaded, after);
+        opts.bus.emit({
+          kind: "tool_call",
+          runId: opts.runId,
+          turn,
+          toolCall: tc,
+          bytesLoaded,
+          totalBytes: after
+        });
+        const durationMs = Date.now() - startedAtMs;
+        opts.bus.emit({
+          kind: "tool_call_completed",
+          runId: opts.runId,
+          turn,
+          toolCallId,
+          name: "read_file",
+          durationMs,
+          bytesLoaded,
+          totalBytes: after,
+          isError: !!result.isError,
+          errorSnippet: result.isError ? String(result.content).slice(0, 200) : void 0
+        });
+        return { content: result.content, isError: result.isError };
+      } catch (err2) {
+        const durationMs = Date.now() - startedAtMs;
+        opts.bus.emit({
+          kind: "tool_call_completed",
+          runId: opts.runId,
+          turn,
+          toolCallId,
+          name: "read_file",
+          durationMs,
+          bytesLoaded: 0,
+          totalBytes: opts.budget.snapshot().bytes,
+          isError: true,
+          errorSnippet: err2 instanceof Error ? err2.message.slice(0, 200) : String(err2).slice(0, 200)
+        });
+        throw err2;
       }
-      return { content: result.content, isError: result.isError };
     }
   });
   if (enabled.grep) {
@@ -3892,30 +4028,70 @@ function buildPlannerToolDefinitions(opts) {
       parameters: grepSchema,
       execute: async (args) => {
         const turn = opts.getTurn();
+        const toolCallId = randomUUID();
+        const startedAtMs = Date.now();
         const tc = {
-          id: randomUUID(),
+          id: toolCallId,
           name: GREP_TOOL_NAME,
           input: { ...args }
         };
-        const before = opts.budget.snapshot().bytes;
-        const out = runGrep(opts.root, opts.budget, {
-          pattern: args.pattern,
-          regex: args.regex ?? false,
-          path: args.path,
-          caseInsensitive: args.caseInsensitive ?? false
-        });
-        const after = opts.budget.snapshot().bytes;
-        const bytesLoaded = after - before;
-        opts.onToolCall?.(tc, bytesLoaded, after);
         opts.bus.emit({
-          kind: "tool_call",
+          kind: "tool_call_started",
           runId: opts.runId,
           turn,
-          toolCall: tc,
-          bytesLoaded,
-          totalBytes: after
+          toolCallId,
+          name: GREP_TOOL_NAME,
+          input: tc.input
         });
-        return { content: out.content, isError: out.isError };
+        try {
+          const before = opts.budget.snapshot().bytes;
+          const out = runGrep(opts.root, opts.budget, {
+            pattern: args.pattern,
+            regex: args.regex ?? false,
+            path: args.path,
+            caseInsensitive: args.caseInsensitive ?? false
+          });
+          const after = opts.budget.snapshot().bytes;
+          const bytesLoaded = after - before;
+          opts.onToolCall?.(tc, bytesLoaded, after);
+          opts.bus.emit({
+            kind: "tool_call",
+            runId: opts.runId,
+            turn,
+            toolCall: tc,
+            bytesLoaded,
+            totalBytes: after
+          });
+          const durationMs = Date.now() - startedAtMs;
+          opts.bus.emit({
+            kind: "tool_call_completed",
+            runId: opts.runId,
+            turn,
+            toolCallId,
+            name: GREP_TOOL_NAME,
+            durationMs,
+            bytesLoaded,
+            totalBytes: after,
+            isError: !!out.isError,
+            errorSnippet: out.isError ? String(out.content).slice(0, 200) : void 0
+          });
+          return { content: out.content, isError: out.isError };
+        } catch (err2) {
+          const durationMs = Date.now() - startedAtMs;
+          opts.bus.emit({
+            kind: "tool_call_completed",
+            runId: opts.runId,
+            turn,
+            toolCallId,
+            name: GREP_TOOL_NAME,
+            durationMs,
+            bytesLoaded: 0,
+            totalBytes: opts.budget.snapshot().bytes,
+            isError: true,
+            errorSnippet: err2 instanceof Error ? err2.message.slice(0, 200) : String(err2).slice(0, 200)
+          });
+          throw err2;
+        }
       }
     });
   }
@@ -3926,24 +4102,65 @@ function buildPlannerToolDefinitions(opts) {
       parameters: listDirSchema,
       execute: async (args) => {
         const turn = opts.getTurn();
+        const toolCallId = randomUUID();
+        const startedAtMs = Date.now();
         const tc = {
-          id: randomUUID(),
+          id: toolCallId,
           name: LIST_DIR_TOOL_NAME,
           input: { path: args.path }
         };
-        const before = opts.budget.snapshot().bytes;
-        const out = runListDir(opts.root, opts.budget, args.path);
-        const after = opts.budget.snapshot().bytes;
-        opts.onToolCall?.(tc, after - before, after);
         opts.bus.emit({
-          kind: "tool_call",
+          kind: "tool_call_started",
           runId: opts.runId,
           turn,
-          toolCall: tc,
-          bytesLoaded: after - before,
-          totalBytes: after
+          toolCallId,
+          name: LIST_DIR_TOOL_NAME,
+          input: tc.input
         });
-        return { content: out.content, isError: out.isError };
+        try {
+          const before = opts.budget.snapshot().bytes;
+          const out = runListDir(opts.root, opts.budget, args.path);
+          const after = opts.budget.snapshot().bytes;
+          const bytesLoaded = after - before;
+          opts.onToolCall?.(tc, bytesLoaded, after);
+          opts.bus.emit({
+            kind: "tool_call",
+            runId: opts.runId,
+            turn,
+            toolCall: tc,
+            bytesLoaded,
+            totalBytes: after
+          });
+          const durationMs = Date.now() - startedAtMs;
+          opts.bus.emit({
+            kind: "tool_call_completed",
+            runId: opts.runId,
+            turn,
+            toolCallId,
+            name: LIST_DIR_TOOL_NAME,
+            durationMs,
+            bytesLoaded,
+            totalBytes: after,
+            isError: !!out.isError,
+            errorSnippet: out.isError ? String(out.content).slice(0, 200) : void 0
+          });
+          return { content: out.content, isError: out.isError };
+        } catch (err2) {
+          const durationMs = Date.now() - startedAtMs;
+          opts.bus.emit({
+            kind: "tool_call_completed",
+            runId: opts.runId,
+            turn,
+            toolCallId,
+            name: LIST_DIR_TOOL_NAME,
+            durationMs,
+            bytesLoaded: 0,
+            totalBytes: opts.budget.snapshot().bytes,
+            isError: true,
+            errorSnippet: err2 instanceof Error ? err2.message.slice(0, 200) : String(err2).slice(0, 200)
+          });
+          throw err2;
+        }
       }
     });
   }
@@ -4052,34 +4269,280 @@ function rateLimitMessage(err2) {
 }
 
 // src/core/runs.ts
-import fs25 from "fs/promises";
-import path17 from "path";
+import fs26 from "fs/promises";
+import path18 from "path";
 import { randomBytes } from "crypto";
-var RING_SIZE = 20;
+
+// src/core/run-retention.ts
+var RUN_HISTORY_RING_SIZE = 20;
+var RUN_EVENT_JSONL_UNCOMPRESSED_HEAD = 5;
+
+// src/core/run-events-store.ts
+import fs25, { createWriteStream } from "fs";
+import fsPromises from "fs/promises";
+import path17 from "path";
+import readline from "readline";
+import { pipeline } from "stream/promises";
+import zlib from "zlib";
+var SUFFIX_JSONL = ".events.jsonl";
+var SUFFIX_GZ = ".events.jsonl.gz";
+function redactPlannerEventForDisk(e) {
+  if (e.kind === "thinking_delta") return { ...e, delta: "" };
+  return e;
+}
+function runsDir(paths) {
+  return path17.join(paths.squadDir, "runs");
+}
+function logAppendErrorOnce(err2) {
+  console.error("[run-events-store] append failed:", err2);
+}
+var RunEventsStoreImpl = class {
+  stream;
+  bytes = 0;
+  closed = false;
+  loggedError = false;
+  file;
+  constructor(file) {
+    this.file = file;
+    this.stream = createWriteStream(file, { flags: "a" });
+    this.stream.on("error", (err2) => {
+      if (!this.loggedError) {
+        this.loggedError = true;
+        logAppendErrorOnce(err2);
+      }
+    });
+  }
+  bytesWritten() {
+    return this.bytes;
+  }
+  async append(e) {
+    if (!this.stream || this.closed) return;
+    const line2 = JSON.stringify(redactPlannerEventForDisk(e)) + "\n";
+    this.bytes += Buffer.byteLength(line2, "utf8");
+    await new Promise((resolve2) => {
+      const s = this.stream;
+      if (!s) {
+        resolve2();
+        return;
+      }
+      s.write(line2, (err2) => {
+        if (err2 && !this.loggedError) {
+          this.loggedError = true;
+          logAppendErrorOnce(err2);
+        }
+        resolve2();
+      });
+    });
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const s = this.stream;
+    this.stream = null;
+    if (!s) return;
+    await new Promise((resolve2) => {
+      s.end(() => resolve2());
+      s.on("error", () => resolve2());
+    });
+  }
+};
+function createRunEventsStore(paths, runId) {
+  const dir = runsDir(paths);
+  fs25.mkdirSync(dir, { recursive: true });
+  const file = path17.join(dir, `${runId}${SUFFIX_JSONL}`);
+  return new RunEventsStoreImpl(file);
+}
+var RunEventsReaderImpl = class {
+  filePath;
+  useGunzip;
+  _count = null;
+  constructor(filePath, useGunzip) {
+    this.filePath = filePath;
+    this.useGunzip = useGunzip;
+  }
+  async count() {
+    if (this._count !== null) return this._count;
+    let n = 0;
+    for await (const _ of this.iterate()) {
+      n++;
+    }
+    this._count = n;
+    return n;
+  }
+  async *iterate(opts) {
+    const fromIndex = Math.max(0, opts?.fromIndex ?? 0);
+    const limit = opts?.limit ?? Number.POSITIVE_INFINITY;
+    let logical = 0;
+    let yielded = 0;
+    const stream = fs25.createReadStream(this.filePath);
+    const input5 = this.useGunzip ? stream.pipe(zlib.createGunzip()) : stream;
+    const rl = readline.createInterface({ input: input5, crlfDelay: Infinity });
+    try {
+      for await (const line2 of rl) {
+        const trimmed = line2.trim();
+        if (!trimmed) continue;
+        let ev;
+        try {
+          ev = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        if (logical >= fromIndex && yielded < limit) {
+          yield ev;
+          yielded++;
+          if (yielded >= limit) break;
+        }
+        logical++;
+      }
+    } finally {
+      rl.close();
+      stream.destroy();
+    }
+  }
+};
+async function openRunEventsReader(paths, runId) {
+  const dir = runsDir(paths);
+  const jsonl = path17.join(dir, `${runId}${SUFFIX_JSONL}`);
+  const gz = path17.join(dir, `${runId}${SUFFIX_GZ}`);
+  let jsonlStat = null;
+  let gzStat = null;
+  try {
+    jsonlStat = await fsPromises.stat(jsonl).then((s) => ({ mtimeMs: s.mtimeMs }));
+  } catch {
+    jsonlStat = null;
+  }
+  try {
+    gzStat = await fsPromises.stat(gz).then((s) => ({ mtimeMs: s.mtimeMs }));
+  } catch {
+    gzStat = null;
+  }
+  if (gzStat && jsonlStat) return new RunEventsReaderImpl(gz, true);
+  if (gzStat) return new RunEventsReaderImpl(gz, true);
+  if (jsonlStat) return new RunEventsReaderImpl(jsonl, false);
+  return null;
+}
+var rotateChain = Promise.resolve();
+function collectEventLogs(dir, names) {
+  const byRun = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    let runId = null;
+    let kind = null;
+    if (name.endsWith(SUFFIX_GZ)) {
+      runId = name.slice(0, -SUFFIX_GZ.length);
+      kind = "gz";
+    } else if (name.endsWith(SUFFIX_JSONL)) {
+      runId = name.slice(0, -SUFFIX_JSONL.length);
+      kind = "jsonl";
+    }
+    if (!runId || !kind) continue;
+    const full = path17.join(dir, name);
+    let st;
+    try {
+      st = { mtimeMs: fs25.statSync(full).mtimeMs };
+    } catch {
+      continue;
+    }
+    const cur = byRun.get(runId) ?? { mtimeMs: 0, jsonlPath: null, gzPath: null };
+    cur.mtimeMs = Math.max(cur.mtimeMs, st.mtimeMs);
+    if (kind === "jsonl") cur.jsonlPath = full;
+    else cur.gzPath = full;
+    byRun.set(runId, cur);
+  }
+  const out = [];
+  for (const [runId, v] of byRun) {
+    out.push({ runId, mtimeMs: v.mtimeMs, jsonlPath: v.jsonlPath, gzPath: v.gzPath });
+  }
+  out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out;
+}
+async function fsyncFile(filePath) {
+  const fh = await fsPromises.open(filePath, "r");
+  try {
+    await fh.sync();
+  } finally {
+    await fh.close();
+  }
+}
+async function gzipAtomic(jsonlPath, gzPath) {
+  const gzTmp = `${gzPath}.tmp`;
+  await fsPromises.rm(gzTmp, { force: true });
+  await pipeline(fs25.createReadStream(jsonlPath), zlib.createGzip(), fs25.createWriteStream(gzTmp));
+  await fsyncFile(gzTmp);
+  await fsPromises.rename(gzTmp, gzPath);
+  await fsPromises.unlink(jsonlPath);
+}
+async function rotateRunEventsUnlocked(paths) {
+  const dir = runsDir(paths);
+  let names;
+  try {
+    names = await fsPromises.readdir(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (name.endsWith(`${SUFFIX_GZ}.tmp`)) {
+      await fsPromises.rm(path17.join(dir, name), { force: true });
+    }
+  }
+  names = await fsPromises.readdir(dir);
+  const ordered = collectEventLogs(dir, names);
+  for (let i = RUN_HISTORY_RING_SIZE; i < ordered.length; i++) {
+    const e = ordered[i];
+    const summary = path17.join(dir, `${e.runId}.json`);
+    await fsPromises.rm(summary, { force: true });
+    if (e.jsonlPath) await fsPromises.rm(e.jsonlPath, { force: true });
+    if (e.gzPath) await fsPromises.rm(e.gzPath, { force: true });
+  }
+  const keep = ordered.slice(0, RUN_HISTORY_RING_SIZE);
+  for (let i = RUN_EVENT_JSONL_UNCOMPRESSED_HEAD; i < keep.length; i++) {
+    const e = keep[i];
+    const jsonl = e.jsonlPath;
+    if (!jsonl) continue;
+    const gz = path17.join(dir, `${e.runId}${SUFFIX_GZ}`);
+    await gzipAtomic(jsonl, gz);
+  }
+}
+function rotateRunEvents(paths) {
+  rotateChain = rotateChain.then(() => rotateRunEventsUnlocked(paths)).catch(() => {
+  });
+  return rotateChain;
+}
+
+// src/core/runs.ts
 function newRunId() {
   const ts = Date.now().toString(36).padStart(9, "0");
   const rnd = randomBytes(8).toString("hex");
   return `${ts}-${rnd}`;
 }
-async function appendRun(paths, rec) {
-  const dir = path17.join(paths.squadDir, "runs");
-  await fs25.mkdir(dir, { recursive: true });
-  const file = path17.join(dir, `${rec.runId}.json`);
-  await fs25.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
-  await pruneOldRuns(dir);
-}
-async function pruneOldRuns(dir) {
-  const entries = (await fs25.readdir(dir)).filter((n) => n.endsWith(".json"));
-  if (entries.length <= RING_SIZE) return;
+async function pruneOldRuns(paths) {
+  const dir = path18.join(paths.squadDir, "runs");
+  const entries = (await fs26.readdir(dir)).filter((n) => n.endsWith(".json"));
+  if (entries.length <= RUN_HISTORY_RING_SIZE) return;
   entries.sort();
-  const drop = entries.slice(0, entries.length - RING_SIZE);
-  await Promise.all(drop.map((n) => fs25.rm(path17.join(dir, n), { force: true })));
+  const drop = entries.slice(0, entries.length - RUN_HISTORY_RING_SIZE);
+  await Promise.all(
+    drop.map(async (n) => {
+      const runPath = path18.join(dir, n);
+      const runId = n.replace(/\.json$/u, "");
+      await fs26.rm(runPath, { force: true });
+      await fs26.rm(path18.join(dir, `${runId}.events.jsonl`), { force: true });
+      await fs26.rm(path18.join(dir, `${runId}.events.jsonl.gz`), { force: true });
+    })
+  );
+}
+async function appendRun(paths, rec) {
+  const dir = path18.join(paths.squadDir, "runs");
+  await fs26.mkdir(dir, { recursive: true });
+  const file = path18.join(dir, `${rec.runId}.json`);
+  await fs26.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
+  await pruneOldRuns(paths);
+  await rotateRunEvents(paths);
 }
 async function listRuns(paths) {
-  const dir = path17.join(paths.squadDir, "runs");
+  const dir = path18.join(paths.squadDir, "runs");
   let entries;
   try {
-    entries = await fs25.readdir(dir);
+    entries = await fs26.readdir(dir);
   } catch {
     return [];
   }
@@ -4087,7 +4550,7 @@ async function listRuns(paths) {
   const out = [];
   for (const f of files) {
     try {
-      const raw = await fs25.readFile(path17.join(dir, f), "utf8");
+      const raw = await fs26.readFile(path18.join(dir, f), "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.version === 1) out.push(parsed);
     } catch {
@@ -4795,6 +5258,11 @@ var VercelRuntime = class {
 
 // src/planner/events.ts
 var PlannerEventBus = class {
+  /**
+   * When `runPlanner` persists JSONL timelines, callers must await this once after emitting
+   * terminal bus events (`done`) so streams flush before process exit.
+   */
+  finalizeEventPersistence;
   listeners = /* @__PURE__ */ new Set();
   emit(e) {
     for (const fn of this.listeners) {
@@ -4871,8 +5339,8 @@ async function runScout(input5) {
 }
 
 // src/planner/validation.ts
-import fs26 from "fs";
-import path18 from "path";
+import fs27 from "fs";
+import path19 from "path";
 var CODE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|md|json|ya?ml|css|html|py|go|rs|cs|java|kt|kts|swift|rb|php|vue|svelte)$/i;
 function summariseIssuesByKind(issues) {
   const out = {};
@@ -4942,21 +5410,21 @@ function trigramSimilarity(a, b) {
   return inter / Math.sqrt(A.size * B.size);
 }
 function suggestPaths(root, missingRel, max = 3) {
-  const targetBase = path18.basename(missingRel).toLowerCase();
+  const targetBase = path19.basename(missingRel).toLowerCase();
   const ig = buildRepoIgnore(root);
   const candidates = [];
   const walk2 = (dir) => {
     if (candidates.length >= 2e3) return;
     let ents;
     try {
-      ents = fs26.readdirSync(dir, { withFileTypes: true });
+      ents = fs27.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of ents) {
       if (candidates.length >= 2e3) return;
-      const abs = path18.join(dir, ent.name);
-      const rel = path18.relative(root, abs).split(path18.sep).join("/");
+      const abs = path19.join(dir, ent.name);
+      const rel = path19.relative(root, abs).split(path19.sep).join("/");
       if (!rel || ig.ignores(rel) || ent.isDirectory() && ig.ignores(`${rel}/`)) continue;
       if (ent.isDirectory()) walk2(abs);
       else if (ent.isFile()) candidates.push(rel);
@@ -4965,7 +5433,7 @@ function suggestPaths(root, missingRel, max = 3) {
   walk2(root);
   const rows = [];
   for (const rel of candidates) {
-    const base = path18.basename(rel).toLowerCase();
+    const base = path19.basename(rel).toLowerCase();
     let score = 0;
     if (base === targetBase) score = 1e3;
     else if (base.startsWith(targetBase) || targetBase.startsWith(base)) score = 500;
@@ -5043,12 +5511,12 @@ function validatePlan(input5) {
   const cache = /* @__PURE__ */ new Map();
   const readCached = (rel) => {
     if (cache.has(rel)) return cache.get(rel);
-    const resolved = path18.resolve(input5.root, rel);
-    const rc = path18.relative(input5.root, resolved);
-    if (rc.startsWith("..") || path18.isAbsolute(rc)) return void 0;
-    if (!fs26.existsSync(resolved) || !fs26.statSync(resolved).isFile()) return void 0;
+    const resolved = path19.resolve(input5.root, rel);
+    const rc = path19.relative(input5.root, resolved);
+    if (rc.startsWith("..") || path19.isAbsolute(rc)) return void 0;
+    if (!fs27.existsSync(resolved) || !fs27.statSync(resolved).isFile()) return void 0;
     try {
-      const buf = fs26.readFileSync(resolved);
+      const buf = fs27.readFileSync(resolved);
       const isBinary = buf.includes(0);
       const text = isBinary ? "" : buf.toString("utf8");
       const lines = isBinary ? 0 : text.split(/\r?\n/).length;
@@ -5062,10 +5530,10 @@ function validatePlan(input5) {
   const pathClaims = mergePathClaims(input5.planText);
   for (const c of pathClaims) {
     if (c.isCreate) continue;
-    const resolved = path18.resolve(input5.root, c.path);
-    const rel = path18.relative(input5.root, resolved);
-    if (rel.startsWith("..") || path18.isAbsolute(rel)) continue;
-    if (!fs26.existsSync(resolved)) {
+    const resolved = path19.resolve(input5.root, c.path);
+    const rel = path19.relative(input5.root, resolved);
+    if (rel.startsWith("..") || path19.isAbsolute(rel)) continue;
+    if (!fs27.existsSync(resolved)) {
       const suggestions = suggestPaths(input5.root, c.path);
       issues.push({
         severity: "warning",
@@ -5232,9 +5700,9 @@ ${result.content}
       }
       continue;
     }
-    const resolved = path19.resolve(root, cleaned);
-    const rc = path19.relative(root, resolved);
-    if (rc.startsWith("..") || path19.isAbsolute(rc)) {
+    const resolved = path20.resolve(root, cleaned);
+    const rc = path20.relative(root, resolved);
+    if (rc.startsWith("..") || path20.isAbsolute(rc)) {
       bus.emit({
         kind: "validation_issue",
         runId,
@@ -5245,7 +5713,7 @@ ${result.content}
       });
       continue;
     }
-    if (!fs27.existsSync(resolved)) {
+    if (!fs28.existsSync(resolved)) {
       bus.emit({
         kind: "validation_issue",
         runId,
@@ -5256,7 +5724,7 @@ ${result.content}
       });
       continue;
     }
-    const st = fs27.statSync(resolved);
+    const st = fs28.statSync(resolved);
     if (!st.isFile()) continue;
     const n = Math.min(st.size, MAX_BYTES_PER_FULL_READ);
     const cap = budget.canRead(n);
@@ -5270,7 +5738,7 @@ _(skipped: ${cap.reason})_
     }
     let buf;
     try {
-      buf = fs27.readFileSync(resolved);
+      buf = fs28.readFileSync(resolved);
     } catch {
       continue;
     }
@@ -5386,6 +5854,19 @@ async function runDraftStage(input5) {
     } : void 0
   });
   const incompleteKind = draft.incompleteKind;
+  const u = input5.budget.snapshot().usage;
+  const cacheRead = u.cacheReadTokens ?? 0;
+  const cacheCreate = u.cacheCreationTokens ?? 0;
+  const totalIn = u.inputTokens + cacheRead;
+  const cacheHitRatio = totalIn === 0 ? 0 : Math.round(cacheRead / totalIn * 100) / 100;
+  bus.emit({
+    kind: "cache_summary",
+    runId,
+    turn: draft.iterations,
+    cacheHitRatio,
+    cacheReadTokens: cacheRead,
+    cacheCreationTokens: cacheCreate
+  });
   return {
     planText: draft.text,
     budgetExhausted: draft.budgetExhausted ?? budgetExhausted,
@@ -5401,6 +5882,26 @@ async function runPlanner(input5) {
   const bus = input5.events ?? new PlannerEventBus();
   const runId = input5.runId ?? newRunId();
   const cacheEnabled = input5.cacheEnabled ?? true;
+  const shouldPersistEvents = input5.persistEvents !== false && input5.paths !== void 0;
+  if (input5.persistEvents === true && !input5.paths) {
+    throw new Error("runPlanner: `paths` is required when `persistEvents: true`");
+  }
+  let persistFinalized = false;
+  if (shouldPersistEvents && input5.paths) {
+    const persistPaths = input5.paths;
+    const store = createRunEventsStore(persistPaths, runId);
+    const unsubPersist = bus.subscribe((e) => {
+      void store.append(e);
+    });
+    bus.finalizeEventPersistence = async () => {
+      if (persistFinalized) return;
+      persistFinalized = true;
+      unsubPersist();
+      await store.close();
+      delete bus.finalizeEventPersistence;
+      await rotateRunEvents(persistPaths);
+    };
+  }
   bus.emit({
     kind: "started",
     runId,
@@ -5409,6 +5910,27 @@ async function runPlanner(input5) {
     cacheEnabled,
     plannerRuntime: input5.runtime.kind
   });
+  bus.emit({
+    kind: "runtime_info",
+    runId,
+    provider: input5.provider,
+    model: input5.modelId,
+    runtimeKind: input5.runtime.kind,
+    cacheEnabled,
+    scoutEnabled: input5.stages?.scout?.enabled !== false,
+    validationEnabled: input5.validation?.enabled !== false,
+    budgetCaps: input5.budget.caps(),
+    providerOptions: input5.provider === "anthropic" && input5.anthropicProviderSpecific ? {
+      anthropic: {
+        thinking: input5.anthropicProviderSpecific.draft?.thinking ?? "adaptive",
+        effort: input5.anthropicProviderSpecific.draft?.effort,
+        effortByPhase: {
+          scout: input5.anthropicProviderSpecific.scout?.effort,
+          draft: input5.anthropicProviderSpecific.draft?.effort
+        }
+      }
+    } : void 0
+  });
   const merged = { ...input5, events: bus, runId };
   const systemPrompt = input5.systemPrompt;
   let scoutSummary;
@@ -5665,14 +6187,165 @@ var BUILTIN_TOOL_DENY = [
   "WebFetch",
   "WebSearch"
 ];
-function streamEventTextDelta(ev) {
-  if (!ev || typeof ev !== "object") return "";
+function initialThinkingState() {
+  return {
+    blockIndexCounter: 0,
+    inThinkingBlock: false,
+    thinkingBlockIndex: -1,
+    thinkingBlockStartedAt: 0,
+    thinkingChars: 0
+  };
+}
+function decodeStreamEvent(ev) {
+  if (!ev || typeof ev !== "object") return { kind: "other" };
   const o = ev;
-  if (o.type === "content_block_delta") {
+  const t = o.type;
+  if (t === "message_start") {
+    const msg = o.message;
+    const u = msg?.usage ?? o.usage;
+    if (!u || typeof u !== "object") return { kind: "message_start" };
+    return {
+      kind: "message_start",
+      usage: {
+        input_tokens: num(u.input_tokens),
+        output_tokens: num(u.output_tokens),
+        cache_creation_input_tokens: num(u.cache_creation_input_tokens),
+        cache_read_input_tokens: num(u.cache_read_input_tokens)
+      }
+    };
+  }
+  if (t === "message_delta") {
+    const u = o.usage;
+    if (!u || typeof u !== "object") return { kind: "message_delta" };
+    return {
+      kind: "message_delta",
+      usage: {
+        output_tokens: num(u.output_tokens),
+        cache_creation_input_tokens: num(u.cache_creation_input_tokens),
+        cache_read_input_tokens: num(u.cache_read_input_tokens)
+      }
+    };
+  }
+  if (t === "content_block_start") {
+    const idx = typeof o.index === "number" ? o.index : 0;
+    const cb = o.content_block;
+    const bt = cb?.type;
+    if (bt === "thinking" || bt === "text" || bt === "tool_use")
+      return { kind: "content_block_start", blockType: bt, index: idx };
+    return { kind: "other" };
+  }
+  if (t === "content_block_stop") {
+    return { kind: "content_block_stop", index: typeof o.index === "number" ? o.index : 0 };
+  }
+  if (t === "content_block_delta") {
     const d = o.delta;
-    if (d && d.type === "text_delta" && typeof d.text === "string") return d.text;
+    if (!d) return { kind: "other" };
+    const dt = d.type;
+    if (dt === "text_delta" && typeof d.text === "string") {
+      return { kind: "text_delta", text: d.text };
+    }
+    if (dt === "thinking_delta") {
+      const th = typeof d.thinking === "string" ? d.thinking : typeof d.text === "string" ? d.text : "";
+      if (th) return { kind: "thinking_delta", text: th };
+    }
+  }
+  return { kind: "other" };
+}
+function num(v) {
+  return typeof v === "number" && !Number.isNaN(v) ? v : void 0;
+}
+function handleDecodedStreamEvent(decoded, input5) {
+  const { bus, runId, onAssistantText, think } = input5;
+  const turnUse = input5.assistantTurns + 1;
+  if (decoded.kind === "message_start" && decoded.usage) {
+    const u = decoded.usage;
+    const partial = {
+      inputTokens: u.input_tokens ?? 0,
+      outputTokens: u.output_tokens ?? 0,
+      cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+      cacheReadTokens: u.cache_read_input_tokens ?? 0
+    };
+    bus.emit({ kind: "usage", runId, turn: turnUse, usage: partial });
+    return;
+  }
+  if (decoded.kind === "message_delta" && decoded.usage) {
+    const out = decoded.usage.output_tokens ?? 0;
+    if (out > 0) {
+      bus.emit({
+        kind: "usage",
+        runId,
+        turn: turnUse,
+        usage: { inputTokens: 0, outputTokens: out }
+      });
+    }
+    return;
+  }
+  if (decoded.kind === "text_delta") {
+    input5.textSink?.append(decoded.text);
+    onAssistantText?.(decoded.text);
+    bus.emit({
+      kind: "assistant_text",
+      runId,
+      turn: input5.assistantTurns,
+      delta: decoded.text
+    });
+    return;
+  }
+  if (decoded.kind === "content_block_start") {
+    if (decoded.blockType === "thinking") {
+      think.inThinkingBlock = true;
+      think.thinkingBlockIndex = decoded.index;
+      think.thinkingChars = 0;
+      think.thinkingBlockStartedAt = Date.now();
+      think.blockIndexCounter = Math.max(think.blockIndexCounter, decoded.index + 1);
+      bus.emit({
+        kind: "thinking_block_started",
+        runId,
+        turn: input5.assistantTurns,
+        blockIndex: think.thinkingBlockIndex
+      });
+    } else {
+      think.inThinkingBlock = false;
+    }
+    return;
+  }
+  if (decoded.kind === "thinking_delta") {
+    if (!think.inThinkingBlock) {
+      think.thinkingBlockIndex = think.blockIndexCounter++;
+      think.thinkingChars = 0;
+      think.thinkingBlockStartedAt = Date.now();
+      think.inThinkingBlock = true;
+      bus.emit({
+        kind: "thinking_block_started",
+        runId,
+        turn: input5.assistantTurns,
+        blockIndex: think.thinkingBlockIndex
+      });
+    }
+    think.thinkingChars += decoded.text.length;
+    bus.emit({
+      kind: "thinking_delta",
+      runId,
+      turn: input5.assistantTurns,
+      blockIndex: think.thinkingBlockIndex,
+      delta: decoded.text
+    });
+    return;
+  }
+  if (decoded.kind === "content_block_stop") {
+    if (think.inThinkingBlock) {
+      bus.emit({
+        kind: "thinking_block_stopped",
+        runId,
+        turn: input5.assistantTurns,
+        blockIndex: think.thinkingBlockIndex,
+        durationMs: Date.now() - think.thinkingBlockStartedAt,
+        chars: think.thinkingChars
+      });
+      think.inThinkingBlock = false;
+      think.thinkingBlockIndex = -1;
+    }
   }
-  return "";
 }
 var AgentSdkRuntime = class {
   constructor(modelId, apiKey) {
@@ -5727,6 +6400,7 @@ var AgentSdkRuntime = class {
     let finishedNormally = false;
     let incompleteKind;
     let userCancelled = false;
+    const think = initialThinkingState();
     try {
       const q = query({
         prompt: input5.userMessage,
@@ -5736,15 +6410,21 @@ var AgentSdkRuntime = class {
         const m = message;
         switch (m.type) {
           case "stream_event": {
-            const delta = streamEventTextDelta(m.event);
-            if (delta) {
-              text += delta;
-              input5.onAssistantText?.(delta);
-              input5.bus.emit({ kind: "assistant_text", runId: input5.runId, turn: assistantTurns, delta });
-            }
+            handleDecodedStreamEvent(decodeStreamEvent(m.event), {
+              bus: input5.bus,
+              runId: input5.runId,
+              assistantTurns,
+              onAssistantText: input5.onAssistantText,
+              think,
+              textSink: { append: (s) => text += s }
+            });
             break;
           }
           case "assistant": {
+            think.blockIndexCounter = 0;
+            think.inThinkingBlock = false;
+            think.thinkingBlockIndex = -1;
+            think.thinkingChars = 0;
             assistantTurns += 1;
             input5.bus.emit({
               kind: "turn_complete",
@@ -5770,6 +6450,8 @@ var AgentSdkRuntime = class {
             }
             break;
           }
+          case "system":
+            break;
           default:
             break;
         }
@@ -5824,6 +6506,7 @@ var AgentSdkRuntime = class {
       mcpServers: { "squad-kit-scout": mcpServer },
       systemPrompt: input5.systemPrompt + "\n\nIMPORTANT: respond by calling the `respond_with_scout_result` tool with the JSON object \u2014 do not write the JSON as text.",
       maxTurns: 2,
+      includePartialMessages: true,
       persistSession: false,
       settingSources: [],
       env: { ...process.env, ANTHROPIC_API_KEY: this.apiKey },
@@ -5831,6 +6514,8 @@ var AgentSdkRuntime = class {
       effort
     };
     let usage = { inputTokens: 0, outputTokens: 0 };
+    let assistantTurns = 0;
+    const think = initialThinkingState();
     const ac = new AbortController();
     const onAbort = () => ac.abort();
     if (input5.abort) {
@@ -5844,10 +6529,31 @@ var AgentSdkRuntime = class {
       });
       for await (const message of q) {
         const m = message;
-        if (m.type === "result") {
-          usage = usageFromAgentSdkResult(
-            m.usage
-          );
+        switch (m.type) {
+          case "stream_event":
+            handleDecodedStreamEvent(decodeStreamEvent(m.event), {
+              bus: input5.bus,
+              runId: input5.runId,
+              assistantTurns,
+              think
+            });
+            break;
+          case "assistant":
+            think.blockIndexCounter = 0;
+            think.inThinkingBlock = false;
+            think.thinkingBlockIndex = -1;
+            think.thinkingChars = 0;
+            assistantTurns += 1;
+            break;
+          case "result":
+            usage = usageFromAgentSdkResult(
+              m.usage
+            );
+            break;
+          case "system":
+            break;
+          default:
+            break;
         }
       }
     } finally {
@@ -5927,6 +6633,13 @@ var Budget = class {
   timedOut() {
     return (Date.now() - this.startedAt) / 1e3 > this.maxWallSeconds;
   }
+  caps() {
+    return {
+      maxFileReads: this.maxFileReadsAllowed,
+      maxContextBytes: this.maxContextBytesAllowed,
+      maxDurationSeconds: this.maxWallSeconds
+    };
+  }
   snapshot() {
     return {
       reads: this.reads,
@@ -5938,8 +6651,8 @@ var Budget = class {
 };
 
 // src/planner/writer.ts
-import fs28 from "fs";
-import path20 from "path";
+import fs29 from "fs";
+import path21 from "path";
 function planFileSlugParts(config2, story) {
   const baseSlug = slugify(story.id);
   const trackerId = config2.naming.includeTrackerId && config2.tracker.type !== "none" ? trackerIdForFilename(config2.tracker.type, story.id) : "";
@@ -5948,8 +6661,8 @@ function planFileSlugParts(config2, story) {
 }
 function writePlanFile(input5) {
   const { paths, config: config2, story } = input5;
-  const featurePlanDir = path20.join(paths.plansDir, story.feature);
-  fs28.mkdirSync(featurePlanDir, { recursive: true });
+  const featurePlanDir = path21.join(paths.plansDir, story.feature);
+  fs29.mkdirSync(featurePlanDir, { recursive: true });
   if (input5.partial) {
     return writePartialPlanFile(input5, featurePlanDir, paths, config2, story);
   }
@@ -5964,14 +6677,14 @@ function writePlanFile(input5) {
   } else {
     nn = scanPlans(paths.plansDir).nextGlobal;
     const { baseSlug, trackerPart } = planFileSlugParts(config2, story);
-    targetPath = path20.join(featurePlanDir, `${formatSequence(nn)}-story-${baseSlug}${trackerPart}.md`);
+    targetPath = path21.join(featurePlanDir, `${formatSequence(nn)}-story-${baseSlug}${trackerPart}.md`);
   }
   const body = `${input5.metadataHeader.trimEnd()}
 
 ${input5.planBodyMarkdown.trimStart()}
 `;
-  fs28.writeFileSync(targetPath, body, "utf8");
-  upsertOverviewRow(featurePlanDir, story.feature, nn, path20.basename(targetPath), story, false);
+  fs29.writeFileSync(targetPath, body, "utf8");
+  upsertOverviewRow(featurePlanDir, story.feature, nn, path21.basename(targetPath), story, false);
   return { planFile: targetPath, sequenceNumber: nn, overwrote };
 }
 function writePartialPlanFile(input5, featurePlanDir, paths, config2, story) {
@@ -5986,42 +6699,42 @@ function writePartialPlanFile(input5, featurePlanDir, paths, config2, story) {
   } else {
     nn = scanPlans(paths.plansDir).nextGlobal;
     const { baseSlug, trackerPart } = planFileSlugParts(config2, story);
-    targetPath = path20.join(featurePlanDir, `${formatSequence(nn)}-story-${baseSlug}${trackerPart}.partial.md`);
+    targetPath = path21.join(featurePlanDir, `${formatSequence(nn)}-story-${baseSlug}${trackerPart}.partial.md`);
   }
   const body = `${input5.metadataHeader.trimEnd()}
 
 ${input5.planBodyMarkdown.trimStart()}
 `;
-  fs28.writeFileSync(targetPath, body, "utf8");
-  upsertOverviewRow(featurePlanDir, story.feature, nn, path20.basename(targetPath), story, true);
+  fs29.writeFileSync(targetPath, body, "utf8");
+  upsertOverviewRow(featurePlanDir, story.feature, nn, path21.basename(targetPath), story, true);
   return { planFile: targetPath, sequenceNumber: nn, overwrote };
 }
 function findExistingPlan(featureDir, storyId) {
-  if (!fs28.existsSync(featureDir)) return void 0;
+  if (!fs29.existsSync(featureDir)) return void 0;
   const pattern = /^(\d{2,})-story-.+\.md$/;
-  for (const entry of fs28.readdirSync(featureDir)) {
+  for (const entry of fs29.readdirSync(featureDir)) {
     if (entry.endsWith(".partial.md")) continue;
     const m = entry.match(pattern);
     if (!m) continue;
-    if (entry.includes(storyId)) return { absPath: path20.join(featureDir, entry), nn: parseInt(m[1], 10) };
+    if (entry.includes(storyId)) return { absPath: path21.join(featureDir, entry), nn: parseInt(m[1], 10) };
   }
   return void 0;
 }
 function findExistingPartialPlan(featureDir, storyId) {
-  if (!fs28.existsSync(featureDir)) return void 0;
+  if (!fs29.existsSync(featureDir)) return void 0;
   const pattern = /^(\d{2,})-story-.+\.partial\.md$/;
-  for (const entry of fs28.readdirSync(featureDir)) {
+  for (const entry of fs29.readdirSync(featureDir)) {
     const m = entry.match(pattern);
     if (!m) continue;
-    if (entry.includes(storyId)) return { absPath: path20.join(featureDir, entry), nn: parseInt(m[1], 10) };
+    if (entry.includes(storyId)) return { absPath: path21.join(featureDir, entry), nn: parseInt(m[1], 10) };
   }
   return void 0;
 }
 function upsertOverviewRow(featureDir, feature, nn, filename, story, isPartial) {
-  const overviewPath = path20.join(featureDir, "00-overview.md");
+  const overviewPath = path21.join(featureDir, "00-overview.md");
   const titleCell = isPartial ? `${story.titleHint ?? story.id} (partial)` : story.titleHint ?? story.id;
   const row = `| ${formatSequence(nn)} | \`${filename}\` | ${titleCell} | ${story.id} | \u2014 |`;
-  if (!fs28.existsSync(overviewPath)) {
+  if (!fs29.existsSync(overviewPath)) {
     const content = `# ${feature} \u2014 plan overview
 
 Entry point for the **${feature}** feature. Stories execute in order by their \`NN\` prefix.
@@ -6032,10 +6745,10 @@ Entry point for the **${feature}** feature. Stories execute in order by their \`
 |----|------|-------|------------|------------|
 ${row}
 `;
-    fs28.writeFileSync(overviewPath, content, "utf8");
+    fs29.writeFileSync(overviewPath, content, "utf8");
     return;
   }
-  const current = fs28.readFileSync(overviewPath, "utf8");
+  const current = fs29.readFileSync(overviewPath, "utf8");
   const lines = current.split("\n");
   const existingIdx = lines.findIndex((l) => l.includes(`\`${filename}\``) || l.includes(`| ${formatSequence(nn)} |`));
   if (existingIdx >= 0) {
@@ -6044,7 +6757,7 @@ ${row}
     const tableEnd = findTableEnd(lines);
     lines.splice(tableEnd, 0, row);
   }
-  fs28.writeFileSync(overviewPath, lines.join("\n"), "utf8");
+  fs29.writeFileSync(overviewPath, lines.join("\n"), "utf8");
 }
 function findTableEnd(lines) {
   let inTable = false;
@@ -6097,16 +6810,16 @@ function buildCopyPlanPromptMarkdown(config2, intakeContent) {
 }
 
 // src/core/last-run.ts
-import fs29 from "fs/promises";
-import path21 from "path";
+import fs30 from "fs/promises";
+import path22 from "path";
 async function writeLastRun(paths, rec) {
-  const file = path21.join(paths.squadDir, ".last-run.json");
-  await fs29.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
+  const file = path22.join(paths.squadDir, ".last-run.json");
+  await fs30.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
 }
 async function readLastRun(paths) {
-  const file = path21.join(paths.squadDir, ".last-run.json");
+  const file = path22.join(paths.squadDir, ".last-run.json");
   try {
-    const raw = await fs29.readFile(file, "utf8");
+    const raw = await fs30.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1) return void 0;
     return parsed;
@@ -6139,8 +6852,8 @@ function formatPlannerCacheLine(opts) {
 }
 
 // src/core/plans-index.ts
-import fs30 from "fs";
-import path22 from "path";
+import fs31 from "fs";
+import path23 from "path";
 var MAX_ENTRIES = 30;
 function firstMarkdownH1(src) {
   const lines = src.split(/\r?\n/);
@@ -6155,12 +6868,12 @@ function collectPlanMarkdownFiles(plansDir) {
   const walk2 = (dir) => {
     let ents;
     try {
-      ents = fs30.readdirSync(dir, { withFileTypes: true });
+      ents = fs31.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of ents) {
-      const abs = path22.join(dir, ent.name);
+      const abs = path23.join(dir, ent.name);
       if (ent.isDirectory()) {
         walk2(abs);
       } else if (ent.isFile() && ent.name.endsWith(".md")) {
@@ -6169,7 +6882,7 @@ function collectPlanMarkdownFiles(plansDir) {
       }
     }
   };
-  if (fs30.existsSync(plansDir)) walk2(plansDir);
+  if (fs31.existsSync(plansDir)) walk2(plansDir);
   out.sort((a, b) => a.localeCompare(b));
   return out.slice(0, MAX_ENTRIES);
 }
@@ -6178,19 +6891,265 @@ function buildPlansIndex(paths) {
   if (files.length === 0) return "(no prior plans yet)";
   const bullets = [];
   for (const abs of files) {
-    const rel = path22.relative(paths.root, abs).split(path22.sep).join("/");
+    const rel = path23.relative(paths.root, abs).split(path23.sep).join("/");
     let title = "";
     try {
-      const raw = fs30.readFileSync(abs, "utf8");
-      title = firstMarkdownH1(raw) ?? path22.basename(abs);
+      const raw = fs31.readFileSync(abs, "utf8");
+      title = firstMarkdownH1(raw) ?? path23.basename(abs);
     } catch {
-      title = path22.basename(abs);
+      title = path23.basename(abs);
     }
     bullets.push(`- ${rel} \u2014 "${title}"`);
   }
   return bullets.join("\n");
 }
 
+// src/commands/new-plan-api-events.ts
+function toolLabel(name, inp) {
+  if (name === "read_file") {
+    return `read ${String(inp.path ?? "<unknown>")}`;
+  }
+  if (name === "grep") {
+    return `grep ${String(inp.pattern ?? "?").slice(0, 48)}`;
+  }
+  if (name === "list_dir") {
+    return `list_dir ${String(inp.path ?? "?")}`;
+  }
+  return name;
+}
+function ensureStagesIntro(ctx) {
+  if (ctx.stagesIntroPrinted) return;
+  ctx.stagesIntroPrinted = true;
+  divider("stages");
+}
+function budgetSnap(ctx) {
+  const snap = ctx.budget.snapshot();
+  const caps = ctx.budgetCaps ?? ctx.budget.caps();
+  return {
+    reads: snap.reads,
+    readsCap: caps.maxFileReads,
+    bytes: snap.bytes,
+    bytesCap: caps.maxContextBytes,
+    elapsedMs: Date.now() - ctx.startedAt,
+    durationMsCap: caps.maxDurationSeconds * 1e3
+  };
+}
+function printBudgetMeterLine(ctx) {
+  line(`  ${dim(formatBudgetMeter(budgetSnap(ctx)))}`);
+}
+function resumeSessionSpinner(ctx) {
+  const st = ctx.activePlannerStage;
+  if (st === "scout") ctx.sessionSpinner.current = spinner("scouting\u2026");
+  else if (st === "draft") ctx.sessionSpinner.current = spinner("drafting\u2026");
+  else if (st === "validation") ctx.sessionSpinner.current = spinner("validating\u2026");
+  else ctx.sessionSpinner.current = spinner("next tool\u2026");
+}
+function clearThinkingTick(ctx) {
+  if (ctx.thinkingTick.id) {
+    clearInterval(ctx.thinkingTick.id);
+    ctx.thinkingTick.id = null;
+  }
+}
+function applyUsagePrefix(ctx) {
+  if (!ctx.interactive || !ctx.sessionSpinner.current) return;
+  const snap = ctx.budget.snapshot().usage;
+  const useBudget = snap.inputTokens > 0 || snap.outputTokens > 0;
+  const inTok = useBudget ? snap.inputTokens : ctx.usageAcc.inputTokens;
+  const outTok = useBudget ? snap.outputTokens : ctx.usageAcc.outputTokens;
+  const meter = formatBudgetMeter(budgetSnap(ctx));
+  ctx.sessionSpinner.current.setPrefix(`${inTok} in \xB7 ${outTok} out \xB7 ${meter}  `);
+}
+function dispatchNewPlanApiPlannerEvent(ctx, e) {
+  switch (e.kind) {
+    case "runtime_info": {
+      ctx.budgetCaps = e.budgetCaps;
+      if (!e.scoutEnabled) {
+        ctx.stageLine.scout = "skipped";
+      }
+      if (!e.validationEnabled) {
+        ctx.stageLine.validation = "skipped";
+      }
+      divider("runtime info");
+      kv("provider", e.provider);
+      kv("model", e.model);
+      kv(
+        "runtime",
+        `${e.runtimeKind}${e.provider === "anthropic" && ctx.anthropicRuntimeChoice ? ` (${ctx.anthropicRuntimeChoice})` : ""}`
+      );
+      kv("cache", e.cacheEnabled ? "enabled" : "disabled");
+      kv("scout", e.scoutEnabled ? "enabled" : "disabled");
+      kv("validation", e.validationEnabled ? "enabled" : "disabled");
+      const caps = e.budgetCaps;
+      kv(
+        "budget caps",
+        `${caps.maxFileReads} reads \xB7 ${(caps.maxContextBytes / 1024).toFixed(0)} KB \xB7 ${caps.maxDurationSeconds}s`
+      );
+      const anth = e.providerOptions?.anthropic;
+      if (e.provider === "anthropic" && anth) {
+        if (anth.effortByPhase?.scout || anth.effortByPhase?.draft) {
+          const s = anth.effortByPhase.scout ? `scout ${anth.effortByPhase.scout}` : "";
+          const d = anth.effortByPhase.draft ? `draft ${anth.effortByPhase.draft}` : "";
+          kv("effort", [s, d].filter(Boolean).join(" \xB7 ") || (anth.effort ?? "\u2014"));
+        } else if (anth.effort) {
+          kv("effort", anth.effort);
+        }
+        if (anth.thinking && anth.thinking !== "off") {
+          kv("thinking", anth.thinking);
+        }
+      }
+      ensureStagesIntro(ctx);
+      printStagePipeline(ctx.stageLine);
+      break;
+    }
+    case "stage_started": {
+      ctx.activePlannerStage = e.stage;
+      ensureStagesIntro(ctx);
+      ctx.stageLine[e.stage] = "running";
+      printStagePipeline(ctx.stageLine);
+      printBudgetMeterLine(ctx);
+      ctx.sessionSpinner.current?.stop();
+      if (e.stage === "scout") ctx.sessionSpinner.current = spinner("scouting\u2026");
+      else if (e.stage === "draft") ctx.sessionSpinner.current = spinner("drafting\u2026");
+      else if (e.stage === "validation") ctx.sessionSpinner.current = spinner("validating\u2026");
+      applyUsagePrefix(ctx);
+      break;
+    }
+    case "stage_complete": {
+      const st = e.stage;
+      ctx.stageLine[st] = e.success ? "success" : "failed";
+      if (!e.success && e.errorMessage && st === "scout") {
+        ctx.sessionSpinner.current?.stop();
+        warning(`scout stage failed: ${e.errorMessage}`);
+      }
+      ensureStagesIntro(ctx);
+      printStagePipeline(ctx.stageLine);
+      break;
+    }
+    case "tool_call_started":
+      break;
+    case "tool_call": {
+      const name = e.toolCall.name;
+      const inp = e.toolCall.input;
+      ctx.lastToolUi = {
+        label: toolLabel(name, inp),
+        bytesLoaded: e.bytesLoaded,
+        totalBytes: e.totalBytes
+      };
+      break;
+    }
+    case "tool_call_completed": {
+      const pending = ctx.lastToolUi;
+      ctx.lastToolUi = null;
+      const label = pending?.label ?? toolLabel(e.name, {});
+      const bytesLoaded = pending?.bytesLoaded ?? e.bytesLoaded;
+      const totalBytes = pending?.totalBytes ?? e.totalBytes;
+      const caps = ctx.budgetCaps ?? ctx.budget.caps();
+      const kb = `(${(bytesLoaded / 1024).toFixed(1)} KB \xB7 ${(totalBytes / 1024).toFixed(1)} KB / ${(caps.maxContextBytes / 1024).toFixed(0)} KB) \xB7 tool ${e.durationMs}ms`;
+      if (e.isError) {
+        ctx.sessionSpinner.current?.fail(
+          `${label}  ${kb}${e.errorSnippet ? ` \u2014 ${e.errorSnippet}` : ""}`
+        );
+      } else {
+        ctx.sessionSpinner.current?.succeed(`${label}  ${kb}`);
+      }
+      ctx.sessionSpinner.current = spinner("next tool\u2026");
+      applyUsagePrefix(ctx);
+      printBudgetMeterLine(ctx);
+      break;
+    }
+    case "thinking_block_started": {
+      clearThinkingTick(ctx);
+      ctx.thinkingState.running = true;
+      ctx.thinkingBlockChars = 0;
+      ctx.thinkingState.blockStartedAt = Date.now();
+      ctx.sessionSpinner.current?.stop();
+      ctx.thinkingSpinner.current = spinner("thinking\u2026");
+      ctx.thinkingTick.id = setInterval(() => {
+        if (!ctx.thinkingSpinner.current) return;
+        ctx.thinkingSpinner.current.update(
+          formatThinkingLine({
+            running: true,
+            durationMs: Date.now() - ctx.thinkingState.blockStartedAt,
+            chars: ctx.thinkingBlockChars
+          })
+        );
+      }, 500);
+      break;
+    }
+    case "thinking_delta": {
+      ctx.thinkingBlockChars += e.delta.length;
+      break;
+    }
+    case "thinking_block_stopped": {
+      clearThinkingTick(ctx);
+      ctx.thinkingState.running = false;
+      ctx.thinkingSpinner.current?.succeed(
+        formatThinkingLine({ running: false, durationMs: e.durationMs, chars: e.chars })
+      );
+      ctx.thinkingSpinner.current = null;
+      ctx.thinkingState.totalChars += e.chars;
+      ctx.thinkingState.totalDurationMs += e.durationMs;
+      resumeSessionSpinner(ctx);
+      applyUsagePrefix(ctx);
+      break;
+    }
+    case "usage": {
+      ctx.usageAcc.inputTokens += e.usage.inputTokens;
+      ctx.usageAcc.outputTokens += e.usage.outputTokens;
+      applyUsagePrefix(ctx);
+      break;
+    }
+    case "validation_issue": {
+      if (!ctx.interactive) break;
+      ctx.streamedValidationIssues.count += 1;
+      const n = ctx.streamedValidationIssues.count;
+      if (n <= 50) {
+        const pathPart = e.path ? ` ${e.path}` : "";
+        const line2 = `[${e.severity}] ${e.issueKind}${pathPart} \u2014 ${e.detail}`;
+        if (e.severity === "error") failure(line2);
+        else warning(line2);
+      } else if (!ctx.validationStreamCappedMsg) {
+        ctx.validationStreamCappedMsg = true;
+        info(`  \u2026 +${n - 50} more issues, see summary`);
+      }
+      break;
+    }
+    case "assistant_text": {
+      if (ctx.thinkingState.running) return;
+      ctx.sessionSpinner.current?.succeed("planner thinking complete (this chunk)");
+      ctx.sessionSpinner.current = spinner("thinking\u2026");
+      applyUsagePrefix(ctx);
+      break;
+    }
+    case "rate_limit": {
+      if (e.phase === "retrying") {
+        ctx.sessionSpinner.current?.stop();
+        warning(`${e.provider} rate limit hit \u2014 retrying in ${e.waitSec}s`);
+        ctx.sessionSpinner.current = spinner("waiting for rate limit to reset\u2026");
+      }
+      break;
+    }
+    case "scout_result": {
+      ctx.activePlannerStage = "draft";
+      const preview = e.selected.slice(0, 4).join(", ");
+      const more = e.selected.length > 4 ? "\u2026" : "";
+      ctx.sessionSpinner.current?.succeed(`scout picked ${e.selected.length} files: ${preview}${more}`);
+      ctx.sessionSpinner.current = spinner("drafting\u2026");
+      applyUsagePrefix(ctx);
+      break;
+    }
+    case "cancelled": {
+      clearThinkingTick(ctx);
+      ctx.thinkingState.running = false;
+      ctx.thinkingSpinner.current?.fail("cancelled");
+      ctx.thinkingSpinner.current = null;
+      break;
+    }
+    default:
+      break;
+  }
+}
+
 // src/commands/new-plan.ts
 function decideMode(opts, config2) {
   if (opts.api && opts.copy) {
@@ -6222,8 +7181,8 @@ async function runNewPlan(intakePath, opts) {
   }
 }
 function resolveFromPath(intakePath, stories, root) {
-  const resolved = path23.resolve(intakePath.trim());
-  if (!fs31.existsSync(resolved)) {
+  const resolved = path24.resolve(intakePath.trim());
+  if (!fs32.existsSync(resolved)) {
     throw new Error(
       `Intake not found: ${resolved}. Run \`squad list\` to see intakes, or \`squad new-story\` to create one first.`
     );
@@ -6235,7 +7194,7 @@ function resolveFromPath(intakePath, stories, root) {
   );
 }
 function relativeStoriesDir(root) {
-  return path23.relative(root, path23.join(root, ".squad", "stories"));
+  return path24.relative(root, path24.join(root, ".squad", "stories"));
 }
 async function pickStory(stories, opts) {
   const candidates = opts.all ? stories : stories.filter((s) => !s.planFile);
@@ -6266,7 +7225,7 @@ async function pickStory(stories, opts) {
       value: s.intakePath
     }))
   });
-  return candidates.find((s) => path23.resolve(s.intakePath) === path23.resolve(pick));
+  return candidates.find((s) => path24.resolve(s.intakePath) === path24.resolve(pick));
 }
 function formatLabel(s) {
   const head = `${s.feature} / ${s.id}`;
@@ -6336,14 +7295,6 @@ async function emitViaApi(story, paths, config2, opts) {
   step(`planning   ${story.feature} / ${story.id}`);
   kv("provider", planner.provider);
   kv("model", modelId);
-  kv(
-    "runtime",
-    `${draftRuntime.kind} \xB7 ${draftRuntime.providerName}` + (planner.provider === "anthropic" ? ` (${anthropicRuntimeChoice})` : "")
-  );
-  kv(
-    "budget",
-    `${planner.budget.maxFileReads} reads \xB7 ${(planner.budget.maxContextBytes / 1024).toFixed(0)} KB \xB7 ${planner.budget.maxDurationSeconds}s`
-  );
   blank();
   const interactive = !opts.yes && Boolean(process.stdin.isTTY);
   if (interactive) {
@@ -6395,64 +7346,27 @@ async function emitViaApi(story, paths, config2, opts) {
   const cacheEnabled = planner.cache?.enabled ?? true;
   const runId = newRunId();
   const bus = new PlannerEventBus();
+  const apiUiCtx = {
+    sessionSpinner,
+    stageLine: { scout: "pending", draft: "pending", validation: "pending" },
+    activePlannerStage: null,
+    thinkingBlockChars: 0,
+    thinkingState: { running: false, blockStartedAt: 0, totalChars: 0, totalDurationMs: 0 },
+    thinkingSpinner: { current: null },
+    thinkingTick: { id: null },
+    budget,
+    budgetCaps: null,
+    startedAt,
+    interactive,
+    stagesIntroPrinted: false,
+    lastToolUi: null,
+    streamedValidationIssues: { count: 0 },
+    validationStreamCappedMsg: false,
+    anthropicRuntimeChoice: planner.provider === "anthropic" ? anthropicRuntimeChoice : void 0,
+    usageAcc: { inputTokens: 0, outputTokens: 0 }
+  };
   const unsubscribe = bus.subscribe((e) => {
-    switch (e.kind) {
-      case "tool_call": {
-        const name = e.toolCall.name;
-        const inp = e.toolCall.input;
-        let label;
-        if (name === "read_file") {
-          label = `read ${String(inp.path ?? "<unknown>")}`;
-        } else if (name === "grep") {
-          label = `grep ${String(inp.pattern ?? "?").slice(0, 48)}`;
-        } else if (name === "list_dir") {
-          label = `list_dir ${String(inp.path ?? "?")}`;
-        } else {
-          label = name;
-        }
-        sessionSpinner.current?.succeed(
-          `${label}  (${(e.bytesLoaded / 1024).toFixed(1)} KB \xB7 ${(e.totalBytes / 1024).toFixed(1)} KB / ${(planner.budget.maxContextBytes / 1024).toFixed(0)} KB)`
-        );
-        sessionSpinner.current = spinner("next tool\u2026");
-        break;
-      }
-      case "stage_started": {
-        sessionSpinner.current?.stop();
-        if (e.stage === "scout") sessionSpinner.current = spinner("scouting\u2026");
-        else if (e.stage === "draft") sessionSpinner.current = spinner("drafting\u2026");
-        else if (e.stage === "validation") sessionSpinner.current = spinner("validating\u2026");
-        break;
-      }
-      case "stage_complete": {
-        if (!e.success && e.errorMessage && e.stage === "scout") {
-          sessionSpinner.current?.stop();
-          warning(`scout stage failed: ${e.errorMessage}`);
-        }
-        break;
-      }
-      case "scout_result": {
-        const preview = e.selected.slice(0, 4).join(", ");
-        const more = e.selected.length > 4 ? "\u2026" : "";
-        sessionSpinner.current?.succeed(`scout picked ${e.selected.length} files: ${preview}${more}`);
-        sessionSpinner.current = spinner("drafting\u2026");
-        break;
-      }
-      case "assistant_text":
-        sessionSpinner.current?.succeed("planner thinking complete (this chunk)");
-        sessionSpinner.current = spinner("thinking\u2026");
-        break;
-      case "rate_limit":
-        if (e.phase === "retrying") {
-          sessionSpinner.current?.stop();
-          warning(`${e.provider} rate limit hit \u2014 retrying in ${e.waitSec}s`);
-          sessionSpinner.current = spinner("waiting for rate limit to reset\u2026");
-        }
-        break;
-      case "usage":
-        break;
-      default:
-        break;
-    }
+    dispatchNewPlanApiPlannerEvent(apiUiCtx, e);
   });
   const decideOnLimit = interactive ? async (ctx) => {
     printPlannerLimitExplanation(ctx);
@@ -6482,6 +7396,7 @@ async function emitViaApi(story, paths, config2, opts) {
       decideOnLimit,
       events: bus,
       runId,
+      paths,
       stages: {
         scout: {
           enabled: scoutEnabled,
@@ -6496,7 +7411,13 @@ async function emitViaApi(story, paths, config2, opts) {
       scoutSystemPrompt
     });
   } finally {
+    await bus.finalizeEventPersistence?.();
     unsubscribe();
+    if (apiUiCtx.thinkingTick.id) {
+      clearInterval(apiUiCtx.thinkingTick.id);
+      apiUiCtx.thinkingTick.id = null;
+    }
+    apiUiCtx.thinkingSpinner.current?.stop();
     sessionSpinner.current?.stop();
   }
   if (!result.planText.trim()) {
@@ -6531,7 +7452,7 @@ async function emitViaApi(story, paths, config2, opts) {
     metadataHeader: header,
     partial: !success2
   });
-  const relPlan = path23.relative(paths.root, planFile);
+  const relPlan = path24.relative(paths.root, planFile);
   try {
     await writeLastRun(paths, {
       stats: result.stats,
@@ -6570,11 +7491,27 @@ async function emitViaApi(story, paths, config2, opts) {
     });
   } catch {
   }
+  const stripAnsi2 = (s) => s.replace(/\x1B\[[0-9;]*m/g, "");
+  const budgetCapsForSummary = budget.caps();
   blank();
   summaryBox(success2 ? " plan generated " : " plan saved (incomplete) ", [
     { key: "file", value: relPlan },
     { key: "nn", value: String(sequenceNumber).padStart(2, "0") },
     { key: "model", value: `${planner.provider}/${modelId}` },
+    {
+      key: "runtime",
+      value: (() => {
+        let chips = "";
+        if (planner.provider === "anthropic") {
+          const d = anthropicProviderSpecific?.draft;
+          if (d?.effort) chips += ` \xB7 effort ${d.effort}`;
+          if (d?.thinking && d.thinking !== "off") chips += ` \xB7 thinking ${d.thinking}`;
+        }
+        const rollup = apiUiCtx.thinkingState.totalChars > 0 ? ` \xB7 \u03A3 ${apiUiCtx.thinkingState.totalChars} thinking chars` : "";
+        return `${draftRuntime.kind} \xB7 ${planner.provider}${chips}${rollup}`;
+      })()
+    },
+    { key: "events", value: `.squad/runs/${runId}.events.jsonl` },
     {
       key: "scout",
       value: scoutEnabled ? `${result.scout?.selected.length ?? 0} files \xB7 ${result.scout?.tokensUsed ?? 0} tok` : "disabled"
@@ -6583,7 +7520,19 @@ async function emitViaApi(story, paths, config2, opts) {
       key: "validation",
       value: validationEnabled ? `${issueCount} issue(s)` : "disabled"
     },
-    { key: "reads", value: `${snap.reads} files \xB7 ${(snap.bytes / 1024).toFixed(1)} KB` },
+    {
+      key: "reads",
+      value: stripAnsi2(
+        formatBudgetMeter({
+          reads: snap.reads,
+          readsCap: budgetCapsForSummary.maxFileReads,
+          bytes: snap.bytes,
+          bytesCap: budgetCapsForSummary.maxContextBytes,
+          elapsedMs,
+          durationMsCap: budgetCapsForSummary.maxDurationSeconds * 1e3
+        })
+      )
+    },
     {
       key: "tokens",
       value: `${snap.usage.inputTokens} in \xB7 ${snap.usage.outputTokens} out` + (draftRuntime.kind === "agent-sdk" ? " (agent-sdk: aggregate-only)" : "")
@@ -6608,14 +7557,19 @@ async function emitViaApi(story, paths, config2, opts) {
   ]);
   if (issueCount > 0 && validationEnabled) {
     blank();
-    warning(`Validation reported ${issueCount} issue(s) (heuristic; first 10 shown):`);
-    for (const iss of result.validation.issues.slice(0, 10)) {
-      info(
-        `  [${iss.severity}] ${iss.kind}${iss.path ? ` ${iss.path}` : ""} \u2014 ${iss.detail}`
-      );
-    }
-    if (issueCount > 10) {
-      info(`  (+${issueCount - 10} more \u2014 see metadata header issues=\u2026)`);
+    const streamed = interactive && apiUiCtx.streamedValidationIssues.count > 0;
+    if (!streamed) {
+      warning(`Validation reported ${issueCount} issue(s) (heuristic; first 10 shown):`);
+      for (const iss of result.validation.issues.slice(0, 10)) {
+        info(
+          `  [${iss.severity}] ${iss.kind}${iss.path ? ` ${iss.path}` : ""} \u2014 ${iss.detail}`
+        );
+      }
+      if (issueCount > 10) {
+        info(`  (+${issueCount - 10} more \u2014 see metadata header issues=\u2026)`);
+      }
+    } else {
+      warning(`Validation reported ${issueCount} issue(s) (details were streamed during the run).`);
     }
     if (issueCount > 50) {
       warning("Large issue count may mean the validator is misfiring; try `squad new-plan --no-validation` to compare.");
@@ -6634,14 +7588,14 @@ async function emitViaApi(story, paths, config2, opts) {
     info("Note: file-read budget was reached; the model finalised without further reads.");
   }
   blank();
-  info(`next  \u2192  open a new agent chat and attach only ${path23.basename(planFile)}`);
+  info(`next  \u2192  open a new agent chat and attach only ${path24.basename(planFile)}`);
 }
 async function emitCopyPrompt(story, paths, config2, clipboard) {
   const intakeContent = readFile(story.intakePath);
   const composed = buildCopyPlanPromptMarkdown(config2, intakeContent);
-  const promptFile = path23.join(paths.squadDir, ".last-copy-prompt.md");
-  fs31.writeFileSync(promptFile, composed, "utf8");
-  const relPromptFile = path23.relative(paths.root, promptFile);
+  const promptFile = path24.join(paths.squadDir, ".last-copy-prompt.md");
+  fs32.writeFileSync(promptFile, composed, "utf8");
+  const relPromptFile = path24.relative(paths.root, promptFile);
   const bytes = Buffer.byteLength(composed, "utf8");
   const estTokens = Math.round(bytes / 4);
   const clipResult = clipboard ? await copyToClipboard(composed) : { ok: false, reason: "clipboard disabled (--no-clipboard)" };
@@ -6699,7 +7653,7 @@ function printModelBanner(config2) {
 }
 
 // src/commands/status.ts
-import fs32 from "fs";
+import fs33 from "fs";
 var kw = 28;
 function probeTrackerCredential(config2, overlay) {
   const { client, error } = clientFor(config2, overlay);
@@ -6725,7 +7679,7 @@ async function runStatus() {
   const scan = scanPlans(paths.plansDir);
   const storyCount = listStories(paths).length;
   const planCount = scan.usedNumbers.length;
-  const secrets = fs32.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
+  const secrets = fs33.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
   const overlay = overlayTrackerEnv(secrets);
   banner();
   step("squad-kit status");
@@ -6779,13 +7733,13 @@ function buildTrackerLine(config2, overlay) {
 }
 
 // src/commands/list.ts
-import path24 from "path";
+import path25 from "path";
 async function runList(opts) {
   const root = requireSquadRoot();
   const paths = buildPaths(root);
   const records = listStories(paths, { feature: opts.feature });
   const rows = records.map((r) => {
-    const planAbs = r.planFile ? path24.join(paths.plansDir, r.feature, r.planFile) : void 0;
+    const planAbs = r.planFile ? path25.join(paths.plansDir, r.feature, r.planFile) : void 0;
     const meta = planAbs ? readPlanMetadata(planAbs) : void 0;
     return {
       feature: r.feature,
@@ -6824,8 +7778,8 @@ function stripAnsi(s) {
 }
 
 // src/commands/tracker-link.ts
-import fs33 from "fs";
-import path25 from "path";
+import fs34 from "fs";
+import path26 from "path";
 import { input as input4, select as select7 } from "@inquirer/prompts";
 async function runTrackerLink(storyPath, trackerId, opts = {}) {
   const root = requireSquadRoot();
@@ -6872,17 +7826,17 @@ async function runTrackerLink(storyPath, trackerId, opts = {}) {
       `Invalid tracker id "${resolvedTrackerId}" for tracker type "${config2.tracker.type}". Run \`squad config show\` to review the expected format, or \`squad config set tracker\` if the type is wrong.`
     );
   }
-  const resolved = path25.resolve(resolvedStoryPath);
-  const intakeFile = resolved.endsWith("intake.md") ? resolved : path25.join(resolved, "intake.md");
-  if (!fs33.existsSync(intakeFile)) {
+  const resolved = path26.resolve(resolvedStoryPath);
+  const intakeFile = resolved.endsWith("intake.md") ? resolved : path26.join(resolved, "intake.md");
+  if (!fs34.existsSync(intakeFile)) {
     throw new Error(
       `intake.md not found at ${intakeFile}. Run \`squad list\` to see valid paths, or \`squad new-story\` to create a story first.`
     );
   }
-  const content = fs33.readFileSync(intakeFile, "utf8");
+  const content = fs34.readFileSync(intakeFile, "utf8");
   const updated = upsertTrackerId(content, resolvedTrackerId);
-  fs33.writeFileSync(intakeFile, updated, "utf8");
-  success(`Linked tracker id ${resolvedTrackerId} \u2192 ${path25.relative(root, intakeFile)}`);
+  fs34.writeFileSync(intakeFile, updated, "utf8");
+  success(`Linked tracker id ${resolvedTrackerId} \u2192 ${path26.relative(root, intakeFile)}`);
   blank();
   step("Next:");
   info("1) Review the intake \u2014 the Source block at the top now carries the tracker id.");
@@ -6900,8 +7854,8 @@ function upsertTrackerId(content, id) {
 }
 
 // src/commands/doctor-engine.ts
-import fs34 from "fs";
-import path26 from "path";
+import fs35 from "fs";
+import path27 from "path";
 async function gatherContext(paths) {
   const ctx = { hasLegacyPromptsDir: false };
   try {
@@ -6910,29 +7864,29 @@ async function gatherContext(paths) {
     ctx.configError = err2;
   }
   try {
-    ctx.secrets = fs34.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
+    ctx.secrets = fs35.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
   } catch (err2) {
     ctx.secretsError = err2;
   }
-  ctx.hasLegacyPromptsDir = fs34.existsSync(paths.promptsDir);
+  ctx.hasLegacyPromptsDir = fs35.existsSync(paths.promptsDir);
   return ctx;
 }
 function gitignoreHasManagedBlock(repoRoot) {
-  const gitignore = path26.join(repoRoot, ".gitignore");
-  return fs34.existsSync(gitignore) && fs34.readFileSync(gitignore, "utf8").includes(".squad/secrets.yaml");
+  const gitignore = path27.join(repoRoot, ".gitignore");
+  return fs35.existsSync(gitignore) && fs35.readFileSync(gitignore, "utf8").includes(".squad/secrets.yaml");
 }
 function gitignoreHasTrashPattern(repoRoot) {
-  const gitignore = path26.join(repoRoot, ".gitignore");
-  return fs34.existsSync(gitignore) && fs34.readFileSync(gitignore, "utf8").includes(SQUAD_TRASH_PATTERN);
+  const gitignore = path27.join(repoRoot, ".gitignore");
+  return fs35.existsSync(gitignore) && fs35.readFileSync(gitignore, "utf8").includes(SQUAD_TRASH_PATTERN);
 }
 async function checkDirStructure(paths, _ctx, fix) {
-  const need = [paths.squadDir, paths.storiesDir, paths.plansDir].filter((p) => !fs34.existsSync(p));
+  const need = [paths.squadDir, paths.storiesDir, paths.plansDir].filter((p) => !fs35.existsSync(p));
   if (need.length === 0) {
     return { id: "dirs", name: ".squad/ directory structure", status: "ok" };
   }
   if (fix) {
     for (const p of need) {
-      fs34.mkdirSync(p, { recursive: true });
+      fs35.mkdirSync(p, { recursive: true });
     }
     return { id: "dirs", name: ".squad/ directory structure", status: "ok", detail: "repaired" };
   }
@@ -6940,7 +7894,7 @@ async function checkDirStructure(paths, _ctx, fix) {
     id: "dirs",
     name: ".squad/ directory structure",
     status: "warn",
-    detail: `missing: ${need.map((p) => path26.relative(paths.root, p)).join(", ")}`,
+    detail: `missing: ${need.map((p) => path27.relative(paths.root, p)).join(", ")}`,
     fixable: true,
     fixHint: "squad doctor --fix"
   };
@@ -6995,15 +7949,15 @@ async function checkSecretsPermissions(paths, _ctx, fix) {
   if (process.platform === "win32") {
     return { id: "secrets-perms", name: ".squad/secrets.yaml permissions", status: "skip", detail: "Windows" };
   }
-  if (!fs34.existsSync(paths.secretsFile)) {
+  if (!fs35.existsSync(paths.secretsFile)) {
     return { id: "secrets-perms", name: ".squad/secrets.yaml permissions", status: "ok", detail: "not present" };
   }
-  const mode = fs34.statSync(paths.secretsFile).mode & 511;
+  const mode = fs35.statSync(paths.secretsFile).mode & 511;
   if (mode === 384) {
     return { id: "secrets-perms", name: ".squad/secrets.yaml permissions", status: "ok" };
   }
   if (fix) {
-    fs34.chmodSync(paths.secretsFile, 384);
+    fs35.chmodSync(paths.secretsFile, 384);
     return { id: "secrets-perms", name: ".squad/secrets.yaml permissions", status: "ok", detail: "repaired" };
   }
   return {
@@ -7024,7 +7978,7 @@ async function checkSecretsParseable(_paths, ctx) {
       detail: ctx.secretsError.message
     };
   }
-  if (!fs34.existsSync(_paths.secretsFile)) {
+  if (!fs35.existsSync(_paths.secretsFile)) {
     return { id: "secrets-yaml", name: ".squad/secrets.yaml parseable", status: "ok", detail: "not present" };
   }
   return { id: "secrets-yaml", name: ".squad/secrets.yaml parseable", status: "ok" };
@@ -7578,23 +8532,23 @@ async function runDoctor(opts) {
 }
 
 // src/commands/migrate.ts
-import fs35 from "fs";
-import path27 from "path";
+import fs36 from "fs";
+import path28 from "path";
 import { confirm as confirm7 } from "@inquirer/prompts";
 var LEGACY_PROMPTS_MIGRATION = {
   id: "legacy-prompts",
   name: "Remove legacy .squad/prompts/",
-  isApplied: (paths) => !fs35.existsSync(paths.promptsDir),
-  describe: (paths) => `delete ${path27.relative(paths.root, paths.promptsDir)} (prompts are now bundled in squad-kit)`,
+  isApplied: (paths) => !fs36.existsSync(paths.promptsDir),
+  describe: (paths) => `delete ${path28.relative(paths.root, paths.promptsDir)} (prompts are now bundled in squad-kit)`,
   apply: (paths) => {
     const target = paths.promptsDir;
-    if (!target.includes(path27.sep + ".squad" + path27.sep + "prompts")) {
+    if (!target.includes(path28.sep + ".squad" + path28.sep + "prompts")) {
       throw new Error(
         `Refusing to delete suspicious path: ${target}. This is a safety check \u2014 run \`squad doctor\` if .squad/ paths look wrong.`
       );
     }
-    if (fs35.existsSync(target)) {
-      fs35.rmSync(target, { recursive: true, force: true });
+    if (fs36.existsSync(target)) {
+      fs36.rmSync(target, { recursive: true, force: true });
     }
   }
 };
@@ -7602,8 +8556,8 @@ var GITIGNORE_MIGRATION = {
   id: "gitignore",
   name: "Ensure .gitignore managed block",
   isApplied: (paths) => {
-    const f = path27.join(paths.root, ".gitignore");
-    return fs35.existsSync(f) && fs35.readFileSync(f, "utf8").includes(".squad/secrets.yaml");
+    const f = path28.join(paths.root, ".gitignore");
+    return fs36.existsSync(f) && fs36.readFileSync(f, "utf8").includes(".squad/secrets.yaml");
   },
   describe: () => "add squad-kit managed block to .gitignore",
   apply: (paths) => {
@@ -7615,23 +8569,23 @@ var SECRETS_PERMS_MIGRATION = {
   name: "Tighten .squad/secrets.yaml permissions",
   isApplied: (paths) => {
     if (process.platform === "win32") return true;
-    if (!fs35.existsSync(paths.secretsFile)) return true;
-    const st = fs35.statSync(paths.secretsFile);
+    if (!fs36.existsSync(paths.secretsFile)) return true;
+    const st = fs36.statSync(paths.secretsFile);
     return (st.mode & 511) === 384;
   },
-  describe: (paths) => `chmod 0600 ${path27.relative(paths.root, paths.secretsFile)}`,
+  describe: (paths) => `chmod 0600 ${path28.relative(paths.root, paths.secretsFile)}`,
   apply: (paths) => {
     if (process.platform === "win32") return;
-    if (fs35.existsSync(paths.secretsFile)) fs35.chmodSync(paths.secretsFile, 384);
+    if (fs36.existsSync(paths.secretsFile)) fs36.chmodSync(paths.secretsFile, 384);
   }
 };
 var PLANNER_BUDGET_DEFAULTS_MIGRATION = {
   id: "planner-budget-defaults",
   name: "Backfill planner.budget defaults in config.yaml",
   isApplied: (paths) => {
-    if (!fs35.existsSync(paths.configFile)) return true;
+    if (!fs36.existsSync(paths.configFile)) return true;
     try {
-      const raw = fs35.readFileSync(paths.configFile, "utf8");
+      const raw = fs36.readFileSync(paths.configFile, "utf8");
       if (!/^\s*planner:/m.test(raw)) return true;
       if (/^\s*budget:/m.test(raw)) return true;
       const cfg = loadConfig(paths.configFile);
@@ -7650,9 +8604,9 @@ var CONFIG_NORMALIZE_MIGRATION = {
   id: "config-normalize",
   name: "Normalise .squad/config.yaml formatting",
   isApplied: (paths) => {
-    if (!fs35.existsSync(paths.configFile)) return true;
+    if (!fs36.existsSync(paths.configFile)) return true;
     try {
-      const raw = fs35.readFileSync(paths.configFile, "utf8");
+      const raw = fs36.readFileSync(paths.configFile, "utf8");
       const cfg = loadConfig(paths.configFile);
       return raw.trim() === serializeConfig(cfg).trim();
     } catch {
@@ -7661,7 +8615,7 @@ var CONFIG_NORMALIZE_MIGRATION = {
   },
   describe: () => "rewrite config.yaml with canonical YAML formatting (drops comments)",
   apply: (paths) => {
-    if (!fs35.existsSync(paths.configFile)) return;
+    if (!fs36.existsSync(paths.configFile)) return;
     const cfg = loadConfig(paths.configFile);
     saveConfig(paths.configFile, cfg);
   }
@@ -7742,8 +8696,8 @@ import process3 from "process";
 import { confirm as confirm8 } from "@inquirer/prompts";
 
 // src/core/package-info.ts
-import fs36 from "fs";
-import path28 from "path";
+import fs37 from "fs";
+import path29 from "path";
 function changelogBlobUrl(repositoryUrl, version) {
   let base = repositoryUrl;
   if (!base) base = "https://github.com/AzmSquad/squad-kit";
@@ -7754,9 +8708,9 @@ function changelogBlobUrl(repositoryUrl, version) {
 }
 function readInstalledPackage() {
   const root = packageRoot();
-  const pkgFile = path28.join(root, "package.json");
-  const pkg = JSON.parse(fs36.readFileSync(pkgFile, "utf8"));
-  const isDevInstall = fs36.existsSync(path28.join(root, "src"));
+  const pkgFile = path29.join(root, "package.json");
+  const pkg = JSON.parse(fs37.readFileSync(pkgFile, "utf8"));
+  const isDevInstall = fs37.existsSync(path29.join(root, "src"));
   return {
     name: pkg.name,
     version: pkg.version,
@@ -7796,7 +8750,7 @@ function isNewer(a, b) {
 }
 
 // src/core/package-manager.ts
-import path29 from "path";
+import path30 from "path";
 import process2 from "process";
 function detectPackageManager(installRoot) {
   const ua = process2.env.npm_config_user_agent;
@@ -7807,11 +8761,11 @@ function detectPackageManager(installRoot) {
     if (ua.startsWith("npm/")) return { pm: "npm", reason: "npm_config_user_agent" };
   }
   const root = installRoot.toLowerCase();
-  if (root.includes(`${path29.sep}pnpm${path29.sep}`) || root.includes(`${path29.sep}.pnpm${path29.sep}`))
+  if (root.includes(`${path30.sep}pnpm${path30.sep}`) || root.includes(`${path30.sep}.pnpm${path30.sep}`))
     return { pm: "pnpm", reason: `install path contains pnpm` };
-  if (root.includes(`${path29.sep}.yarn${path29.sep}`) || root.includes(`${path29.sep}yarn${path29.sep}`))
+  if (root.includes(`${path30.sep}.yarn${path30.sep}`) || root.includes(`${path30.sep}yarn${path30.sep}`))
     return { pm: "yarn", reason: `install path contains yarn` };
-  if (root.includes(`${path29.sep}.bun${path29.sep}`) || root.includes(`${path29.sep}bun${path29.sep}`))
+  if (root.includes(`${path30.sep}.bun${path30.sep}`) || root.includes(`${path30.sep}bun${path30.sep}`))
     return { pm: "bun", reason: `install path contains bun` };
   return { pm: "npm", reason: "default fallback" };
 }
@@ -7924,14 +8878,14 @@ import { cors } from "hono/cors";
 import { secureHeaders } from "hono/secure-headers";
 
 // src/console/api/stories.ts
-import fs37 from "fs";
+import fs38 from "fs";
 import { z as z6 } from "zod";
 
 // src/utils/path-safety.ts
-import path30 from "path";
+import path31 from "path";
 function isInside(abs, parent) {
-  const a = path30.resolve(abs) + path30.sep;
-  const p = path30.resolve(parent) + path30.sep;
+  const a = path31.resolve(abs) + path31.sep;
+  const p = path31.resolve(parent) + path31.sep;
   return a.startsWith(p);
 }
 
@@ -7971,7 +8925,7 @@ function mountStoriesApi(app, opts) {
     if (!isInside(hit.intakePath, opts.paths.storiesDir)) return c.json({ error: "forbidden" }, 403);
     let intakeContent = "";
     try {
-      intakeContent = fs37.readFileSync(hit.intakePath, "utf8");
+      intakeContent = fs38.readFileSync(hit.intakePath, "utf8");
     } catch {
     }
     return c.json({
@@ -8015,7 +8969,7 @@ function mountStoriesApi(app, opts) {
     const hit = stories.find((s) => s.id === id);
     if (!hit) return c.json({ error: "not_found" }, 404);
     if (!isInside(hit.intakePath, opts.paths.storiesDir)) return c.json({ error: "forbidden" }, 403);
-    fs37.writeFileSync(hit.intakePath, body.data.intakeContent, "utf8");
+    fs38.writeFileSync(hit.intakePath, body.data.intakeContent, "utf8");
     return c.json({ ok: true });
   });
   app.delete("/api/stories/:feature/:id", (c) => {
@@ -8032,8 +8986,8 @@ function mountStoriesApi(app, opts) {
 }
 
 // src/console/api/plans.ts
-import fs38 from "fs";
-import path31 from "path";
+import fs39 from "fs";
+import path32 from "path";
 import { z as z7 } from "zod";
 import { diffLines } from "diff";
 var DiffQuery = z7.object({
@@ -8048,11 +9002,11 @@ function mountPlansApi(app, opts) {
   app.get("/api/plans", (c) => {
     const out = [];
     for (const feature of listPlanFeatureNames(opts.paths)) {
-      const featureDir = path31.join(opts.paths.plansDir, feature);
-      if (!fs38.existsSync(featureDir)) continue;
-      for (const entry of fs38.readdirSync(featureDir)) {
+      const featureDir = path32.join(opts.paths.plansDir, feature);
+      if (!fs39.existsSync(featureDir)) continue;
+      for (const entry of fs39.readdirSync(featureDir)) {
         if (!entry.endsWith(".md") || entry === "00-index.md") continue;
-        const abs = path31.join(featureDir, entry);
+        const abs = path32.join(featureDir, entry);
         out.push({ feature, planFile: entry, metadata: readPlanMetadata(abs) });
       }
     }
@@ -8061,10 +9015,10 @@ function mountPlansApi(app, opts) {
   app.get("/api/plans/:feature/:planFile", (c) => {
     const { feature, planFile } = c.req.param();
     if (!safeFeatureParam2(feature)) return c.json({ error: "forbidden" }, 403);
-    const abs = path31.resolve(path31.join(opts.paths.plansDir, feature, planFile));
+    const abs = path32.resolve(path32.join(opts.paths.plansDir, feature, planFile));
     if (!isInside(abs, opts.paths.plansDir)) return c.json({ error: "forbidden" }, 403);
-    if (!fs38.existsSync(abs)) return c.json({ error: "not_found" }, 404);
-    const content = fs38.readFileSync(abs, "utf8");
+    if (!fs39.existsSync(abs)) return c.json({ error: "not_found" }, 404);
+    const content = fs39.readFileSync(abs, "utf8");
     return c.json({
       feature,
       planFile,
@@ -8082,15 +9036,15 @@ function mountPlansApi(app, opts) {
     if (!parse.success) return c.json({ error: "invalid_query", issues: parse.error.issues }, 400);
     const { feature, a, b } = parse.data;
     if (!safeFeatureParam2(feature)) return c.json({ error: "forbidden" }, 403);
-    const featureDir = path31.join(opts.paths.plansDir, feature);
-    const aAbs = path31.join(featureDir, a);
-    const bAbs = path31.join(featureDir, b);
+    const featureDir = path32.join(opts.paths.plansDir, feature);
+    const aAbs = path32.join(featureDir, a);
+    const bAbs = path32.join(featureDir, b);
     if (!isInside(aAbs, opts.paths.plansDir) || !isInside(bAbs, opts.paths.plansDir)) {
       return c.json({ error: "forbidden" }, 403);
     }
-    if (!fs38.existsSync(aAbs) || !fs38.existsSync(bAbs)) return c.json({ error: "not_found" }, 404);
-    const aText = fs38.readFileSync(aAbs, "utf8");
-    const bText = fs38.readFileSync(bAbs, "utf8");
+    if (!fs39.existsSync(aAbs) || !fs39.existsSync(bAbs)) return c.json({ error: "not_found" }, 404);
+    const aText = fs39.readFileSync(aAbs, "utf8");
+    const bText = fs39.readFileSync(bAbs, "utf8");
     const changes = diffLines(aText, bText);
     return c.json({ feature, a, b, changes });
   });
@@ -8098,16 +9052,16 @@ function mountPlansApi(app, opts) {
     const trash = c.req.query("trash") === "1";
     const { feature, planFile } = c.req.param();
     if (!safeFeatureParam2(feature)) return c.json({ error: "forbidden" }, 403);
-    const abs = path31.join(opts.paths.plansDir, feature, planFile);
+    const abs = path32.join(opts.paths.plansDir, feature, planFile);
     if (!isInside(abs, opts.paths.plansDir)) return c.json({ error: "forbidden" }, 403);
-    if (!fs38.existsSync(abs)) return c.json({ error: "not_found" }, 404);
+    if (!fs39.existsSync(abs)) return c.json({ error: "not_found" }, 404);
     if (trash) {
       const result = trashOrDelete([abs], opts.paths.trashDir, true);
-      removeOverviewRowForPlanFile(path31.join(opts.paths.plansDir, feature), planFile);
+      removeOverviewRowForPlanFile(path32.join(opts.paths.plansDir, feature), planFile);
       return c.json({ ok: true, trashed: result.trashed });
     }
-    fs38.rmSync(abs);
-    removeOverviewRowForPlanFile(path31.join(opts.paths.plansDir, feature), planFile);
+    fs39.rmSync(abs);
+    removeOverviewRowForPlanFile(path32.join(opts.paths.plansDir, feature), planFile);
     return c.json({ ok: true });
   });
 }
@@ -8155,10 +9109,10 @@ function mountMetaApi(app, opts) {
 // src/console/api/runs.ts
 import { streamSSE } from "hono/streaming";
 import { z as z9 } from "zod";
-import path32 from "path";
-import fs39 from "fs";
+import path33 from "path";
+import fs40 from "fs";
 var active = /* @__PURE__ */ new Map();
-var EVENT_BUF_CAP = 512;
+var EVENT_BUF_CAP = 4096;
 var StartBody = z9.object({
   feature: z9.string().min(1),
   storyId: z9.string().min(1)
@@ -8269,147 +9223,189 @@ function mountRunsApi(app, opts) {
         repoMap
       });
       const userPrompt = composeUserPrompt({
-        intakeContent: fs39.readFileSync(story.intakePath, "utf8")
+        intakeContent: fs40.readFileSync(story.intakePath, "utf8")
       });
       let result;
       try {
-        result = await runPlanner({
-          root: opts.paths.root,
-          runtime: draftRuntime,
-          provider: planner.provider,
-          modelId,
-          anthropicProviderSpecific,
-          systemPrompt,
-          userPrompt,
-          budget,
-          maxOutputTokens: planner.maxOutputTokens,
-          cacheEnabled,
-          events: bus,
-          runId,
-          abort: controller.signal,
-          stages: {
+        try {
+          result = await runPlanner({
+            root: opts.paths.root,
+            runtime: draftRuntime,
+            provider: planner.provider,
+            modelId,
+            anthropicProviderSpecific,
+            systemPrompt,
+            userPrompt,
+            budget,
+            maxOutputTokens: planner.maxOutputTokens,
+            cacheEnabled,
+            events: bus,
+            runId,
+            paths: opts.paths,
+            abort: controller.signal,
+            stages: {
+              scout: {
+                enabled: scoutEnabled,
+                runtime: scoutRuntime,
+                modelId: scoutModelId,
+                maxFiles: maxScoutFiles,
+                maxOutputTokens: planner.stages?.scout?.maxOutputTokens ?? 2048
+              }
+            },
+            validation: { enabled: validationEnabled, strict: strictValidation },
+            toolsEnabled: planner.tools,
+            scoutSystemPrompt
+          });
+        } catch (err2) {
+          const durationMs = Date.now() - startedAt;
+          const last = eventBuffer[eventBuffer.length - 1];
+          const isRateLimitAbort = last?.kind === "rate_limit" && last.phase === "aborted";
+          if (!isRateLimitAbort) {
+            bus.emit({ kind: "error", runId, message: err2.message });
+          }
+          bus.emit({
+            kind: "done",
+            runId,
+            success: false,
+            planFile: null,
+            partial: true,
+            stats: emptyStats(durationMs),
+            durationMs
+          });
+          return;
+        }
+        const issueCount = result.validation?.issues.length ?? 0;
+        const issuesByKind = summariseIssuesByKind(result.validation?.issues ?? []);
+        const validationBlocks = strictValidation && validationEnabled && issueCount > 0;
+        const runSuccess = result.finishedNormally && !result.timedOut && !result.userCancelled && !validationBlocks;
+        let planFile = null;
+        if (result.planText.trim()) {
+          const snap = budget.snapshot();
+          const header = buildMetadataHeader({
+            provider: planner.provider,
+            model: modelId,
+            reads: snap.reads,
+            bytes: snap.bytes,
+            inputTokens: snap.usage.inputTokens,
+            outputTokens: snap.usage.outputTokens,
+            durationMs: Date.now() - startedAt,
+            planStatus: runSuccess ? void 0 : "partial",
+            scoutEnabled,
+            validationEnabled,
+            validationIssueCount: issueCount
+          });
+          const out = writePlanFile({
+            paths: opts.paths,
+            config: cfgFresh,
+            story,
+            planBodyMarkdown: result.planText,
+            metadataHeader: header,
+            partial: !runSuccess
+          });
+          planFile = path33.relative(opts.paths.root, out.planFile);
+        }
+        try {
+          await writeLastRun(opts.paths, {
+            stats: result.stats,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            provider: planner.provider,
+            model: modelId
+          });
+          await appendRun(opts.paths, {
+            runId,
+            provider: planner.provider,
+            model: modelId,
+            feature: story.feature,
+            storyId: story.id,
+            startedAt: new Date(startedAt).toISOString(),
+            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            success: runSuccess,
+            partial: !runSuccess,
+            planFile,
+            stats: result.stats,
+            cacheEnabled,
+            durationMs: Date.now() - startedAt,
             scout: {
               enabled: scoutEnabled,
-              runtime: scoutRuntime,
-              modelId: scoutModelId,
-              maxFiles: maxScoutFiles,
-              maxOutputTokens: planner.stages?.scout?.maxOutputTokens ?? 2048
-            }
-          },
-          validation: { enabled: validationEnabled, strict: strictValidation },
-          toolsEnabled: planner.tools,
-          scoutSystemPrompt
-        });
-      } catch (err2) {
-        const durationMs = Date.now() - startedAt;
-        const last = eventBuffer[eventBuffer.length - 1];
-        const isRateLimitAbort = last?.kind === "rate_limit" && last.phase === "aborted";
-        if (!isRateLimitAbort) {
-          bus.emit({ kind: "error", runId, message: err2.message });
+              selectedCount: result.scout?.selected.length,
+              tokensUsed: result.scout?.tokensUsed,
+              durationMs: result.scout?.durationMs
+            },
+            validation: {
+              enabled: validationEnabled,
+              issuesCount: issueCount,
+              issuesByKind,
+              durationMs: result.validation?.durationMs
+            },
+            plannerRuntime: { kind: draftRuntime.kind, provider: planner.provider },
+            providerOptionsSnapshot: anthropicProviderSpecific ? { anthropic: anthropicProviderSpecific } : void 0
+          });
+        } catch {
         }
         bus.emit({
           kind: "done",
           runId,
-          success: false,
-          planFile: null,
-          partial: true,
-          stats: emptyStats(durationMs),
-          durationMs
-        });
-        return;
-      }
-      const issueCount = result.validation?.issues.length ?? 0;
-      const issuesByKind = summariseIssuesByKind(result.validation?.issues ?? []);
-      const validationBlocks = strictValidation && validationEnabled && issueCount > 0;
-      const runSuccess = result.finishedNormally && !result.timedOut && !result.userCancelled && !validationBlocks;
-      let planFile = null;
-      if (result.planText.trim()) {
-        const snap = budget.snapshot();
-        const header = buildMetadataHeader({
-          provider: planner.provider,
-          model: modelId,
-          reads: snap.reads,
-          bytes: snap.bytes,
-          inputTokens: snap.usage.inputTokens,
-          outputTokens: snap.usage.outputTokens,
-          durationMs: Date.now() - startedAt,
-          planStatus: runSuccess ? void 0 : "partial",
-          scoutEnabled,
-          validationEnabled,
-          validationIssueCount: issueCount
-        });
-        const out = writePlanFile({
-          paths: opts.paths,
-          config: cfgFresh,
-          story,
-          planBodyMarkdown: result.planText,
-          metadataHeader: header,
-          partial: !runSuccess
-        });
-        planFile = path32.relative(opts.paths.root, out.planFile);
-      }
-      try {
-        await writeLastRun(opts.paths, {
-          stats: result.stats,
-          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          provider: planner.provider,
-          model: modelId
-        });
-        await appendRun(opts.paths, {
-          runId,
-          provider: planner.provider,
-          model: modelId,
-          feature: story.feature,
-          storyId: story.id,
-          startedAt: new Date(startedAt).toISOString(),
-          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
           success: runSuccess,
-          partial: !runSuccess,
           planFile,
+          partial: !runSuccess,
           stats: result.stats,
-          cacheEnabled,
-          durationMs: Date.now() - startedAt,
-          scout: {
-            enabled: scoutEnabled,
-            selectedCount: result.scout?.selected.length,
-            tokensUsed: result.scout?.tokensUsed,
-            durationMs: result.scout?.durationMs
-          },
-          validation: {
-            enabled: validationEnabled,
-            issuesCount: issueCount,
-            issuesByKind,
-            durationMs: result.validation?.durationMs
-          },
-          plannerRuntime: { kind: draftRuntime.kind, provider: planner.provider },
-          providerOptionsSnapshot: anthropicProviderSpecific ? { anthropic: anthropicProviderSpecific } : void 0
+          durationMs: Date.now() - startedAt
         });
-      } catch {
+      } finally {
+        await bus.finalizeEventPersistence?.();
       }
-      bus.emit({
-        kind: "done",
-        runId,
-        success: runSuccess,
-        planFile,
-        partial: !runSuccess,
-        stats: result.stats,
-        durationMs: Date.now() - startedAt
-      });
     })().finally(() => {
       active.delete(runId);
     });
     active.set(runId, { runId, bus, controller, feature: story.feature, storyId: story.id, startedAt, done, eventBuffer });
     return c.json({ runId, eventStream: `/api/runs/${runId}/stream` }, 202);
   });
+  app.get("/api/runs/:runId/events", async (c) => {
+    const runId = c.req.param("runId");
+    const fromQ = Number(c.req.query("from") ?? 0);
+    const fromIndex = Number.isFinite(fromQ) ? Math.max(0, Math.floor(fromQ)) : 0;
+    const limQ = Number(c.req.query("limit") ?? 1e3);
+    const limit = Math.min(
+      2e3,
+      Math.max(1, Number.isFinite(limQ) ? Math.floor(limQ) : 1e3)
+    );
+    const reader = await openRunEventsReader(opts.paths, runId);
+    if (!reader) return c.json({ error: "not_found" }, 404);
+    const events = [];
+    for await (const e of reader.iterate({ fromIndex, limit })) events.push(e);
+    const total = await reader.count();
+    return c.json({ runId, fromIndex, limit, total, events });
+  });
+  app.get("/api/runs/:runId", async (c) => {
+    const runId = c.req.param("runId");
+    const all = await listRuns(opts.paths);
+    const rec = all.find((r) => r.runId === runId);
+    if (!rec) return c.json({ error: "not_found" }, 404);
+    return c.json(rec);
+  });
   app.get("/api/runs/:runId/stream", (c) => {
     const runId = c.req.param("runId");
     const run = active.get(runId);
+    if (!run) {
+      return streamSSE(c, async (stream) => {
+        const reader = await openRunEventsReader(opts.paths, runId);
+        if (!reader) {
+          await stream.writeSSE({ event: "error", data: JSON.stringify({ message: "unknown run" }) });
+          await stream.writeSSE({ event: "closed", data: "{}" });
+          return;
+        }
+        try {
+          for await (const e of reader.iterate()) {
+            await stream.writeSSE({ event: e.kind, data: JSON.stringify(e) });
+          }
+          await stream.writeSSE({ event: "closed", data: "{}" });
+        } catch {
+          await stream.writeSSE({ event: "error", data: JSON.stringify({ message: "replay_failed" }) });
+          await stream.writeSSE({ event: "closed", data: "{}" });
+        }
+      });
+    }
     return streamSSE(c, async (stream) => {
-      if (!run) {
-        await stream.writeSSE({ event: "error", data: JSON.stringify({ message: "unknown run" }) });
-        await stream.writeSSE({ event: "closed", data: "{}" });
-        return;
-      }
       let idx = 0;
       let resolveWaiter = null;
       const notify = () => resolveWaiter?.();
@@ -8698,17 +9694,17 @@ function countStories(stories) {
 }
 
 // src/console/api/projects.ts
-import fs40 from "fs/promises";
-import path33 from "path";
+import fs41 from "fs/promises";
+import path34 from "path";
 import os from "os";
 var MAX = 10;
 function recentFilePath() {
-  return path33.join(os.homedir(), ".squad", "recent-projects.json");
+  return path34.join(os.homedir(), ".squad", "recent-projects.json");
 }
 async function loadRecent() {
   const RECENT_FILE = recentFilePath();
   try {
-    const raw = await fs40.readFile(RECENT_FILE, "utf8");
+    const raw = await fs41.readFile(RECENT_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.slice(0, MAX) : [];
   } catch {
@@ -8717,8 +9713,8 @@ async function loadRecent() {
 }
 async function saveRecent(list) {
   const RECENT_FILE = recentFilePath();
-  await fs40.mkdir(path33.dirname(RECENT_FILE), { recursive: true });
-  await fs40.writeFile(RECENT_FILE, JSON.stringify(list.slice(0, MAX), null, 2) + "\n", "utf8");
+  await fs41.mkdir(path34.dirname(RECENT_FILE), { recursive: true });
+  await fs41.writeFile(RECENT_FILE, JSON.stringify(list.slice(0, MAX), null, 2) + "\n", "utf8");
 }
 function mountProjectsApi(app, opts) {
   app.get("/api/projects/recent", async (c) => c.json(await loadRecent()));
@@ -8747,8 +9743,8 @@ function mountApi(app, opts) {
 }
 
 // src/console/static-assets.ts
-import fs41 from "fs";
-import path34 from "path";
+import fs42 from "fs";
+import path35 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Readable } from "stream";
 function pathnameForStatic(c) {
@@ -8778,18 +9774,18 @@ function mountStaticAssets(app, _opts) {
     }
     if (c.req.path.startsWith("/api/") || c.req.path.startsWith("/healthz")) return c.notFound();
     if (!distDir) return c.text("UI not built. Run `pnpm -C console-ui build`.", 404);
-    const indexHtml = path34.join(distDir, "index.html");
-    if (!fs41.existsSync(indexHtml)) return c.text("UI not built", 404);
-    return c.html(fs41.readFileSync(indexHtml, "utf8"), 200, { "cache-control": "no-store" });
+    const indexHtml = path35.join(distDir, "index.html");
+    if (!fs42.existsSync(indexHtml)) return c.text("UI not built", 404);
+    return c.html(fs42.readFileSync(indexHtml, "utf8"), 200, { "cache-control": "no-store" });
   });
 }
 function assetResponse(c, distDir, pathname) {
   if (!distDir) return c.text("UI not built", 404);
   const rel = pathname.replace(/^\//, "");
-  const abs = path34.normalize(path34.join(distDir, rel));
+  const abs = path35.normalize(path35.join(distDir, rel));
   if (!isInside2(abs, distDir)) return c.text("forbidden", 403);
-  if (!fs41.existsSync(abs) || !fs41.statSync(abs).isFile()) return c.text("not found", 404);
-  const body = Readable.toWeb(fs41.createReadStream(abs));
+  if (!fs42.existsSync(abs) || !fs42.statSync(abs).isFile()) return c.text("not found", 404);
+  const body = Readable.toWeb(fs42.createReadStream(abs));
   return new Response(body, {
     headers: {
       "content-type": contentTypeFor(abs),
@@ -8799,9 +9795,9 @@ function assetResponse(c, distDir, pathname) {
 }
 function serveFile(c, distDir, name, ct) {
   if (!distDir) return c.text("UI not built", 404);
-  const abs = path34.join(distDir, name);
-  if (!fs41.existsSync(abs)) return c.text("not found", 404);
-  return new Response(fs41.readFileSync(abs), {
+  const abs = path35.join(distDir, name);
+  if (!fs42.existsSync(abs)) return c.text("not found", 404);
+  return new Response(fs42.readFileSync(abs), {
     headers: { "content-type": ct, "cache-control": "public, max-age=86400" }
   });
 }
@@ -8816,13 +9812,13 @@ function contentTypeFor(p) {
   return "application/octet-stream";
 }
 function isInside2(abs, parent) {
-  const a = path34.resolve(abs) + path34.sep;
-  const p = path34.resolve(parent) + path34.sep;
+  const a = path35.resolve(abs) + path35.sep;
+  const p = path35.resolve(parent) + path35.sep;
   return a.startsWith(p);
 }
 function resolveConsoleUiDist() {
   const fromEnv = process.env.SQUAD_CONSOLE_UI_DIST;
-  if (fromEnv && fs41.existsSync(path34.join(fromEnv, "index.html"))) return fromEnv;
+  if (fromEnv && fs42.existsSync(path35.join(fromEnv, "index.html"))) return fromEnv;
   const candidates = [
     fileURLToPath2(new URL("./console-ui/", import.meta.url)),
     // dist/cli.js → dist/console-ui/
@@ -8834,7 +9830,7 @@ function resolveConsoleUiDist() {
     // src/console/*.ts → project/console-ui/dist
   ];
   for (const c of candidates) {
-    if (fs41.existsSync(path34.join(c, "index.html"))) return c;
+    if (fs42.existsSync(path35.join(c, "index.html"))) return c;
   }
   return null;
 }
@@ -9016,18 +10012,18 @@ async function runConsole(opts) {
 }
 
 // src/commands/rm/story.ts
-import fs43 from "fs";
-import path36 from "path";
+import fs44 from "fs";
+import path37 from "path";
 import { confirm as confirm10 } from "@inquirer/prompts";
 
 // src/commands/rm/feature.ts
-import fs42 from "fs";
-import path35 from "path";
+import fs43 from "fs";
+import path36 from "path";
 import { confirm as confirm9 } from "@inquirer/prompts";
 function countStoryDirs(storiesDir, feature) {
-  const d = path35.join(storiesDir, feature);
-  if (!fs42.existsSync(d)) return 0;
-  return fs42.readdirSync(d, { withFileTypes: true }).filter((x) => x.isDirectory()).length;
+  const d = path36.join(storiesDir, feature);
+  if (!fs43.existsSync(d)) return 0;
+  return fs43.readdirSync(d, { withFileTypes: true }).filter((x) => x.isDirectory()).length;
 }
 async function runRmFeature(featureSlug, opts = {}) {
   const root = requireSquadRoot();
@@ -9061,17 +10057,17 @@ async function runRmFeature(featureSlug, opts = {}) {
       feature = await pickFeatureInteractive(paths);
     }
   }
-  const storyDir = path35.join(paths.storiesDir, feature);
-  const planDir = path35.join(paths.plansDir, feature);
+  const storyDir = path36.join(paths.storiesDir, feature);
+  const planDir = path36.join(paths.plansDir, feature);
   const nStories = countStoryDirs(paths.storiesDir, feature);
   const nPlans = listAllPlanListEntries(paths, feature).length;
-  const hasOverview = fs42.existsSync(path35.join(planDir, "00-overview.md")) ? 1 : 0;
+  const hasOverview = fs43.existsSync(path36.join(planDir, "00-overview.md")) ? 1 : 0;
   const targets = [];
-  if (fs42.existsSync(storyDir)) {
-    targets.push({ label: path35.relative(root, storyDir), absPath: storyDir, kind: "dir" });
+  if (fs43.existsSync(storyDir)) {
+    targets.push({ label: path36.relative(root, storyDir), absPath: storyDir, kind: "dir" });
   }
-  if (fs42.existsSync(planDir)) {
-    targets.push({ label: path35.relative(root, planDir), absPath: planDir, kind: "dir" });
+  if (fs43.existsSync(planDir)) {
+    targets.push({ label: path36.relative(root, planDir), absPath: planDir, kind: "dir" });
   }
   divider("squad rm feature");
   info(`Feature:  ${feature}`);
@@ -9086,7 +10082,7 @@ async function runRmFeature(featureSlug, opts = {}) {
     kv(t.kind, t.label, 6);
   }
   if (useTrash) {
-    info(`Items will move to ${path35.relative(process.cwd(), paths.trashDir)}/<timestamp>/`);
+    info(`Items will move to ${path36.relative(process.cwd(), paths.trashDir)}/<timestamp>/`);
   } else if (!dryRun) {
     warning("This is a permanent delete. Pass --trash to move to .squad/.trash/ instead.");
   }
@@ -9119,7 +10115,7 @@ async function runRmFeature(featureSlug, opts = {}) {
     useTrash
   );
   if (result.trashed) {
-    success(`Feature removed. Items moved to ${path35.relative(root, result.trashed)}.`);
+    success(`Feature removed. Items moved to ${path36.relative(root, result.trashed)}.`);
   } else {
     success("Feature removed (stories and plans directories).");
   }
@@ -9160,11 +10156,11 @@ async function runRmStory(storyPathOrId, opts = {}) {
     }
   }
   const targets = [
-    { label: path36.relative(root, story.storyDir), absPath: story.storyDir, kind: "dir" }
+    { label: path37.relative(root, story.storyDir), absPath: story.storyDir, kind: "dir" }
   ];
   if (story.planFile) {
-    const planAbs = path36.join(paths.plansDir, story.feature, story.planFile);
-    targets.push({ label: path36.relative(root, planAbs), absPath: planAbs, kind: "file" });
+    const planAbs = path37.join(paths.plansDir, story.feature, story.planFile);
+    targets.push({ label: path37.relative(root, planAbs), absPath: planAbs, kind: "file" });
   }
   renderPreview("story", targets, {
     dryRun,
@@ -9189,14 +10185,14 @@ async function runRmStory(storyPathOrId, opts = {}) {
   }
   const result = deleteStoryRecord({ paths, story, trash: useTrash });
   if (result.trashed) {
-    success(`Removed (moved to ${path36.relative(root, result.trashed)}).`);
+    success(`Removed (moved to ${path37.relative(root, result.trashed)}).`);
   } else {
     success("Removed story folder, plan file (if any), and overview row.");
   }
-  const featurePlanDir = path36.join(paths.plansDir, story.feature);
-  const overviewPath = path36.join(featurePlanDir, "00-overview.md");
-  if (fs43.existsSync(overviewPath)) {
-    const body = fs43.readFileSync(overviewPath, "utf8");
+  const featurePlanDir = path37.join(paths.plansDir, story.feature);
+  const overviewPath = path37.join(featurePlanDir, "00-overview.md");
+  if (fs44.existsSync(overviewPath)) {
+    const body = fs44.readFileSync(overviewPath, "utf8");
     const onlyShell = countOverviewDataRows(body) === 0;
     if (onlyShell && featureStoriesDirEmpty(paths, story.feature)) {
       if (canPrompt) {
@@ -9216,7 +10212,7 @@ async function runRmStory(storyPathOrId, opts = {}) {
 }
 
 // src/commands/rm/plan.ts
-import path37 from "path";
+import path38 from "path";
 import { confirm as confirm11 } from "@inquirer/prompts";
 async function runRmPlan(planPathOrSequence, opts = {}) {
   const root = requireSquadRoot();
@@ -9252,7 +10248,7 @@ async function runRmPlan(planPathOrSequence, opts = {}) {
   }
   const storyRows = listStories(paths, { feature: plan.feature });
   const linked = storyRows.find((s) => s.planFile === plan.file);
-  const targets = [{ label: path37.relative(root, plan.abs), absPath: plan.abs, kind: "file" }];
+  const targets = [{ label: path38.relative(root, plan.abs), absPath: plan.abs, kind: "file" }];
   renderPreview("plan", targets, {
     dryRun,
     trash: useTrash,
@@ -9275,8 +10271,8 @@ async function runRmPlan(planPathOrSequence, opts = {}) {
     }
   }
   trashOrDelete([plan.abs], paths.trashDir, useTrash);
-  removeOverviewRowForPlanFile(path37.join(paths.plansDir, plan.feature), plan.file);
-  const intakeHint = linked ? path37.relative(root, linked.intakePath) : `under .squad/stories/${plan.feature}/`;
+  removeOverviewRowForPlanFile(path38.join(paths.plansDir, plan.feature), plan.file);
+  const intakeHint = linked ? path38.relative(root, linked.intakePath) : `under .squad/stories/${plan.feature}/`;
   success(`Plan removed. Run \`squad new-plan ${intakeHint}\` to regenerate.`);
 }