@wrongstack/core 0.283.1 → 0.284.1

package/dist/coordination/index.js

@@ -1,28 +1,29 @@
 import { randomUUID, createHash, randomBytes } from 'crypto';
-import * as fsp7 from 'fs/promises';
-import * as path10 from 'path';
+import * as fsp9 from 'fs/promises';
+import * as path9 from 'path';
 import { isAbsolute, resolve } from 'path';
 import * as os from 'os';
 import { hostname } from 'os';
-import { readFileSync, statSync, createReadStream } from 'fs';
+import { readFileSync, statSync, createReadStream, openSync, writeSync, fsyncSync, closeSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { EventEmitter } from 'events';
+import { listReadyTasks, claimReadyTask, updateTaskAssignment } from '@wrongstack/kanban';
 import { createInterface } from 'readline';
-import { execFileSync } from 'child_process';
+import { execFileSync, spawn } from 'child_process';
 
 // src/coordination/agent-bridge.ts
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path10.dirname(targetPath);
-  await fsp7.mkdir(dir, { recursive: true });
-  const tmp = path10.join(dir, `.${path10.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const dir = path9.dirname(targetPath);
+  await fsp9.mkdir(dir, { recursive: true });
+  const tmp = path9.join(dir, `.${path9.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fsp7.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fsp9.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fsp7.writeFile(tmp, content, { flag: "wx" });
+      await fsp9.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fsp7.open(tmp, "r+");
+      const fh = await fsp9.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -32,56 +33,56 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat8 = await fsp7.stat(targetPath);
-      mode = stat8.mode & 511;
+      const stat9 = await fsp9.stat(targetPath);
+      mode = stat9.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fsp7.chmod(tmp, mode);
+      await fsp9.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
     if (mode !== void 0 && process.platform === "win32") {
       try {
-        await fsp7.chmod(targetPath, mode);
+        await fsp9.chmod(targetPath, mode);
       } catch {
       }
     }
   } catch (err) {
     try {
-      await fsp7.unlink(tmp);
+      await fsp9.unlink(tmp);
     } catch {
     }
     throw err;
   }
 }
 async function ensureDir(dir) {
-  await fsp7.mkdir(dir, { recursive: true });
+  await fsp9.mkdir(dir, { recursive: true });
 }
 async function withFileLock(targetPath, fn, opts = {}) {
-  const dir = path10.dirname(targetPath);
-  await fsp7.mkdir(dir, { recursive: true });
-  const lockPath = path10.join(dir, `.${path10.basename(targetPath)}.lock`);
+  const dir = path9.dirname(targetPath);
+  await fsp9.mkdir(dir, { recursive: true });
+  const lockPath = path9.join(dir, `.${path9.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 5e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
   let handle;
   for (; ; ) {
     try {
-      handle = await fsp7.open(lockPath, "wx");
+      handle = await fsp9.open(lockPath, "wx");
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
-        await fsp7.mkdir(dir, { recursive: true });
+        await fsp9.mkdir(dir, { recursive: true });
         continue;
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat8 = await fsp7.stat(lockPath);
-        if (Date.now() - stat8.mtimeMs > staleMs) {
-          await fsp7.unlink(lockPath);
+        const stat9 = await fsp9.stat(lockPath);
+        if (Date.now() - stat9.mtimeMs > staleMs) {
+          await fsp9.unlink(lockPath);
           continue;
         }
       } catch {
@@ -95,7 +96,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
           context: { timeoutMs }
         });
       }
-      await new Promise((resolve7) => setTimeout(resolve7, 25));
+      await new Promise((resolve9) => setTimeout(resolve9, 25));
     }
   }
   try {
@@ -106,7 +107,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
     } catch {
     }
     try {
-      await fsp7.unlink(lockPath);
+      await fsp9.unlink(lockPath);
     } catch {
     }
   }
@@ -114,14 +115,14 @@ async function withFileLock(targetPath, fn, opts = {}) {
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
-    await fsp7.rename(from, to);
+    await fsp9.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fsp7.rename(from, to);
+      await fsp9.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -129,12 +130,132 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve7) => setTimeout(resolve7, delays[i]));
+      await new Promise((resolve9) => setTimeout(resolve9, delays[i]));
     }
   }
   throw lastErr;
 }
 
+// src/utils/child-env.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "USERNAME",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "TZ",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "PWD",
+  "OLDPWD",
+  "COMSPEC",
+  "SYSTEMROOT",
+  "SYSTEMDRIVE",
+  "WINDIR",
+  "PROGRAMFILES",
+  "PROGRAMFILES(X86)",
+  "PROGRAMDATA",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "USERPROFILE",
+  "PUBLIC",
+  "PATHEXT"
+]);
+var SECRET_NAME_PARTS = [
+  "TOKEN",
+  "SECRET",
+  "PASSWORD",
+  "PASSWD",
+  "AUTH",
+  "CRED",
+  "BEARER",
+  "COOKIE",
+  "PRIVATE"
+];
+function looksSecret(name) {
+  const upper = name.toUpperCase();
+  for (const p of SECRET_NAME_PARTS) {
+    if (upper.includes(p)) return true;
+  }
+  if (/(?:^|_)KEY(?:$|_|S$)/i.test(upper)) return true;
+  if (/API[_-]?KEY/i.test(upper)) return true;
+  if (/ACCESS[_-]?KEY/i.test(upper)) return true;
+  if (/SESSION[_-]?ID/i.test(upper) === false && /SESSION/i.test(upper)) {
+    return true;
+  }
+  return false;
+}
+function valueHasEmbeddedCredential(value) {
+  return /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]*:[^/\s@]+@/i.test(value);
+}
+var NODE_OPTIONS_INJECTION_FLAG = /^(?:--require|-r|--import|--loader|--experimental-loader)$/;
+var NODE_OPTIONS_INJECTION_FLAG_EQ = /^(?:--require|-r|--import|--loader|--experimental-loader)=/;
+function sanitizeNodeOptions(value) {
+  const tokens = value.split(/\s+/).filter(Boolean);
+  const kept = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (NODE_OPTIONS_INJECTION_FLAG_EQ.test(tok)) continue;
+    if (NODE_OPTIONS_INJECTION_FLAG.test(tok)) {
+      i++;
+      continue;
+    }
+    kept.push(tok);
+  }
+  return kept.join(" ");
+}
+function buildChildEnv(optsOrSessionId) {
+  const opts = {};
+  const hasOwn = Object.hasOwn(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
+  const legacyHasOwn = Object.hasOwn(process.env, "WRONGSTACK_BASH_ENV_PASSTHROUGH");
+  const passthrough = hasOwn && process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || legacyHasOwn && process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
+  if (passthrough && !process.env["CI"]) {
+    console.warn(
+      "[agent] WARNING: WRONGSTACK_*_ENV_PASSTHROUGH=1 is active \u2014\n  all parent env vars (including API keys) forwarded to child processes.\n  Do not use on shared or multi-tenant systems."
+    );
+  }
+  const out = {};
+  const nodeEnvDefaulted = process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] === "1";
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0) continue;
+    if (nodeEnvDefaulted && (k === "NODE_ENV" || k === "WRONGSTACK_NODE_ENV_DEFAULTED")) continue;
+    if (passthrough) {
+      out[k] = v;
+      continue;
+    }
+    const upper = k.toUpperCase();
+    if (valueHasEmbeddedCredential(v)) continue;
+    if (ALLOWED_KEYS.has(upper)) {
+      out[k] = v;
+      continue;
+    }
+    if (looksSecret(upper)) continue;
+    if (upper === "NODE_OPTIONS") {
+      const sanitized = sanitizeNodeOptions(v);
+      if (sanitized) out[k] = sanitized;
+      continue;
+    }
+    if (upper.startsWith("NODE_") || upper.startsWith("NPM_") || upper.startsWith("PNPM_") || upper.startsWith("YARN_") || upper.startsWith("GIT_") || upper.startsWith("CI") || upper.startsWith("XDG_") || // Our own non-secret knobs (WRONGSTACK_HOME, WRONGSTACK_SESSION_ID, …).
+    // Secrets never live in WRONGSTACK_* env vars (they're in the encrypted
+    // vault). Forwarding keeps child wstack processes — e.g. ones spawned
+    // by the test suite — inside the same redirected global root.
+    upper.startsWith("WRONGSTACK_") || upper === "EDITOR" || upper === "VISUAL" || upper === "PAGER") {
+      out[k] = v;
+    }
+  }
+  if (opts.extra) {
+    Object.assign(out, opts.extra);
+  }
+  if (opts.sessionId) out["WRONGSTACK_SESSION_ID"] = opts.sessionId;
+  return out;
+}
+
 // src/utils/error.ts
 function toErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -214,7 +335,7 @@ async function expandGlob(pattern) {
   async function walk(dir, pat) {
     let entries;
     try {
-      entries = await fsp7.readdir(dir);
+      entries = await fsp9.readdir(dir);
     } catch {
       return;
     }
@@ -236,8 +357,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat8 = await fsp7.stat(full);
-          if (stat8.isDirectory()) await walk(full, rest);
+          const stat9 = await fsp9.stat(full);
+          if (stat9.isDirectory()) await walk(full, rest);
         } catch {
         }
       }
@@ -254,8 +375,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat8 = await fsp7.stat(full);
-          if (stat8.isDirectory()) await walk(full, rest);
+          const stat9 = await fsp9.stat(full);
+          if (stat9.isDirectory()) await walk(full, rest);
         } catch {
         }
       }
@@ -396,9 +517,9 @@ function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path10.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path10.relative(path10.resolve(dir), resolved);
-  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
+  const resolved = path9.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path9.relative(path9.resolve(dir), resolved);
+  if (rel.startsWith("..") || path9.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
@@ -442,8 +563,8 @@ function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 function projectSlug(absRoot) {
-  const base = slugify(path10.basename(absRoot));
-  const hash = createHash("sha256").update(path10.resolve(absRoot)).digest("hex").slice(0, 6);
+  const base = slugify(path9.basename(absRoot));
+  const hash = createHash("sha256").update(path9.resolve(absRoot)).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify(name) {
@@ -451,8 +572,8 @@ function slugify(name) {
 }
 function wstackGlobalRoot() {
   const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path10.resolve(fromEnv);
-  return path10.join(os.homedir(), ".wrongstack");
+  if (fromEnv && fromEnv.trim().length > 0) return path9.resolve(fromEnv);
+  return path9.join(os.homedir(), ".wrongstack");
 }
 
 // src/types/errors.ts
@@ -464,6 +585,7 @@ var ERROR_CODES = {
   PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
   PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
   PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
   // Agent
   AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
   AGENT_ABORTED: "AGENT_ABORTED",
@@ -632,7 +754,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve9, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -651,7 +773,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve7,
+        resolve: resolve9,
         reject,
         timer
       });
@@ -1000,13 +1122,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve7(d);
+        resolve9(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -1141,6 +1263,152 @@ var SubagentBudget = class _SubagentBudget {
   }
 };
 
+// src/security/capabilities.ts
+var ToolCapabilities = {
+  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
+  SHELL_ARBITRARY: "shell.arbitrary",
+  /** Can execute a restricted set of commands (the `exec` tool). */
+  SHELL_RESTRICTED: "shell.restricted",
+  /** Can run a restricted project formatter/linter-style command. */
+  SHELL_EXEC: "shell.exec",
+  /** Can write / modify / delete files inside the project. */
+  FS_WRITE: "fs.write",
+  /** Can write files outside the current project root (very high risk). */
+  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Can spawn or manage subagents / multi-agent tasks. */
+  SUBAGENT_SPAWN: "subagent.spawn",
+  /** Can inspect fleet/subagent coordination state without mutating it. */
+  COORDINATION_FLEET_READ: "coordination.fleet.read",
+  /** Can publish attributed, schema-checked events onto the fleet bus. */
+  COORDINATION_FLEET_EMIT: "coordination.fleet.emit",
+  /** Can submit a task-local structured result to the parent Director. */
+  COORDINATION_RESULT_SUBMIT: "coordination.result.submit",
+  /** Can read or write inter-agent mailbox messages. */
+  COORDINATION_MAIL: "coordination.mail",
+  /** Can install packages or run package managers with side effects. */
+  PACKAGE_INSTALL: "package.install"
+};
+
+// src/coordination/subagent-result-tool.ts
+var SUBAGENT_STRUCTURED_REPORT_META_KEY = "subagentStructuredReport";
+var MAX_SUBAGENT_STRUCTURED_REPORT_CHARS = 8e3;
+var MAX_SUMMARY_CHARS = 1500;
+var MAX_FINDINGS = 16;
+var MAX_FILES = 64;
+var MAX_NEXT_STEPS = 12;
+var MAX_ITEM_CHARS = 500;
+function normalizeSubagentStructuredReport(value) {
+  if (!isRecord(value)) return void 0;
+  const summary = nonEmptyString(value["summary"]);
+  const findings = stringArray(value["findings"]);
+  const filesExamined = stringArray(value["files_examined"]);
+  const nextSteps = stringArray(value["suggested_next_steps"]);
+  const confidence = value["confidence"];
+  if (!summary || summary.length > MAX_SUMMARY_CHARS || !findings || findings.length > MAX_FINDINGS || !filesExamined || filesExamined.length > MAX_FILES || !nextSteps || nextSteps.length > MAX_NEXT_STEPS || [...findings, ...filesExamined, ...nextSteps].some(
+    (item) => item.trim().length > MAX_ITEM_CHARS
+  ) || typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+    return void 0;
+  }
+  const report = {
+    summary,
+    findings: findings.map((item) => item.trim()).filter(Boolean),
+    files_examined: filesExamined.map((item) => item.trim()).filter(Boolean),
+    confidence,
+    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean)
+  };
+  return JSON.stringify(report).length <= MAX_SUBAGENT_STRUCTURED_REPORT_CHARS ? report : void 0;
+}
+function readSubagentStructuredReport(ctx) {
+  return normalizeSubagentStructuredReport(ctx?.meta?.[SUBAGENT_STRUCTURED_REPORT_META_KEY]);
+}
+function formatSubagentStructuredReport(report) {
+  const findings = report.findings.length ? report.findings.map((item) => `- ${item}`).join("\n") : "- (none)";
+  const files = report.files_examined.length ? report.files_examined.join(", ") : "(none)";
+  const next = report.suggested_next_steps.length ? report.suggested_next_steps.map((item) => `- ${item}`).join("\n") : "- (none)";
+  return [
+    report.summary,
+    `
+Findings:
+${findings}`,
+    `
+Files examined: ${files}`,
+    `Confidence: ${report.confidence.toFixed(2)}`,
+    `
+Suggested next steps:
+${next}`
+  ].join("\n");
+}
+function makeSubagentResultTool() {
+  return {
+    name: "submit_result",
+    description: "Submit the task result as a compact structured report for the Director. Call once near the end, before your final text response.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_RESULT_SUBMIT],
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          maxLength: MAX_SUMMARY_CHARS,
+          description: "Concise outcome summary."
+        },
+        findings: {
+          type: "array",
+          maxItems: MAX_FINDINGS,
+          items: { type: "string" },
+          description: "Atomic findings or changes, with evidence when useful."
+        },
+        files_examined: {
+          type: "array",
+          maxItems: MAX_FILES,
+          items: { type: "string" },
+          description: "Project-relative files materially read or changed."
+        },
+        confidence: {
+          type: "number",
+          minimum: 0,
+          maximum: 1,
+          description: "Confidence from 0.0 to 1.0."
+        },
+        suggested_next_steps: {
+          type: "array",
+          maxItems: MAX_NEXT_STEPS,
+          items: { type: "string" },
+          description: "Concrete follow-ups; use an empty array when none remain."
+        }
+      },
+      required: ["summary", "findings", "files_examined", "confidence", "suggested_next_steps"],
+      additionalProperties: false
+    },
+    async execute(input, ctx) {
+      const report = normalizeSubagentStructuredReport(input);
+      if (!report) {
+        return {
+          ok: false,
+          error: "Invalid report: summary/findings/files_examined/confidence/suggested_next_steps are required and confidence must be 0..1."
+        };
+      }
+      ctx.meta[SUBAGENT_STRUCTURED_REPORT_META_KEY] = report;
+      return {
+        ok: true,
+        findings: report.findings.length,
+        filesExamined: report.files_examined.length,
+        confidence: report.confidence
+      };
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+
 // src/coordination/agent-subagent-runner.ts
 function withDisabledToolFiltering(factory) {
   return async (config) => {
@@ -1162,6 +1430,8 @@ function makeAgentSubagentRunner(opts) {
     const taskStartedAt = Date.now();
     const factoryResult = await opts.factory(ctx.config);
     const { agent, events } = factoryResult;
+    const agentContext = agent.ctx;
+    if (agentContext?.meta) agentContext.meta["subagentTaskId"] = task.id;
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
@@ -1257,6 +1527,10 @@ function makeAgentSubagentRunner(opts) {
       events.on("provider.text_delta", (e) => {
         ctx.budget.markActivity();
         streamingTextAcc = (streamingTextAcc + e.text).slice(-2e3);
+        const text = streamingTextAcc.trim();
+        if (text) {
+          ctx.reportProgress?.({ text, source: "stream", capturedAt: Date.now() });
+        }
       })
     );
     const onParentAbort = () => aborter.abort();
@@ -1264,6 +1538,10 @@ function makeAgentSubagentRunner(opts) {
     let result;
     try {
       result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
+      const finalText2 = result.finalText?.trim();
+      if (finalText2) {
+        ctx.reportProgress?.({ text: finalText2, source: "run_result", capturedAt: Date.now() });
+      }
       events.emit("subagent.task_completed", {
         subagentId: ctx.subagentId,
         taskId: task.id,
@@ -1345,6 +1623,7 @@ function makeAgentSubagentRunner(opts) {
     }
     return {
       result: result.finalText,
+      report: readSubagentStructuredReport(agentContext),
       iterations: result.iterations,
       toolCalls: usage.toolCalls
     };
@@ -1417,7 +1696,7 @@ function agentPrompt(id) {
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      resolved = readFileSync(path10.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync(path9.join(dir, fileName), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -1426,20 +1705,20 @@ function agentPrompt(id) {
   return resolved;
 }
 function agentPromptDirCandidates(envDir) {
-  const globalRoot = process.env["WRONGSTACK_HOME"] || path10.join(os.homedir(), ".wrongstack");
+  const globalRoot = process.env["WRONGSTACK_HOME"] || path9.join(os.homedir(), ".wrongstack");
   const candKey = `${envDir}\0${globalRoot}`;
   const cached = candidateCache.get(candKey);
   if (cached !== void 0) return cached;
-  const here = path10.dirname(fileURLToPath(import.meta.url));
+  const here = path9.dirname(fileURLToPath(import.meta.url));
   const explicitDir = envDir || void 0;
   const candidates = [
-    ...explicitDir ? [path10.resolve(explicitDir)] : [],
-    path10.join(globalRoot, "instructions", "agents"),
-    path10.resolve(here, "../../../../instructions/agents"),
-    path10.resolve(here, "../../../instructions/agents"),
-    path10.resolve(here, "../../instructions/agents"),
-    path10.resolve(here, "../instructions/agents"),
-    path10.resolve(here, "instructions/agents")
+    ...explicitDir ? [path9.resolve(explicitDir)] : [],
+    path9.join(globalRoot, "instructions", "agents"),
+    path9.resolve(here, "../../../../instructions/agents"),
+    path9.resolve(here, "../../../instructions/agents"),
+    path9.resolve(here, "../../instructions/agents"),
+    path9.resolve(here, "../instructions/agents"),
+    path9.resolve(here, "instructions/agents")
   ];
   const ordered = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
   candidateCache.set(candKey, ordered);
@@ -3055,12 +3334,12 @@ var BrainDecisionQueue = class {
       options: request.options,
       rationale: "Decision escalated to human authority."
     };
-    const pending = new Promise((resolve7) => {
-      const entry = { request, resolve: resolve7 };
+    const pending = new Promise((resolve9) => {
+      const entry = { request, resolve: resolve9 };
       if (this.opts.timeoutMs && this.opts.timeoutMs > 0) {
         entry.timer = setTimeout(() => {
           this.pending.delete(request.id);
-          resolve7({ type: "deny", reason: "Brain human decision timed out." });
+          resolve9({ type: "deny", reason: "Brain human decision timed out." });
         }, this.opts.timeoutMs);
       }
       this.pending.set(request.id, entry);
@@ -3285,6 +3564,130 @@ var BrainMonitor = class {
     }
   }
 };
+
+// src/coordination/fleet-event-validation.ts
+var ROLE_BY_EVENT = {
+  "bug.found": "bug-hunter",
+  "refactor.plan": "refactor-planner",
+  "critic.evaluation": "critic"
+};
+function validateFleetEventEmission(type, payload, role) {
+  if (!(type in ROLE_BY_EVENT)) return void 0;
+  const knownType = type;
+  const expectedRole = ROLE_BY_EVENT[knownType];
+  if (role !== expectedRole) {
+    return `${knownType} may only be emitted by role ${expectedRole}; caller role is ${role ?? "unknown"}`;
+  }
+  if (!isRecord2(payload)) return `${knownType} payload must be an object`;
+  switch (knownType) {
+    case "bug.found":
+      return validateBugFound(payload);
+    case "refactor.plan":
+      return validateRefactorPlan(payload);
+    case "critic.evaluation":
+      return validateCriticEvaluation(payload);
+  }
+}
+function validateBugFound(payload) {
+  const finding = payload["finding"];
+  if (!isRecord2(finding)) return "bug.found payload.finding must be an object";
+  if (!isNonEmptyString(finding["id"])) return "bug.found finding.id must be a non-empty string";
+  if (!isNonEmptyString(finding["type"]))
+    return "bug.found finding.type must be a non-empty string";
+  if (!isOneOf(finding["severity"], ["critical", "high", "medium", "low"])) {
+    return "bug.found finding.severity must be critical|high|medium|low";
+  }
+  const location = finding["location"];
+  if (!isRecord2(location) || !isNonEmptyString(location["file"]) || !isPositiveInteger(location["line"])) {
+    return "bug.found finding.location must contain file and a positive integer line";
+  }
+  if (!isNonEmptyString(finding["description"])) {
+    return "bug.found finding.description must be a non-empty string";
+  }
+  if (finding["suggestedFix"] !== void 0 && typeof finding["suggestedFix"] !== "string") {
+    return "bug.found finding.suggestedFix must be a string when provided";
+  }
+  return void 0;
+}
+function validateRefactorPlan(payload) {
+  const plan = payload["plan"];
+  if (!isRecord2(plan)) return "refactor.plan payload.plan must be an object";
+  if (!isNonEmptyString(plan["id"])) return "refactor.plan plan.id must be a non-empty string";
+  if (!isStringArray(plan["basedOnBugIds"])) {
+    return "refactor.plan plan.basedOnBugIds must be a string array";
+  }
+  if (!Array.isArray(plan["phases"]) || !plan["phases"].every(isValidPhase)) {
+    return "refactor.plan plan.phases must contain valid numbered phases";
+  }
+  if (!isOneOf(plan["riskScore"], ["low", "medium", "high"])) {
+    return "refactor.plan plan.riskScore must be low|medium|high";
+  }
+  if (!isNonNegativeInteger(plan["estimatedChangeCount"])) {
+    return "refactor.plan plan.estimatedChangeCount must be a non-negative integer";
+  }
+  if (!isNonEmptyString(plan["rollbackStrategy"])) {
+    return "refactor.plan plan.rollbackStrategy must be a non-empty string";
+  }
+  return void 0;
+}
+function validateCriticEvaluation(payload) {
+  const evaluation = payload["evaluation"];
+  if (!isRecord2(evaluation)) {
+    return "critic.evaluation payload.evaluation must be an object";
+  }
+  if (!isNonEmptyString(evaluation["id"])) {
+    return "critic.evaluation evaluation.id must be a non-empty string";
+  }
+  if (!isOneOf(evaluation["subjectType"], ["bug_finding", "refactor_plan"])) {
+    return "critic.evaluation evaluation.subjectType must be bug_finding|refactor_plan";
+  }
+  if (!isNonEmptyString(evaluation["subjectId"])) {
+    return "critic.evaluation evaluation.subjectId must be a non-empty string";
+  }
+  if (typeof evaluation["score"] !== "number" || !Number.isFinite(evaluation["score"]) || evaluation["score"] < 0 || evaluation["score"] > 10) {
+    return "critic.evaluation evaluation.score must be between 0 and 10";
+  }
+  if (!isOneOf(evaluation["verdict"], ["approve", "needs_revision", "reject"])) {
+    return "critic.evaluation evaluation.verdict must be approve|needs_revision|reject";
+  }
+  if (!isStringArray(evaluation["strengths"]) || !isStringArray(evaluation["weaknesses"])) {
+    return "critic.evaluation strengths and weaknesses must be string arrays";
+  }
+  if (!Array.isArray(evaluation["concerns"]) || !evaluation["concerns"].every(isValidConcern)) {
+    return "critic.evaluation concerns must contain valid concern objects";
+  }
+  return void 0;
+}
+function isValidPhase(value) {
+  return isRecord2(value) && isPositiveInteger(value["number"]) && isNonEmptyString(value["title"]) && isStringArray(value["tasks"]) && isOneOf(value["risk"], ["low", "medium", "high"]);
+}
+function isValidConcern(value) {
+  if (!isRecord2(value)) return false;
+  if (!isNonEmptyString(value["description"])) return false;
+  if (!isOneOf(value["severity"], ["blocking", "advisory"])) return false;
+  const location = value["location"];
+  return location === void 0 || isRecord2(location) && (location["file"] === void 0 || typeof location["file"] === "string") && isPositiveInteger(location["line"]);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isOneOf(value, allowed) {
+  return typeof value === "string" && allowed.includes(value);
+}
+
+// src/coordination/collab-debug.ts
 var DEFAULT_MAX_TARGET_FILES = 30;
 var DirectorAlertLevel = /* @__PURE__ */ ((DirectorAlertLevel2) => {
   DirectorAlertLevel2["WARNING"] = "warning";
@@ -3379,9 +3782,9 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat8] = await Promise.all([
-          fsp7.readFile(filePath, "utf8"),
-          fsp7.stat(filePath)
+        const [content, stat9] = await Promise.all([
+          fsp9.readFile(filePath, "utf8"),
+          fsp9.stat(filePath)
         ]);
         const ext = filePath.split(".").pop() ?? "";
         const language = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" ? "javascript" : ext === "md" ? "markdown" : ext === "json" ? "json" : void 0;
@@ -3389,8 +3792,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat8.mtimeMs,
-          snapshotSizeBytes: stat8.size
+          snapshotMtimeMs: stat9.mtimeMs,
+          snapshotSizeBytes: stat9.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -3484,6 +3887,12 @@ var CollabSession = class extends EventEmitter {
     for (const obj of this.extractJsonObjects(text)) {
       const type = "finding" in obj ? "bug.found" : "plan" in obj ? "refactor.plan" : "evaluation" in obj ? "critic.evaluation" : null;
       if (!type) continue;
+      const validationError = validateFleetEventEmission(
+        type,
+        obj,
+        this.roleFromSubagentId(result.subagentId) ?? void 0
+      );
+      if (validationError) continue;
       this.fleetBus.emit({
         subagentId: result.subagentId,
         taskId: result.taskId,
@@ -3803,9 +4212,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat8 = await fsp7.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat8.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat8.size !== file.snapshotSizeBytes;
+        const stat9 = await fsp9.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat9.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat9.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -4033,28 +4442,6 @@ var FLEET_ROSTER_WITHACP = {
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
 };
 
-// src/security/capabilities.ts
-var ToolCapabilities = {
-  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
-  SHELL_ARBITRARY: "shell.arbitrary",
-  /** Can execute a restricted set of commands (the `exec` tool). */
-  SHELL_RESTRICTED: "shell.restricted",
-  /** Can run a restricted project formatter/linter-style command. */
-  SHELL_EXEC: "shell.exec",
-  /** Can write / modify / delete files inside the project. */
-  FS_WRITE: "fs.write",
-  /** Can write files outside the current project root (very high risk). */
-  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
-  /** Can spawn or manage subagents / multi-agent tasks. */
-  SUBAGENT_SPAWN: "subagent.spawn",
-  /** Can inspect fleet/subagent coordination state without mutating it. */
-  COORDINATION_FLEET_READ: "coordination.fleet.read",
-  /** Can read or write inter-agent mailbox messages. */
-  COORDINATION_MAIL: "coordination.mail",
-  /** Can install packages or run package managers with side effects. */
-  PACKAGE_INSTALL: "package.install"
-};
-
 // src/coordination/delegate-tool.ts
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 30 * 60 * 1e3;
@@ -4203,7 +4590,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve7) => {
+        const result = await new Promise((resolve9) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -4213,7 +4600,7 @@ function createDelegateTool(opts) {
             offTool();
             offIter();
             offProgress();
-            resolve7(value);
+            resolve9(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -4277,7 +4664,11 @@ function createDelegateTool(opts) {
           };
         }
         const baseStopReason = result.status === "success" ? "end_turn" : result.status === "timeout" ? "subagent_timeout" : result.status === "stopped" ? "aborted" : "budget_exhausted";
-        const partial = result.status === "success" ? void 0 : await readSubagentPartial(opts, subagentId);
+        const partial = result.status === "success" ? void 0 : result.partial ? {
+          lastAssistantText: result.partial.text,
+          toolUsesObserved: result.toolCalls,
+          events: result.iterations
+        } : await readSubagentPartial(opts, subagentId);
         const errorKind = result.error?.kind;
         const retryable = result.error?.retryable;
         const backoffMs = result.error?.backoffMs;
@@ -4311,6 +4702,7 @@ function createDelegateTool(opts) {
           subagentId: result.subagentId,
           taskId: result.taskId,
           result: result.result,
+          report: result.report,
           error: result.error,
           iterations: result.iterations,
           toolCalls: result.toolCalls,
@@ -4413,7 +4805,7 @@ function buildDelegateSummary(role, result) {
   const ms = result.durationMs;
   const duration = ms < 6e4 ? `${Math.round(ms / 1e3)}s` : ms < 36e5 ? `${Math.round(ms / 6e4)}m` : `${(ms / 36e5).toFixed(1)}h`;
   if (result.status === "success") {
-    const preview = typeof result.result === "string" ? result.result.trim().slice(0, 120).replace(/\n+/g, " ") : null;
+    const preview = result.report?.summary ? result.report.summary.trim().slice(0, 120).replace(/\n+/g, " ") : typeof result.result === "string" ? result.result.trim().slice(0, 120).replace(/\n+/g, " ") : null;
     const tail = preview ? ` \u2014 ${preview}` : "";
     return `[${roleLabel}] done in ${duration} (${result.iterations} iter, ${result.toolCalls} tools)${tail}`;
   }
@@ -4424,13 +4816,13 @@ async function readSubagentPartial(opts, subagentId) {
   if (!opts.sessionsRoot) return void 0;
   const candidates = [];
   if (opts.directorRunId) {
-    candidates.push(path10.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+    candidates.push(path9.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
-      const entries = await fsp7.readdir(opts.sessionsRoot, { withFileTypes: true });
+      const entries = await fsp9.readdir(opts.sessionsRoot, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          candidates.push(path10.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+          candidates.push(path9.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
         }
       }
     } catch {
@@ -4440,7 +4832,7 @@ async function readSubagentPartial(opts, subagentId) {
   for (const file of candidates) {
     let raw;
     try {
-      raw = await fsp7.readFile(file, "utf8");
+      raw = await fsp9.readFile(file, "utf8");
     } catch {
       continue;
     }
@@ -4532,13 +4924,13 @@ function makeDependencyWatcherConfig(opts) {
   const globPatterns = patterns.filter((p) => p.includes("*"));
   const plainPatterns = patterns.filter((p) => !p.includes("*"));
   function matchesPattern(filePath) {
-    const basename7 = filePath.split("/").pop()?.split("\\").pop() ?? "";
-    if (plainPatterns.includes(basename7)) return true;
+    const basename8 = filePath.split("/").pop()?.split("\\").pop() ?? "";
+    if (plainPatterns.includes(basename8)) return true;
     for (const gp of globPatterns) {
       const regex = new RegExp(
         "^" + gp.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
       );
-      if (regex.test(basename7)) return true;
+      if (regex.test(basename8)) return true;
     }
     return false;
   }
@@ -4624,7 +5016,7 @@ function attachDepWatcherBridge(opts) {
 async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   let existing;
   try {
-    existing = await fsp7.readFile(lockPath, "utf8");
+    existing = await fsp9.readFile(lockPath, "utf8");
   } catch {
   }
   if (existing) {
@@ -4648,7 +5040,7 @@ async function acquireDirectorStateLock(lockPath, processId = process.pid) {
 }
 async function releaseDirectorStateLock(lockPath) {
   try {
-    await fsp7.unlink(lockPath);
+    await fsp9.unlink(lockPath);
   } catch {
   }
 }
@@ -4804,6 +5196,14 @@ var DirectorStateCheckpoint = class {
   }
 };
 
+// src/coordination/spawn-budget.ts
+var HARD_MAX_SPAWN_DEPTH = 2;
+var DEFAULT_MAX_FLEET_SPAWNS = 64;
+function resolveMaxSpawnDepth(requested) {
+  if (requested === void 0 || !Number.isFinite(requested)) return HARD_MAX_SPAWN_DEPTH;
+  return Math.max(0, Math.min(HARD_MAX_SPAWN_DEPTH, Math.floor(requested)));
+}
+
 // src/coordination/director/director-errors.ts
 var FleetSpawnBudgetError = class extends Error {
   kind;
@@ -4832,6 +5232,20 @@ var FleetCostCapError = class extends Error {
     this.observed = observed;
   }
 };
+var FleetTokenCapError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Director token cap exceeded: total fleet usage ${Math.round(observed)} tokens meets or exceeds maxTokens ${Math.round(limit)}`
+    );
+    this.name = "FleetTokenCapError";
+    this.kind = "max_tokens";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
 var FleetContextOverflowError = class extends Error {
   kind;
   limit;
@@ -4854,7 +5268,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync(path10.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync(path9.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -4870,11 +5284,11 @@ function renderInstructionTemplate(template, values) {
 }
 function instructionRootCandidates() {
   if (rootCandidates !== void 0) return rootCandidates;
-  const here = path10.dirname(fileURLToPath(import.meta.url));
+  const here = path9.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path10.resolve(here, "../../instructions"),
-    path10.resolve(here, "../instructions"),
-    path10.resolve(here, "instructions")
+    path9.resolve(here, "../../instructions"),
+    path9.resolve(here, "../instructions"),
+    path9.resolve(here, "instructions")
   ];
   rootCandidates = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
   return rootCandidates;
@@ -4948,554 +5362,69 @@ function rosterSummaryFromConfigs(roster) {
   return lines.join("\n");
 }
 
-// src/kanban/types.ts
-var DEFAULT_COLUMNS = [
-  { id: "backlog", title: "Backlog", order: 0, wipLimit: 0, color: "#64748b" },
-  { id: "todo", title: "To Do", order: 1, wipLimit: 0, color: "#2563eb" },
-  { id: "in-progress", title: "In Progress", order: 2, wipLimit: 5, color: "#d97706" },
-  { id: "review", title: "Review", order: 3, wipLimit: 0, color: "#7c3aed" },
-  { id: "done", title: "Done", order: 4, wipLimit: 0, color: "#16a34a" }
-];
-var CURRENT_KANBAN_VERSION = 1;
-
-// src/kanban/storage.ts
-var KANBANS_DIR = "kanbans";
-var BOARD_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
-function getKanbanDir(projectRoot) {
-  return path10.join(projectRoot, ".wrongstack", KANBANS_DIR);
-}
-function getKanbanPath(projectRoot, boardId) {
-  assertValidBoardId(boardId);
-  const dir = path10.resolve(getKanbanDir(projectRoot));
-  const resolved = path10.resolve(dir, `${boardId}.json`);
-  const rel = path10.relative(dir, resolved);
-  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
-    throw invalidBoardId(boardId);
-  }
-  return resolved;
-}
-function getKanbanEventsPath(projectRoot, boardId) {
-  assertValidBoardId(boardId);
-  const dir = path10.resolve(getKanbanDir(projectRoot));
-  const resolved = path10.resolve(dir, `${boardId}.events.jsonl`);
-  const rel = path10.relative(dir, resolved);
-  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
-    throw invalidBoardId(boardId);
-  }
-  return resolved;
-}
-function isValidBoardId(boardId) {
-  return BOARD_ID_RE.test(boardId) && !boardId.includes("..");
-}
-function assertValidBoardId(boardId) {
-  if (!isValidBoardId(boardId)) throw invalidBoardId(boardId);
-}
-function invalidBoardId(boardId) {
-  return new Error(`Invalid kanban board id: ${boardId}`);
-}
-function isEnoent(err) {
-  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
-}
-async function pathExists(filePath) {
-  try {
-    await fsp7.stat(filePath);
-    return true;
-  } catch (err) {
-    if (isEnoent(err)) return false;
-    throw err;
-  }
+// src/coordination/dispatcher.ts
+var DEFAULT_DISPATCH_ROLE = "executor";
+var FALLBACK_DEFINITION = {
+  config: { role: "unknown", name: "Unknown Agent" },
+  budget: {},
+  capability: { phase: "meta", summary: "", keywords: [] }
+};
+function normalize(text) {
+  return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
 }
-async function listBoardIds(projectRoot) {
-  const dir = getKanbanDir(projectRoot);
-  try {
-    const entries = await fsp7.readdir(dir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -5)).filter(isValidBoardId).sort();
-  } catch (err) {
-    if (isEnoent(err)) return [];
-    throw err;
+function scoreAgents(task, catalog = AGENT_CATALOG) {
+  const haySet = new Set(normalize(task).split(/\s+/).filter(Boolean));
+  const out = [];
+  for (const def of Object.values(catalog)) {
+    if (!def?.config?.role) continue;
+    let score = 0;
+    const matched = [];
+    for (const kw of def.capability.keywords) {
+      const needleWords = normalize(kw).split(/\s+/).filter(Boolean);
+      const allPresent = needleWords.every((w) => haySet.has(w));
+      if (allPresent) {
+        score += needleWords.length;
+        matched.push(kw);
+      }
+    }
+    if (score > 0) {
+      out.push({ role: def.config.role, name: def.config.name, score, matched });
+    }
   }
+  out.sort((a, b) => b.score - a.score);
+  return out;
 }
-async function resolveBoardRef(projectRoot, boardRef) {
-  assertValidBoardId(boardRef);
-  if (await pathExists(getKanbanPath(projectRoot, boardRef))) return boardRef;
-  const matches = (await listBoardIds(projectRoot)).filter((id) => id.startsWith(boardRef));
-  if (matches.length === 0) return null;
-  if (matches.length > 1) {
-    throw new Error(`Ambiguous kanban board id "${boardRef}": ${matches.slice(0, 5).join(", ")}`);
-  }
-  return matches[0] ?? null;
+function heuristicConfidence(candidates) {
+  if (candidates.length === 0) return 0;
+  const top = candidates[0]?.score ?? 0;
+  const second = candidates[1]?.score ?? 0;
+  const strength = Math.min(1, top / 3);
+  const margin = (top - second + 1) / (top + 1);
+  return Math.min(1, strength * margin);
 }
-async function readBoard(projectRoot, boardRef) {
-  const boardId = await resolveBoardRef(projectRoot, boardRef);
-  if (!boardId) return null;
-  try {
-    const raw = await fsp7.readFile(getKanbanPath(projectRoot, boardId), "utf8");
-    return normalizeBoard(JSON.parse(raw));
-  } catch (err) {
-    if (isEnoent(err)) return null;
-    throw err;
+async function dispatchAgent(task, opts = {}) {
+  const catalog = opts.catalog ?? AGENT_CATALOG;
+  const threshold = opts.confidenceThreshold ?? 0.4;
+  const maxCandidates = opts.maxCandidates ?? 6;
+  const candidates = scoreAgents(task, catalog);
+  const confidence = heuristicConfidence(candidates);
+  const top = candidates[0];
+  if (top && confidence >= threshold) {
+    return {
+      role: top.role,
+      definition: catalog[top.role] ?? FALLBACK_DEFINITION,
+      confidence,
+      method: "heuristic",
+      reason: `Matched keywords: ${top.matched.slice(0, 4).join(", ")}`,
+      alternatives: candidates.slice(1, maxCandidates)
+    };
   }
-}
-async function appendKanbanEvent(projectRoot, boardId, event) {
-  const filePath = getKanbanEventsPath(projectRoot, boardId);
-  await withFileLock(filePath, async () => {
-    await fsp7.mkdir(path10.dirname(filePath), { recursive: true });
-    await fsp7.appendFile(filePath, `${JSON.stringify(event)}
-`, "utf8");
-  });
-}
-async function mutateBoard(projectRoot, boardRef, mutator) {
-  const boardId = await resolveBoardRef(projectRoot, boardRef);
-  if (!boardId) return null;
-  const filePath = getKanbanPath(projectRoot, boardId);
-  return withFileLock(filePath, async () => {
-    let board;
-    try {
-      const raw = await fsp7.readFile(filePath, "utf8");
-      board = normalizeBoard(JSON.parse(raw));
-    } catch (err) {
-      if (isEnoent(err)) return null;
-      throw err;
-    }
-    const result = await mutator(board);
-    await writeBoardUnlocked(filePath, normalizeBoard(board));
-    return { board, result };
-  });
-}
-function summarizeBoard(board) {
-  const total = board.tasks.length;
-  const completed = board.tasks.filter((task) => task.status === "completed").length;
-  const lastActivity = latestActivity(board);
-  return {
-    id: board.id,
-    title: board.title,
-    createdAt: board.createdAt,
-    updatedAt: board.updatedAt,
-    columnCount: board.columns.length,
-    taskCount: total,
-    completedTaskCount: completed,
-    ...board.description !== void 0 ? { description: board.description } : {},
-    ...board.tags !== void 0 ? { tags: board.tags } : {},
-    ...lastActivity !== void 0 ? { lastActivity } : {}
-  };
-}
-async function listBoardSummaries(projectRoot) {
-  const summaries = [];
-  for (const id of await listBoardIds(projectRoot)) {
-    const board = await readBoard(projectRoot, id);
-    if (board) summaries.push(summarizeBoard(board));
-  }
-  return summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}
-function normalizeBoard(board) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const columns = [...board.columns?.length ? board.columns : DEFAULT_COLUMNS].map((column, index) => ({
-    ...column,
-    order: column.order ?? index
-  })).sort((a, b) => a.order - b.order).map((column, index) => ({ ...column, order: index }));
-  const columnIds = new Set(columns.map((column) => column.id));
-  const fallbackColumnId = columns[0]?.id ?? "backlog";
-  const tasks = normalizeTaskOrders(
-    (board.tasks ?? []).map((task, index) => ({
-      ...task,
-      columnId: columnIds.has(task.columnId) ? task.columnId : fallbackColumnId,
-      order: task.order ?? index,
-      priority: task.priority ?? "medium",
-      status: task.status ?? "pending",
-      createdAt: task.createdAt ?? now,
-      updatedAt: task.updatedAt ?? now
-    }))
-  );
-  return {
-    ...board,
-    version: board.version ?? CURRENT_KANBAN_VERSION,
-    createdAt: board.createdAt ?? now,
-    updatedAt: board.updatedAt ?? now,
-    columns,
-    tasks
-  };
-}
-function latestActivity(board) {
-  return [board.updatedAt, ...board.tasks.map((task) => task.updatedAt)].filter(Boolean).sort().reverse()[0];
-}
-async function writeBoardUnlocked(filePath, board) {
-  await atomicWrite(filePath, `${JSON.stringify(board, null, 2)}
-`, { encoding: "utf8" });
-}
-function normalizeTaskOrders(tasks) {
-  const byColumn = /* @__PURE__ */ new Map();
-  for (const task of tasks) {
-    const columnTasks = byColumn.get(task.columnId) ?? [];
-    columnTasks.push(task);
-    byColumn.set(task.columnId, columnTasks);
-  }
-  for (const columnTasks of byColumn.values()) {
-    columnTasks.sort((a, b) => a.order - b.order || a.createdAt.localeCompare(b.createdAt)).forEach((task, index) => {
-      task.order = index;
-    });
-  }
-  return tasks;
-}
-
-// src/kanban/manager.ts
-async function listBoards(projectRoot) {
-  return listBoardSummaries(projectRoot);
-}
-async function updateTaskAssignment(projectRoot, boardId, taskId, patch) {
-  let event;
-  const updated = await mutateBoard(projectRoot, boardId, (board) => {
-    const task = findTask(board, taskId);
-    if (!task) return null;
-    const previousColumnId = task.columnId;
-    const beforeAssignment = task.assignment ? { ...task.assignment } : void 0;
-    const nextAssignment = {
-      ...task.assignment ?? { status: "assigned" }
-    };
-    for (const [key, value] of Object.entries(patch)) {
-      if (value !== void 0) {
-        nextAssignment[key] = value;
-      }
-    }
-    task.assignment = nextAssignment;
-    if (task.assignment.agentId) task.assignedAgent = task.assignment.agentId;
-    if (task.assignment.status === "completed") {
-      task.assignment.completedAt = task.assignment.completedAt ?? nowIso();
-      task.status = "completed";
-      task.completedAt = task.assignment.completedAt;
-      if (patch.error === void 0) delete task.assignment.error;
-    } else if (task.assignment.status === "running") {
-      delete task.assignment.completedAt;
-      if (patch.error === void 0) delete task.assignment.error;
-      task.status = "in_progress";
-      delete task.completedAt;
-    } else if (task.assignment.status === "failed") {
-      delete task.assignment.completedAt;
-      task.status = "failed";
-      delete task.completedAt;
-    } else if (task.assignment.status === "cancelled") {
-      delete task.assignment.completedAt;
-      if (patch.error === void 0) delete task.assignment.error;
-      task.status = "blocked";
-      delete task.completedAt;
-    } else if (task.assignment.status === "queued" || task.assignment.status === "assigned") {
-      delete task.assignment.completedAt;
-      if (patch.error === void 0) delete task.assignment.error;
-      if (task.status === "completed" || task.status === "failed") {
-        task.status = task.assignment.status === "queued" ? "ready" : "pending";
-      }
-      delete task.completedAt;
-    }
-    syncTaskColumnForStatus(board, task, previousColumnId);
-    task.updatedAt = nowIso();
-    board.updatedAt = task.updatedAt;
-    event = createKanbanEvent(board.id, task, assignmentEventType(task.assignment.status), {
-      before: beforeAssignment,
-      after: { ...task.assignment },
-      note: patch.error ?? patch.lastResult
-    });
-    return task;
-  });
-  if (updated && event) await emitKanbanEvent(projectRoot, event);
-  return updated?.result ? updated.board : null;
-}
-async function claimReadyTask(projectRoot, input = {}) {
-  if (input.boardId) return claimReadyTaskOnBoard(projectRoot, input.boardId, input);
-  for (const board of await listBoards(projectRoot)) {
-    const claimed = await claimReadyTaskOnBoard(projectRoot, board.id, input);
-    if (claimed) return claimed;
-  }
-  return null;
-}
-async function searchKanban(projectRoot, input = {}) {
-  const boardIds = input.boardId ? [input.boardId] : (await listBoards(projectRoot)).map((b) => b.id);
-  const results = [];
-  for (const boardId of boardIds) {
-    const board = await readBoard(projectRoot, boardId);
-    if (!board) continue;
-    for (const task of board.tasks) {
-      if (!matchesKanbanSearch(board, task, input)) continue;
-      results.push({ board: summarizeBoard(board), task });
-    }
-  }
-  return results;
-}
-async function listReadyTasks(projectRoot, input = {}) {
-  const results = await searchKanban(projectRoot, { ...input, readyOnly: true });
-  return input.limit && input.limit > 0 ? results.slice(0, input.limit) : results;
-}
-function areDependenciesMet(board, taskId) {
-  const task = findTask(board, taskId);
-  if (!task?.dependsOn?.length) return true;
-  return task.dependsOn.every((depId) => {
-    const depTask = board.tasks.find((candidate) => candidate.id === depId);
-    return depTask?.status === "completed";
-  });
-}
-function buildAssignment(input) {
-  return {
-    status: input.status ?? "assigned",
-    ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
-    ...input.name !== void 0 ? { name: input.name } : {},
-    ...input.role !== void 0 ? { role: input.role } : {},
-    ...input.provider !== void 0 ? { provider: input.provider } : {},
-    ...input.model !== void 0 ? { model: input.model } : {},
-    ...input.fallbackProfile !== void 0 ? { fallbackProfile: input.fallbackProfile } : {},
-    ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
-    ...input.tools !== void 0 ? { tools: input.tools } : {},
-    ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: input.allowedCapabilities } : {},
-    ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
-    ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
-    ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
-    ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
-    ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
-    ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {},
-    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
-    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
-    ...input.lastFailureKind !== void 0 ? { lastFailureKind: input.lastFailureKind } : {}
-  };
-}
-async function claimReadyTaskOnBoard(projectRoot, boardId, input) {
-  let event;
-  const updated = await mutateBoard(projectRoot, boardId, (board) => {
-    const candidates = input.taskId ? [findTask(board, input.taskId)].filter((task2) => Boolean(task2)) : board.tasks.filter((task2) => isTaskReadyForWork(board, task2)).sort(compareTasksForWork);
-    const task = candidates.find((candidate) => isTaskReadyForWork(board, candidate));
-    if (!task) return null;
-    const previousColumnId = task.columnId;
-    const current = task.assignment;
-    const assignment = buildAssignment({
-      ...current?.agentId !== void 0 ? { agentId: current.agentId } : {},
-      ...current?.name !== void 0 ? { name: current.name } : {},
-      ...current?.role !== void 0 ? { role: current.role } : {},
-      ...current?.provider !== void 0 ? { provider: current.provider } : {},
-      ...current?.model !== void 0 ? { model: current.model } : {},
-      ...current?.fallbackProfile !== void 0 ? { fallbackProfile: current.fallbackProfile } : {},
-      ...current?.fallbackModels !== void 0 ? { fallbackModels: current.fallbackModels } : {},
-      ...current?.tools !== void 0 ? { tools: current.tools } : {},
-      ...current?.allowedCapabilities !== void 0 ? { allowedCapabilities: current.allowedCapabilities } : {},
-      ...current?.leaseId !== void 0 ? { leaseId: current.leaseId } : {},
-      ...current?.claimedAt !== void 0 ? { claimedAt: current.claimedAt } : {},
-      ...current?.heartbeatAt !== void 0 ? { heartbeatAt: current.heartbeatAt } : {},
-      ...current?.leaseExpiresAt !== void 0 ? { leaseExpiresAt: current.leaseExpiresAt } : {},
-      ...current?.attempt !== void 0 ? { attempt: current.attempt } : {},
-      ...current?.maxAttempts !== void 0 ? { maxAttempts: current.maxAttempts } : {},
-      ...current?.costCeilingUsd !== void 0 ? { costCeilingUsd: current.costCeilingUsd } : {},
-      ...current?.retryPolicy !== void 0 ? { retryPolicy: current.retryPolicy } : {},
-      ...current?.lastFailureKind !== void 0 ? { lastFailureKind: current.lastFailureKind } : {},
-      ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
-      ...input.name !== void 0 ? { name: input.name } : {},
-      ...input.role !== void 0 ? { role: input.role } : {},
-      ...input.provider !== void 0 ? { provider: input.provider } : {},
-      ...input.model !== void 0 ? { model: input.model } : {},
-      ...input.fallbackProfile !== void 0 ? { fallbackProfile: input.fallbackProfile } : {},
-      ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
-      ...input.tools !== void 0 ? { tools: input.tools } : {},
-      ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: input.allowedCapabilities } : {},
-      ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
-      ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
-      ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
-      ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
-      ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
-      ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {},
-      ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
-      ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
-      ...input.lastFailureKind !== void 0 ? { lastFailureKind: input.lastFailureKind } : {},
-      ...input.assignee !== void 0 ? { assignee: input.assignee } : {},
-      status: input.status ?? "queued"
-    });
-    assignment.claimedAt = assignment.claimedAt ?? nowIso();
-    assignment.dispatchedAt = assignment.dispatchedAt ?? assignment.claimedAt;
-    task.assignment = assignment;
-    if (assignment.agentId ?? assignment.role ?? assignment.name) {
-      task.assignedAgent = assignment.agentId ?? assignment.role ?? assignment.name;
-    }
-    if (input.assignee ?? assignment.name ?? assignment.agentId) {
-      task.assignee = input.assignee ?? assignment.name ?? assignment.agentId;
-    }
-    task.status = assignment.status === "running" ? "in_progress" : "ready";
-    delete task.completedAt;
-    syncTaskColumnForStatus(board, task, previousColumnId);
-    task.updatedAt = nowIso();
-    board.updatedAt = task.updatedAt;
-    event = createKanbanEvent(board.id, task, "task.claimed", {
-      before: current ? { ...current } : void 0,
-      after: { ...assignment }
-    });
-    return task;
-  });
-  if (updated && event) await emitKanbanEvent(projectRoot, event);
-  return updated?.result ? { board: updated.board, task: updated.result } : null;
-}
-function compareTasksForWork(a, b) {
-  const priorityRank = {
-    critical: 0,
-    high: 1,
-    medium: 2,
-    low: 3
-  };
-  return priorityRank[a.priority] - priorityRank[b.priority] || a.columnId.localeCompare(b.columnId) || a.order - b.order || a.createdAt.localeCompare(b.createdAt);
-}
-function matchesKanbanSearch(board, task, input) {
-  const query = input.query?.trim().toLowerCase();
-  if (input.assignedAgent && task.assignedAgent !== input.assignedAgent) return false;
-  if (input.status && task.status !== input.status) return false;
-  if (input.priority && task.priority !== input.priority) return false;
-  if (input.label && !task.labels?.includes(input.label)) return false;
-  if (input.chainId && task.chain?.chainId !== input.chainId) return false;
-  if (input.readyOnly && !isTaskReadyForWork(board, task)) return false;
-  if (!query) return true;
-  return [task.title, task.description, task.assignedAgent, task.assignee, ...task.labels ?? []].filter(Boolean).some((value) => String(value).toLowerCase().includes(query));
-}
-function findTask(board, taskId) {
-  const exact = board.tasks.find((task) => task.id === taskId);
-  if (exact) return exact;
-  const matches = board.tasks.filter((task) => task.id.startsWith(taskId));
-  if (matches.length > 1) {
-    throw new Error(
-      `Ambiguous kanban task id "${taskId}": ${matches.slice(0, 5).map((task) => task.id).join(", ")}`
-    );
-  }
-  return matches[0];
-}
-function existingColumnId(board, columnId) {
-  if (!columnId) return void 0;
-  const exact = board.columns.find((column) => column.id === columnId);
-  if (exact) return exact.id;
-  const matches = board.columns.filter((column) => column.id.startsWith(columnId));
-  if (matches.length > 1) {
-    throw new Error(
-      `Ambiguous kanban column id "${columnId}": ${matches.slice(0, 5).map((column) => column.id).join(", ")}`
-    );
-  }
-  return matches[0]?.id;
-}
-function isTaskReadyForWork(board, task) {
-  if (!["pending", "ready"].includes(task.status)) return false;
-  if (task.assignment && ["queued", "running"].includes(task.assignment.status)) return false;
-  if (task.mergedIntoTaskId) return false;
-  if (!areDependenciesMet(board, task.id)) return false;
-  return true;
-}
-function createKanbanEvent(boardId, task, type, details = {}) {
-  return {
-    id: randomUUID(),
-    boardId,
-    taskId: task.id,
-    type,
-    ts: nowIso(),
-    ...task.assignment?.agentId !== void 0 ? { actor: task.assignment.agentId } : {},
-    ...task.assignment?.subagentId !== void 0 ? { subagentId: task.assignment.subagentId } : {},
-    ...task.assignment?.runTaskId !== void 0 ? { runTaskId: task.assignment.runTaskId } : {},
-    ...details
-  };
-}
-async function emitKanbanEvent(projectRoot, event) {
-  try {
-    await appendKanbanEvent(projectRoot, event.boardId, event);
-  } catch {
-  }
-}
-function assignmentEventType(status) {
-  return status === "completed" ? "task.assignment.completed" : status === "failed" ? "task.assignment.failed" : status === "running" ? "task.assignment.running" : status === "cancelled" ? "task.assignment.cancelled" : "task.assignment.updated";
-}
-function columnIdForKanbanStatus(board, status) {
-  const preferred = status === "completed" ? ["done", "completed"] : status === "in_progress" ? ["in-progress", "progress", "doing"] : status === "review" || status === "failed" ? ["review"] : status === "blocked" ? ["blocked", "backlog"] : status === "ready" ? ["todo", "ready", "backlog"] : status === "archived" ? ["done", "archive", "backlog"] : ["todo", "backlog"];
-  for (const columnRef of preferred) {
-    const columnId = existingColumnId(board, columnRef);
-    if (columnId) return columnId;
-  }
-  return board.columns[0]?.id;
-}
-function normalizeColumnTaskOrders(board, columnId) {
-  board.tasks.filter((task) => task.columnId === columnId).sort((a, b) => a.order - b.order || a.createdAt.localeCompare(b.createdAt)).forEach((task, index) => {
-    task.order = index;
-  });
-}
-function syncTaskColumnForStatus(board, task, previousColumnId) {
-  const nextColumnId = columnIdForKanbanStatus(board, task.status);
-  if (!nextColumnId || nextColumnId === task.columnId) return;
-  task.columnId = nextColumnId;
-  normalizeColumnTaskOrders(board, previousColumnId);
-  placeTaskInColumn(board, task, nextColumnId, void 0);
-}
-function placeTaskInColumn(board, task, columnId, targetOrder) {
-  const tasks = board.tasks.filter((candidate) => candidate.columnId === columnId && candidate.id !== task.id).sort((a, b) => a.order - b.order || a.createdAt.localeCompare(b.createdAt));
-  const index = clampOrder(targetOrder, tasks.length);
-  tasks.splice(index, 0, task);
-  tasks.forEach((candidate, order) => {
-    candidate.order = order;
-  });
-}
-function clampOrder(order, max) {
-  if (!Number.isFinite(order)) return max;
-  return Math.max(0, Math.min(Math.trunc(order), max));
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-
-// src/coordination/dispatcher.ts
-var DEFAULT_DISPATCH_ROLE = "executor";
-var FALLBACK_DEFINITION = {
-  config: { role: "unknown", name: "Unknown Agent" },
-  budget: {},
-  capability: { phase: "meta", summary: "", keywords: [] }
-};
-function normalize(text) {
-  return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
-}
-function scoreAgents(task, catalog = AGENT_CATALOG) {
-  const haySet = new Set(normalize(task).split(/\s+/).filter(Boolean));
-  const out = [];
-  for (const def of Object.values(catalog)) {
-    if (!def?.config?.role) continue;
-    let score = 0;
-    const matched = [];
-    for (const kw of def.capability.keywords) {
-      const needleWords = normalize(kw).split(/\s+/).filter(Boolean);
-      const allPresent = needleWords.every((w) => haySet.has(w));
-      if (allPresent) {
-        score += needleWords.length;
-        matched.push(kw);
-      }
-    }
-    if (score > 0) {
-      out.push({ role: def.config.role, name: def.config.name, score, matched });
-    }
-  }
-  out.sort((a, b) => b.score - a.score);
-  return out;
-}
-function heuristicConfidence(candidates) {
-  if (candidates.length === 0) return 0;
-  const top = candidates[0]?.score ?? 0;
-  const second = candidates[1]?.score ?? 0;
-  const strength = Math.min(1, top / 3);
-  const margin = (top - second + 1) / (top + 1);
-  return Math.min(1, strength * margin);
-}
-async function dispatchAgent(task, opts = {}) {
-  const catalog = opts.catalog ?? AGENT_CATALOG;
-  const threshold = opts.confidenceThreshold ?? 0.4;
-  const maxCandidates = opts.maxCandidates ?? 6;
-  const candidates = scoreAgents(task, catalog);
-  const confidence = heuristicConfidence(candidates);
-  const top = candidates[0];
-  if (top && confidence >= threshold) {
-    return {
-      role: top.role,
-      definition: catalog[top.role] ?? FALLBACK_DEFINITION,
-      confidence,
-      method: "heuristic",
-      reason: `Matched keywords: ${top.matched.slice(0, 4).join(", ")}`,
-      alternatives: candidates.slice(1, maxCandidates)
-    };
-  }
-  if (opts.classifier) {
-    const pool = (candidates.length > 0 ? candidates.slice(0, maxCandidates).map((c) => catalog[c.role] ?? FALLBACK_DEFINITION) : ALL_AGENT_DEFINITIONS).map((d) => ({
-      role: d.config.role,
-      name: d.config.name,
-      summary: d.capability.summary
-    }));
+  if (opts.classifier) {
+    const pool = (candidates.length > 0 ? candidates.slice(0, maxCandidates).map((c) => catalog[c.role] ?? FALLBACK_DEFINITION) : ALL_AGENT_DEFINITIONS).map((d) => ({
+      role: d.config.role,
+      name: d.config.name,
+      summary: d.capability.summary
+    }));
     try {
       const choice = await opts.classifier(task, pool);
       if (choice && catalog[choice.role]) {
@@ -5556,7 +5485,7 @@ function makeLLMClassifier(complete) {
 }
 
 // src/coordination/director-tools.ts
-function nowIso2() {
+function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function makeSpawnTool(director, roster) {
@@ -5679,6 +5608,9 @@ function makeSpawnTool(director, roster) {
         if (err instanceof FleetCostCapError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
         }
+        if (err instanceof FleetTokenCapError) {
+          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
+        }
         return { error: toErrorMessage(err) };
       }
     }
@@ -5860,11 +5792,11 @@ function normalizeQualityGateInput(input) {
   const raw = input ?? {};
   return {
     task: typeof raw.task === "string" ? raw.task : void 0,
-    implementerTaskIds: stringArray(raw.implementerTaskIds),
+    implementerTaskIds: stringArray2(raw.implementerTaskIds),
     repairSubagentId: typeof raw.repairSubagentId === "string" && raw.repairSubagentId.trim() ? raw.repairSubagentId.trim() : void 0,
     maxRepairAttempts: typeof raw.maxRepairAttempts === "number" ? raw.maxRepairAttempts : void 0,
-    targets: stringArray(raw.targets),
-    commands: stringArray(raw.commands),
+    targets: stringArray2(raw.targets),
+    commands: stringArray2(raw.commands),
     expected: typeof raw.expected === "string" ? raw.expected : void 0,
     evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
     reviewer: typeof raw.reviewer === "boolean" ? raw.reviewer : void 0,
@@ -5874,7 +5806,7 @@ function normalizeQualityGateInput(input) {
     verifierWorktree: normalizeWorktreeOverride(raw.verifierWorktree)
   };
 }
-function stringArray(value) {
+function stringArray2(value) {
   if (!Array.isArray(value)) return void 0;
   const strings = value.filter((v) => typeof v === "string" && v.trim().length > 0);
   return strings.length > 0 ? strings : void 0;
@@ -6181,7 +6113,7 @@ function makeKanbanQueueTool(director, roster) {
       if (!projectRoot) return { error: "kanban_queue requires ctx.projectRoot." };
       const maxTasks = Math.max(1, Math.min(20, Math.floor(i.maxTasks ?? 1)));
       const leaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
-      const claimedAt = nowIso2();
+      const claimedAt = nowIso();
       const leaseSeeding = {
         leaseId: randomUUID(),
         claimedAt,
@@ -6339,9 +6271,9 @@ function normalizeKanbanQueueInput(input) {
     role: typeof raw.role === "string" ? raw.role : void 0,
     provider: typeof raw.provider === "string" ? raw.provider : void 0,
     model: typeof raw.model === "string" ? raw.model : void 0,
-    fallbackModels: stringArray(raw.fallbackModels),
-    tools: stringArray(raw.tools),
-    allowedCapabilities: stringArray(raw.allowedCapabilities),
+    fallbackModels: stringArray2(raw.fallbackModels),
+    tools: stringArray2(raw.tools),
+    allowedCapabilities: stringArray2(raw.allowedCapabilities),
     worktree: normalizeWorktreeOverride(raw.worktree),
     heartbeatIntervalMs: typeof raw.heartbeatIntervalMs === "number" ? raw.heartbeatIntervalMs : void 0,
     leaseTtlMs: typeof raw.leaseTtlMs === "number" ? raw.leaseTtlMs : void 0
@@ -6819,10 +6751,10 @@ function makeCollabDebugTool(director) {
 function makeFleetEmitTool(director) {
   return {
     name: "fleet_emit",
-    description: "Emit a structured event on the FleetBus. Any subagent can emit any event type; the Director routes it to all listeners. Use it to stream findings, progress updates, or final results to other agents in real time.",
+    description: "Emit a structured event on the FleetBus. Known collaboration events are schema-validated and role-bound; custom event types remain extensible. Use it to stream findings, progress updates, or final results to other agents in real time.",
     permission: "auto",
     mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_EMIT],
     inputSchema: {
       type: "object",
       properties: {
@@ -6837,10 +6769,16 @@ function makeFleetEmitTool(director) {
       },
       required: ["type"]
     },
-    async execute(input) {
+    async execute(input, ctx) {
       const i = input;
+      const role = ctx.meta["agentRole"];
+      const validationError = validateFleetEventEmission(i.type, i.payload ?? {}, role);
+      if (validationError) return { ok: false, error: validationError };
+      const callerId = ctx.agentId && ctx.agentId !== "unknown" ? ctx.agentId : director.id;
+      const taskId = ctx.meta["subagentTaskId"];
       director.fleet.emit({
-        subagentId: director.id,
+        subagentId: callerId,
+        taskId,
         ts: Date.now(),
         type: i.type,
         payload: i.payload ?? {}
@@ -7124,15 +7062,39 @@ function hashStr(s) {
 }
 
 // src/types/provider.ts
+var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
+var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+function classifyProviderError(status, body, message) {
+  const type = body?.type;
+  if (status === 0) return "network";
+  if (status === 408) return "timeout";
+  if (status === 599) return "stream_hang";
+  if (type === "rate_limit_error" || status === 429) return "rate_limit";
+  if (type === "overloaded_error" || status === 529) return "overloaded";
+  if (status >= 500) return "server";
+  if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
+    return "auth";
+  }
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
+  if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
+  if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
+    return "context_overflow";
+  }
+  if (status >= 400) return "invalid_request";
+  return "unknown";
+}
 var ProviderError = class extends WrongStackError {
   status;
   retryable;
   providerId;
+  /** Canonical failure classification — see {@link ProviderErrorKind}. */
+  kind;
   body;
   constructor(message, status, retryable, providerId, opts = {}) {
+    const kind = opts.kind ?? classifyProviderError(status, opts.body, message);
     super({
       message,
-      code: providerStatusToCode(status, opts.body?.type),
+      code: kindToCode(kind),
       subsystem: "provider",
       severity: status >= 500 ? "error" : "warning",
       recoverable: retryable,
@@ -7143,6 +7105,7 @@ var ProviderError = class extends WrongStackError {
     this.status = status;
     this.retryable = retryable;
     this.providerId = providerId;
+    this.kind = kind;
     this.body = opts.body;
   }
   /**
@@ -7170,26 +7133,34 @@ var ProviderError = class extends WrongStackError {
 };
 function describeStatus(status, type) {
   if (status === 0) return "network error";
+  if (status === 599) return `stream hang (${status})`;
   if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
   if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
   if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
   if (type === "permission_error" || status === 403) return `forbidden (${status})`;
   if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "content_filter") return `content filtered (${status})`;
   if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
   if (status === 408) return `timeout (${status})`;
   if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
   if (type) return `${type} (${status})`;
   return `HTTP ${status}`;
 }
-function providerStatusToCode(status, type) {
-  if (status === 0) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
-  if (type === "rate_limit_error" || status === 429) return ERROR_CODES.PROVIDER_RATE_LIMITED;
-  if (type === "authentication_error" || status === 401) return ERROR_CODES.PROVIDER_AUTH_FAILED;
-  if (type === "overloaded_error" || status === 529) return ERROR_CODES.PROVIDER_OVERLOADED;
-  if (type === "invalid_request_error" || status === 400) return ERROR_CODES.PROVIDER_INVALID_REQUEST;
-  if (status === 408) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
-  if (status >= 500) return ERROR_CODES.PROVIDER_SERVER_ERROR;
-  return ERROR_CODES.PROVIDER_INVALID_REQUEST;
+var KIND_TO_CODE = {
+  network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
+  overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
+  context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
+  server: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  stream_hang: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  content_filter: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  invalid_request: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  unknown: ERROR_CODES.PROVIDER_INVALID_REQUEST
+};
+function kindToCode(kind) {
+  return KIND_TO_CODE[kind];
 }
 
 // src/core/fallback-model.ts
@@ -7438,20 +7409,31 @@ function classifySubagentError(err, hints = {}) {
   return { kind: "unknown", message: baseMessage, retryable: false, cause };
 }
 function providerErrorToSubagentError(err, message, cause) {
-  const status = err.status;
-  if (status === 429 || err.body?.type === "rate_limit_error") {
-    return { kind: "provider_rate_limit", message, retryable: true, backoffMs: 5e3, cause };
-  }
-  if (status === 401 || status === 403 || err.body?.type === "authentication_error") {
-    return { kind: "provider_auth", message, retryable: false, cause };
-  }
-  if (status === 408 || status === 0) {
-    return { kind: "provider_timeout", message, retryable: true, cause };
-  }
-  if (status >= 500 && status < 600) {
-    return { kind: "provider_5xx", message, retryable: true, backoffMs: 3e3, cause };
+  switch (err.kind) {
+    case "rate_limit":
+      return {
+        kind: "provider_rate_limit",
+        message,
+        retryable: true,
+        backoffMs: err.body?.retryAfterMs ?? 5e3,
+        cause
+      };
+    case "auth":
+      return { kind: "provider_auth", message, retryable: false, cause };
+    case "timeout":
+    case "network":
+      return { kind: "provider_timeout", message, retryable: true, cause };
+    case "overloaded":
+    case "server":
+    case "stream_hang":
+      return { kind: "provider_5xx", message, retryable: true, backoffMs: 3e3, cause };
+    case "context_overflow":
+      return { kind: "context_overflow", message, retryable: false, cause };
+    case "invalid_request":
+    case "content_filter":
+    case "unknown":
+      return { kind: "unknown", message, retryable: err.retryable, cause };
   }
-  return { kind: "unknown", message, retryable: err.retryable, cause };
 }
 
 // src/coordination/subagent-nicknames.ts
@@ -7836,7 +7818,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve9, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -7845,7 +7827,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve7(result);
+              resolve9(result);
             }
           };
           this.on("task.completed", handler);
@@ -7870,13 +7852,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       const done = new Set(completed.map((r) => r.taskId));
       return { completed, pending: taskIds.filter((id) => !done.has(id)) };
     }
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve7({
+        resolve9({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -7884,7 +7866,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve7({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve9({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -8064,12 +8046,22 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     this.inFlight++;
     const startTime = Date.now();
+    let latestPartial;
     const runCtx = {
       subagentId,
       config: subagent.config,
       budget,
       signal: subagent.abortController.signal,
-      bridge: subagent.context.parentBridge || null
+      bridge: subagent.context.parentBridge || null,
+      reportProgress: (partial) => {
+        const text = partial.text.trim();
+        if (!text) return;
+        latestPartial = {
+          ...partial,
+          // A partial is context recovery, not a transcript replacement.
+          text: text.slice(-4e3)
+        };
+      }
     };
     let result;
     budget.start();
@@ -8086,6 +8078,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         taskId: task.id,
         status: "success",
         result: outcome.result,
+        ...outcome.report ? { report: outcome.report } : {},
         iterations: outcome.iterations,
         toolCalls: outcome.toolCalls,
         durationMs: Date.now() - startTime
@@ -8100,6 +8093,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         error: classifySubagentError(err, {
           parentAborted: subagent.abortController.signal.aborted
         }),
+        ...latestPartial ? { partial: latestPartial } : {},
         iterations: usage.iterations,
         toolCalls: usage.toolCalls,
         durationMs: Date.now() - startTime
@@ -8154,12 +8148,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve7 = (d) => {
+              const resolve9 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve7("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve9("stop"), DECISION_TIMEOUT_MS);
               const sessionId = this.currentSessionId();
               budget._events?.emit("budget.threshold_reached", {
                 ...sessionId ? { sessionId } : {},
@@ -8177,11 +8171,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve7({ extend: extra }));
+                  queueMicrotask(() => resolve9({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve7("stop");
+                  resolve9("stop");
                 }
               });
             });
@@ -8345,6 +8339,8 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         taskId: result.taskId,
         status: result.status,
         result: result.result,
+        report: result.report,
+        partial: result.partial,
         iterations: result.iterations,
         toolCalls: result.toolCalls,
         durationMs: result.durationMs
@@ -8729,6 +8725,8 @@ var Director = class _Director {
   manifestDebounceMs;
   /** Fleet-wide cost cap (entire fleet total, distinct from SubagentBudget limits). Infinity means no cap. */
   maxFleetCostUsd;
+  /** Fleet-wide input+output token cap. Infinity means no cap. */
+  maxFleetTokens;
   /** Max auto-extensions per subagent per budget kind before denying. */
   maxBudgetExtensions;
   /** Sessions root for direct subagent JSONL reads (fleet tool, action: session). */
@@ -8807,13 +8805,14 @@ var Director = class _Director {
     this.taskResultNotifier = opts.taskResultNotifier;
     this.sharedScratchpadPath = opts.sharedScratchpadPath ?? null;
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
-    this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
-    this.spawnDepth = opts.spawnDepth ?? 0;
+    this.maxSpawnDepth = opts.fleetManager?.maxSpawnDepth ?? resolveMaxSpawnDepth(opts.maxSpawnDepth);
+    this.spawnDepth = opts.fleetManager?.spawnDepth ?? opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.sessionIdSource = opts.sessionId ?? (() => opts.sessionWriter?.id);
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
     this.dispatchClassifier = opts.dispatchClassifier;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxFleetTokens = opts.directorBudget?.maxTokens ?? Number.POSITIVE_INFINITY;
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
     this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
     this.maxContext = opts.maxContext ?? 128e3;
@@ -8834,7 +8833,7 @@ var Director = class _Director {
     this.fleetManager = opts.fleetManager;
     this.logger = opts.logger;
     if (this.sharedScratchpadPath) {
-      void fsp7.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
+      void fsp9.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
     }
     this.transport = new InMemoryBridgeTransport();
     this.bridge = new InMemoryAgentBridge(
@@ -8907,6 +8906,8 @@ var Director = class _Director {
               subagentName: this.manifestEntries.get(r.subagentId)?.name,
               resultText,
               errorText: r.error ? `${r.error.kind}: ${r.error.message}` : void 0,
+              partialText: r.partial?.text,
+              report: r.report,
               iterations: r.iterations,
               toolCalls: r.toolCalls,
               durationMs: r.durationMs
@@ -9283,6 +9284,8 @@ var Director = class _Director {
           throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
         if (rejection.kind === "max_cost_usd")
           throw new FleetCostCapError(rejection.limit, rejection.observed);
+        if (rejection.kind === "max_tokens")
+          throw new FleetTokenCapError(rejection.limit, rejection.observed);
         if (rejection.kind === "max_context_load")
           throw new FleetContextOverflowError(rejection.limit, rejection.observed);
       }
@@ -9299,6 +9302,13 @@ var Director = class _Director {
           throw new FleetCostCapError(this.maxFleetCostUsd, totalCost);
         }
       }
+      if (this.maxFleetTokens < Number.POSITIVE_INFINITY) {
+        const total = this.usage.snapshot().total;
+        const usedTokens = (total?.input ?? 0) + (total?.output ?? 0);
+        if (usedTokens >= this.maxFleetTokens) {
+          throw new FleetTokenCapError(this.maxFleetTokens, usedTokens);
+        }
+      }
       if (this.maxLeaderContextLoad < 1) {
         const maxContext = this.resolveMaxContext();
         const threshold = maxContext * this.maxLeaderContextLoad;
@@ -9319,6 +9329,34 @@ var Director = class _Director {
         this._usedNicknames.add(key);
       }
     }
+    const budget = this.fleetManager ? this.fleetManager.budgetSnapshot() : (() => {
+      const total = this.usage.snapshot().total;
+      const usedTokens = (total?.input ?? 0) + (total?.output ?? 0);
+      const usedCostUsd = total?.cost ?? 0;
+      return {
+        maxSpawns: this.maxSpawns,
+        remainingSpawns: Math.max(0, this.maxSpawns - this.spawnCount - 1),
+        maxTokens: this.maxFleetTokens,
+        remainingTokens: Math.max(0, this.maxFleetTokens - usedTokens),
+        maxCostUsd: this.maxFleetCostUsd,
+        remainingCostUsd: Math.max(0, this.maxFleetCostUsd - usedCostUsd)
+      };
+    })();
+    config.spawnLineage = {
+      parentDirectorId: this.id,
+      spawnDepth: this.spawnDepth + 1,
+      maxSpawnDepth: this.maxSpawnDepth,
+      fleetBudget: {
+        ...Number.isFinite(budget.maxSpawns) ? { maxSpawns: budget.maxSpawns } : {},
+        ...Number.isFinite(budget.remainingSpawns) ? {
+          remainingSpawns: this.fleetManager ? Math.max(0, budget.remainingSpawns - 1) : budget.remainingSpawns
+        } : {},
+        ...Number.isFinite(budget.maxTokens) ? { maxTokens: budget.maxTokens } : {},
+        ...Number.isFinite(budget.remainingTokens) ? { remainingTokens: budget.remainingTokens } : {},
+        ...Number.isFinite(budget.maxCostUsd) ? { maxCostUsd: budget.maxCostUsd } : {},
+        ...Number.isFinite(budget.remainingCostUsd) ? { remainingCostUsd: budget.remainingCostUsd } : {}
+      }
+    };
     result = await this.coordinator.spawn(config);
     if (this.fleetManager) {
       this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
@@ -9437,6 +9475,7 @@ var Director = class _Director {
           toolCalls: r.toolCalls,
           durationMs: r.durationMs,
           result: r.result,
+          report: r.report,
           error: r.error
         })),
         null,
@@ -9454,6 +9493,7 @@ var Director = class _Director {
       lines.push(`_${r.status} \u2014 ${r.iterations} iter \xB7 ${r.toolCalls} tools \xB7 ${r.durationMs}ms_`);
       lines.push("");
       if (r.error) lines.push(`**Error:** ${r.error}`);
+      else if (r.report) lines.push(formatSubagentStructuredReport(r.report));
       else if (typeof r.result === "string") lines.push(r.result);
       else if (r.result !== void 0)
         lines.push("```json\n" + JSON.stringify(r.result, null, 2) + "\n```");
@@ -9500,7 +9540,7 @@ var Director = class _Director {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp7.mkdir(path10.dirname(this.manifestPath), { recursive: true });
+    await fsp9.mkdir(path9.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -9654,11 +9694,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve7;
+        let resolve9;
         const promise = new Promise((res) => {
-          resolve7 = res;
+          resolve9 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve7 });
+        this.taskWaiters.set(id, { promise, resolve: resolve9 });
         return promise;
       })
     );
@@ -9687,10 +9727,10 @@ var Director = class _Director {
         pending: taskIds.filter((id) => !done.has(id))
       });
     }
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       const entry = {
         ids: new Set(taskIds),
-        resolve: (r) => resolve7({
+        resolve: (r) => resolve9({
           completed: [r],
           pending: taskIds.filter((id) => id !== r.taskId)
         })
@@ -9698,7 +9738,7 @@ var Director = class _Director {
       if (opts?.timeoutMs !== void 0) {
         entry.timer = setTimeout(() => {
           this.anyWaiters.delete(entry);
-          resolve7({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve9({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.anyWaiters.add(entry);
@@ -9820,10 +9860,10 @@ var Director = class _Director {
    */
   async readSession(subagentId, tail) {
     if (!this.sessionsRoot) return null;
-    const filePath = path10.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    const filePath = path9.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
     let raw;
     try {
-      raw = await fsp7.readFile(filePath, "utf8");
+      raw = await fsp9.readFile(filePath, "utf8");
     } catch {
       return null;
     }
@@ -10003,9 +10043,10 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path10.join(opts.dir, `${path10.basename(id)}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path9.join(opts.dir, `${path9.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
+    this.checkpointCas = opts.checkpointCas;
     this.onCloseCb = opts.onClose;
     this.summary = {
       id,
@@ -10047,6 +10088,7 @@ var FileSessionWriter = class _FileSessionWriter {
   appendFailCount = 0;
   lastAppendWarnAt = 0;
   secretScrubber;
+  checkpointCas;
   onCloseCb;
   /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
   traceId;
@@ -10067,9 +10109,12 @@ var FileSessionWriter = class _FileSessionWriter {
   // a timer-driven flush racing an explicit flush()/close() issues two
   // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
   // may complete them out of order (chronology breaks) or, for large
-  // batches, interleave partial writes (torn JSONL lines). The chain keeps
-  // exactly one write in flight; failures don't break the chain.
+  // batches, interleave partial writes (torn JSONL lines). The write chain
+  // serializes handle I/O; flushChain additionally serializes the act of
+  // draining/re-queueing the in-memory event buffer so a failed older batch
+  // can never be overtaken by a newer successful one.
   writeChain = Promise.resolve();
+  flushChain = Promise.resolve();
   /** Enqueue a write on the FIFO chain. Resolves/rejects with that write. */
   enqueueWrite(data) {
     const write = this.writeChain.then(() => this.handle.appendFile(data, "utf8"));
@@ -10090,13 +10135,25 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Scrub secrets out of conversation-turn events before they are observed
    * for the summary, written to the JSONL log, or surfaced on resume. Only
-   * `user_input` / `llm_response` carry free-form user/model text; other event
-   * types either have no secret-bearing content or are already scrubbed
-   * upstream (tool results). Returns the event unchanged when no scrubber is
-   * configured.
+   * `user_input`, `llm_response`, and `context_snapshot` carry free-form
+   * user/model text; other event types either have no secret-bearing content
+   * or are already scrubbed upstream (tool results). Snapshot normalization
+   * also strips transient token-cache fields even when no scrubber is set.
    */
   scrubEvent(event) {
     const s = this.secretScrubber;
+    if (event.type === "context_snapshot") {
+      return {
+        ...event,
+        messages: event.messages.map((message) => {
+          const { _estTokens: _ignored, ...persisted } = message;
+          return {
+            ...persisted,
+            content: typeof persisted.content === "string" ? s?.scrub(persisted.content) ?? persisted.content : s?.scrubObject(persisted.content) ?? persisted.content
+          };
+        })
+      };
+    }
     if (!s) return event;
     if (event.type === "user_input") {
       return {
@@ -10110,10 +10167,55 @@ var FileSessionWriter = class _FileSessionWriter {
     return event;
   }
   pendingFileSnapshots = [];
+  /** Prompt whose tool work is currently executing. Set by writeCheckpoint. */
+  activePromptIndex = null;
   /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
   openToolUses = /* @__PURE__ */ new Set();
+  /**
+   * Buffer an event from a synchronous Context callback. ensureInit() starts
+   * by pushing the lifecycle preamble synchronously, so session_start always
+   * precedes observations even though these callbacks cannot await append().
+   */
+  bufferSynchronousEvent(event) {
+    if (this.closed) return;
+    void this.ensureInit();
+    this.observeForSummary(event);
+    this.writeBuffer.push(event);
+    if (this.writeBuffer.length >= _FileSessionWriter.FLUSH_SIZE) {
+      if (this.flushTimer) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      void this.flushBuffer().catch(() => {
+      });
+    } else {
+      this.scheduleFlush();
+    }
+  }
   recordFileChange(input) {
-    this.pendingFileSnapshots.push(input);
+    if (this.closed) return;
+    if (this.activePromptIndex === null) {
+      this.pendingFileSnapshots.push(input);
+      return;
+    }
+    const event = {
+      type: "file_snapshot",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      promptIndex: this.activePromptIndex,
+      files: [input]
+    };
+    this.bufferSynchronousEvent(event);
+  }
+  recordFileObservation(input) {
+    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs)) return;
+    this.bufferSynchronousEvent({
+      type: "file_observation",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      path: input.path,
+      hash: input.hash.toLowerCase(),
+      mtimeMs: input.mtimeMs,
+      source: input.source
+    });
   }
   recordSideEffect(input) {
     this.append({
@@ -10131,18 +10233,13 @@ var FileSessionWriter = class _FileSessionWriter {
     return Array.from(this.openToolUses);
   }
   async writeSessionStartLazy() {
-    const record = `${JSON.stringify({
+    this.writeBuffer.push({
       type: this.resumed ? "session_resumed" : "session_start",
       ts: this.startedAt,
       id: this.id,
       model: this.meta.model ?? "unknown",
       provider: this.meta.provider ?? "unknown"
-    })}
-`;
-    try {
-      await this.enqueueWrite(record);
-    } catch {
-    }
+    });
   }
   async append(event) {
     if (this.closed) return;
@@ -10155,7 +10252,8 @@ var FileSessionWriter = class _FileSessionWriter {
         clearTimeout(this.flushTimer);
         this.flushTimer = null;
       }
-      await this.flushBuffer();
+      await this.flushBuffer().catch(() => {
+      });
     } else {
       this.scheduleFlush();
     }
@@ -10173,7 +10271,8 @@ var FileSessionWriter = class _FileSessionWriter {
         clearTimeout(this.flushTimer);
         this.flushTimer = null;
       }
-      await this.flushBuffer();
+      await this.flushBuffer().catch(() => {
+      });
     } else {
       this.scheduleFlush();
     }
@@ -10183,16 +10282,49 @@ var FileSessionWriter = class _FileSessionWriter {
    * (user_input, llm_response) call this so they survive SIGKILL/crash
    * instead of sitting in the in-memory buffer for up to 500ms.
    *
-   * Idempotent — cancels any pending timer and writes whatever has
-   * accumulated in the buffer. Safe to call even when the buffer
-   * is empty (no-op).
+   * Idempotent — cancels any pending timer, writes whatever has accumulated,
+   * then asks the OS to synchronize the file data before resolving. Even an
+   * empty-buffer flush synchronizes any earlier timer-driven append.
    */
   async flush() {
+    if (this.closed) return;
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
       this.flushTimer = null;
     }
     await this.flushBuffer();
+    await this.writeChain;
+    await this.handle.datasync();
+  }
+  /**
+   * Last-gasp synchronous drain for hard-exit paths (process.exit after
+   * rapid Ctrl+C). The async write chain cannot be awaited when the process
+   * is about to die, but whatever still sits in the in-memory buffer CAN be
+   * saved with a blocking append. Best-effort: an in-flight async write may
+   * be cut off by the exit regardless; errors here are swallowed.
+   */
+  flushSync() {
+    if (this.writeBuffer.length === 0 || !this.filePath) return;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    this.writeBuffer = [];
+    let fd;
+    try {
+      fd = openSync(this.filePath, "a");
+      writeSync(fd, batch, null, "utf8");
+      fsyncSync(fd);
+    } catch {
+    } finally {
+      if (fd !== void 0) {
+        try {
+          closeSync(fd);
+        } catch {
+        }
+      }
+    }
   }
   /** Schedule a deferred flush. No-op if a timer is already pending. */
   scheduleFlush() {
@@ -10205,15 +10337,24 @@ var FileSessionWriter = class _FileSessionWriter {
   }
   /**
    * Flush all buffered events to disk as a single appendFile call.
-   * Errors use the same throttled-warning pattern the old per-event
-   * append path used — one warning every 5s with a suppressed count.
-   * On failure the buffer is cleared (events are best-effort, same as
-   * the old per-event path where a failed write was silently dropped).
+   * Concurrent callers join a FIFO flush chain. On failure the drained batch
+   * is prepended to the live buffer, preserving chronology and allowing the
+   * next timer/boundary flush to retry it. Warnings retain the existing
+   * throttled behavior.
    */
-  async flushBuffer() {
+  flushBuffer() {
+    const flush = this.flushChain.then(() => this.flushBufferOnce());
+    this.flushChain = flush.then(
+      () => void 0,
+      () => void 0
+    );
+    return flush;
+  }
+  async flushBufferOnce() {
     if (this.writeBuffer.length === 0) return;
-    const eventCount = this.writeBuffer.length;
-    const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    const events = this.writeBuffer;
+    const eventCount = events.length;
+    const batch = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
     this.writeBuffer = [];
     const t0 = Date.now();
     let outcome = "success";
@@ -10223,6 +10364,7 @@ var FileSessionWriter = class _FileSessionWriter {
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
+      this.writeBuffer = [...events, ...this.writeBuffer];
       this.appendFailCount += eventCount;
       const now = Date.now();
       if (now - this.lastAppendWarnAt > 5e3) {
@@ -10236,6 +10378,8 @@ var FileSessionWriter = class _FileSessionWriter {
         this.lastAppendWarnAt = now;
         this.appendFailCount = 0;
       }
+      if (!this.closed) this.scheduleFlush();
+      throw err;
     } finally {
       this.events?.emit("storage.write", {
         sessionId: this.id,
@@ -10290,10 +10434,22 @@ var FileSessionWriter = class _FileSessionWriter {
   }
   async close() {
     if (this.closePromise) return this.closePromise;
-    this.closePromise = this.doClose();
+    this.closePromise = this.doClose().catch((err) => {
+      this.closed = false;
+      this.closePromise = null;
+      if (this.writeBuffer.length > 0) this.scheduleFlush();
+      throw err;
+    });
     return this.closePromise;
   }
   async doClose() {
+    if (this.pendingFileSnapshots.length > 0) {
+      await this.writeFileSnapshot(
+        this.activePromptIndex ?? 0,
+        [...this.pendingFileSnapshots]
+      );
+      this.pendingFileSnapshots = [];
+    }
     this.closed = true;
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
@@ -10301,6 +10457,7 @@ var FileSessionWriter = class _FileSessionWriter {
     }
     await this.flushBuffer();
     await this.writeChain;
+    await this.handle.datasync();
     this.summary = {
       ...this.summary,
       endedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10365,12 +10522,29 @@ var FileSessionWriter = class _FileSessionWriter {
       await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
+    let workspaceCheckpoint;
+    try {
+      workspaceCheckpoint = await this.checkpointCas?.capture(this.id, promptIndex);
+    } catch (err) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "session.workspace_checkpoint_capture_failed",
+          sessionId: this.id,
+          promptIndex,
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
     await this.append({
       type: "checkpoint",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       promptIndex,
-      promptPreview
+      promptPreview,
+      ...workspaceCheckpoint ? { workspaceCheckpoint } : {}
     });
+    this.activePromptIndex = promptIndex;
     this.events?.emit("checkpoint.written", {
       sessionId: this.id,
       promptIndex,
@@ -10409,7 +10583,7 @@ var FileSessionWriter = class _FileSessionWriter {
     let removedCount = 0;
     let targetCheckpointSeen = false;
     try {
-      fd = await fsp7.open(this.filePath, "r", 384);
+      fd = await fsp9.open(this.filePath, "r", 384);
       while (true) {
         const buf = Buffer.alloc(CHUNK_SIZE);
         const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
@@ -10464,7 +10638,7 @@ var FileSessionWriter = class _FileSessionWriter {
     await this.writeChain;
     await this.handle.close();
     const tmpPath = `${this.filePath}.rewind.tmp`;
-    const src = await fsp7.open(this.filePath, "r", 384);
+    const src = await fsp9.open(this.filePath, "r", 384);
     try {
       const statResult = await src.stat();
       const totalSize = statResult.size;
@@ -10480,7 +10654,7 @@ var FileSessionWriter = class _FileSessionWriter {
       } else {
         newlineAfterCheckpoint = totalSize;
       }
-      const writeFd = await fsp7.open(tmpPath, "w", 384);
+      const writeFd = await fsp9.open(tmpPath, "w", 384);
       try {
         let readOffset = 0;
         while (readOffset < newlineAfterCheckpoint) {
@@ -10528,11 +10702,11 @@ var FileSessionWriter = class _FileSessionWriter {
         await writeFd.close();
       }
       await src.close();
-      await fsp7.rename(tmpPath, this.filePath);
-      this.handle = await fsp7.open(this.filePath, "a", 384);
+      await fsp9.rename(tmpPath, this.filePath);
+      this.handle = await fsp9.open(this.filePath, "a", 384);
     } catch (err) {
-      await fsp7.unlink(tmpPath).catch(() => void 0);
-      this.handle = await fsp7.open(this.filePath, "a", 384).catch(() => this.handle);
+      await fsp9.unlink(tmpPath).catch(() => void 0);
+      this.handle = await fsp9.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
     await this.append({
@@ -10541,6 +10715,7 @@ var FileSessionWriter = class _FileSessionWriter {
       toPromptIndex: targetPromptIndex,
       revertedFiles: []
     });
+    this.activePromptIndex = targetPromptIndex;
     this.events?.emit("session.rewound", {
       sessionId: this.id,
       toPromptIndex: targetPromptIndex,
@@ -10555,6 +10730,7 @@ var FileSessionWriter = class _FileSessionWriter {
       clearTimeout(this.flushTimer);
       this.flushTimer = null;
     }
+    await this.flushChain;
     this.writeBuffer = [];
     await this.writeChain;
     const record = `${JSON.stringify({
@@ -10565,7 +10741,9 @@ var FileSessionWriter = class _FileSessionWriter {
       provider: this.meta.provider ?? "unknown"
     })}
 `;
-    await fsp7.writeFile(this.filePath, record, "utf8");
+    await fsp9.writeFile(this.filePath, record, "utf8");
+    this.activePromptIndex = null;
+    this.pendingFileSnapshots = [];
   }
   /**
    * Write an in-flight marker. The agent loop should call
@@ -10592,6 +10770,13 @@ var FileSessionWriter = class _FileSessionWriter {
    * cleanly X times, then died without finishing Y".
    */
   async clearInFlightMarker(reason) {
+    if (this.pendingFileSnapshots.length > 0) {
+      await this.writeFileSnapshot(
+        this.activePromptIndex ?? 0,
+        [...this.pendingFileSnapshots]
+      );
+      this.pendingFileSnapshots = [];
+    }
     await this.append({
       type: "in_flight_end",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10601,6 +10786,492 @@ var FileSessionWriter = class _FileSessionWriter {
   }
 };
 
+// src/storage/storage-concurrency.ts
+async function mapWithConcurrency(items, concurrency, mapper) {
+  if (items.length === 0) return [];
+  const limit = Math.max(1, Math.floor(concurrency));
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (true) {
+      const index = next;
+      next++;
+      if (index >= items.length) return;
+      results[index] = await mapper(items[index], index);
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
+// src/storage/session-checkpoint-cas.ts
+var HASH_RE = /^[a-f\d]{64}$/;
+var CAPTURE_CONCURRENCY = 8;
+var MAX_GIT_OUTPUT = 16 * 1024 * 1024;
+var MAX_BLOB_BYTES = 64 * 1024 * 1024;
+var MAX_CHECKPOINT_BYTES = 512 * 1024 * 1024;
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function isInside(root, target) {
+  const relative4 = path9.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path9.isAbsolute(relative4);
+}
+function normalizeRelative(input) {
+  if (!input || path9.isAbsolute(input)) return null;
+  const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
+  const resolved = path9.posix.normalize(normalized);
+  if (!resolved || resolved === "." || resolved === ".." || resolved.startsWith("../")) return null;
+  return resolved;
+}
+function parseNulPaths(output) {
+  return output.split("\0").map(normalizeRelative).filter((value) => value !== null);
+}
+function isWrongStackWorktreePath(relative4) {
+  return relative4 === ".wrongstack/worktrees" || relative4.startsWith(".wrongstack/worktrees/");
+}
+var SessionCheckpointCas = class {
+  rootDir;
+  projectRoot;
+  runGit;
+  constructor(opts) {
+    this.rootDir = path9.resolve(opts.rootDir);
+    this.projectRoot = path9.resolve(opts.projectRoot);
+    this.runGit = opts.runGit ?? defaultRunGit;
+  }
+  async capture(_sessionId, _promptIndex) {
+    const head = await this.runGit(["rev-parse", "--verify", "HEAD"], this.projectRoot);
+    const baseHead = head.stdout.trim();
+    if (head.code !== 0 || head.stdoutTruncated || !/^[a-f\d]{40,64}$/i.test(baseHead)) {
+      return void 0;
+    }
+    const [tracked, untracked] = await Promise.all([
+      this.runGit(["diff", "HEAD", "--name-only", "-z", "--"], this.projectRoot),
+      this.runGit(["ls-files", "--others", "--exclude-standard", "-z"], this.projectRoot)
+    ]);
+    if (tracked.code !== 0 || untracked.code !== 0 || tracked.stdoutTruncated || untracked.stdoutTruncated) {
+      return void 0;
+    }
+    const relativePaths = [
+      .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
+    ].filter((relative4) => !isWrongStackWorktreePath(relative4)).sort();
+    const unresolved = [];
+    let scheduledBytes = 0;
+    const captured = await mapWithConcurrency(
+      relativePaths,
+      CAPTURE_CONCURRENCY,
+      async (relative4) => {
+        const absolute = path9.resolve(this.projectRoot, ...relative4.split("/"));
+        if (!isInside(this.projectRoot, absolute)) {
+          unresolved.push({ path: relative4, reason: "path escapes project root" });
+          return null;
+        }
+        try {
+          const stat9 = await fsp9.lstat(absolute);
+          if (stat9.isSymbolicLink()) {
+            const linkTarget = await fsp9.readlink(absolute);
+            const resolvedLink = path9.resolve(path9.dirname(absolute), linkTarget);
+            if (path9.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
+              unresolved.push({
+                path: relative4,
+                reason: "symlink target escapes project root"
+              });
+              return null;
+            }
+            return { path: relative4, state: "symlink", linkTarget };
+          }
+          if (!stat9.isFile()) {
+            unresolved.push({ path: relative4, reason: "changed path is not a regular file" });
+            return null;
+          }
+          if (stat9.size > MAX_BLOB_BYTES) {
+            unresolved.push({
+              path: relative4,
+              reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
+            });
+            return null;
+          }
+          if (scheduledBytes + stat9.size > MAX_CHECKPOINT_BYTES) {
+            unresolved.push({
+              path: relative4,
+              reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
+            });
+            return null;
+          }
+          scheduledBytes += stat9.size;
+          const content = await fsp9.readFile(absolute);
+          const blobHash = sha256(content);
+          await this.putBlob(blobHash, content);
+          return { path: relative4, state: "file", blobHash, mode: stat9.mode & 511 };
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            return { path: relative4, state: "absent" };
+          }
+          unresolved.push({ path: relative4, reason: toErrorMessage(err) });
+          return null;
+        }
+      }
+    );
+    const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const manifest = {
+      version: 1,
+      baseHead: baseHead.toLowerCase(),
+      coverage: "git-head-plus-dirty",
+      entries: captured.filter((entry) => entry !== null),
+      unresolved: [...unresolved].sort((a, b) => a.path.localeCompare(b.path))
+    };
+    const encoded = JSON.stringify(manifest);
+    const manifestHash = sha256(encoded);
+    await this.putManifest(manifestHash, encoded);
+    return {
+      manifestHash,
+      baseHead: manifest.baseHead,
+      entryCount: manifest.entries.length,
+      unresolvedCount: manifest.unresolved.length,
+      capturedAt,
+      coverage: manifest.coverage
+    };
+  }
+  async materialize(checkpoint, targetRoot) {
+    const target = path9.resolve(targetRoot);
+    if (target === this.projectRoot) {
+      throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
+    }
+    const targetStat = await fsp9.stat(target);
+    if (!targetStat.isDirectory()) throw new Error(`Checkpoint target is not a directory: ${target}`);
+    const manifest = await this.loadManifest(checkpoint.manifestHash);
+    if (manifest.baseHead !== checkpoint.baseHead.toLowerCase() || manifest.coverage !== checkpoint.coverage || manifest.entries.length !== checkpoint.entryCount || manifest.unresolved.length !== checkpoint.unresolvedCount) {
+      throw new Error("Workspace checkpoint reference does not match its CAS manifest");
+    }
+    if (manifest.unresolved.length > 0) {
+      throw new Error(
+        `Workspace checkpoint has ${manifest.unresolved.length} unresolved path(s); exact materialization refused`
+      );
+    }
+    const targetHead = await this.runGit(["rev-parse", "--verify", "HEAD"], target);
+    if (targetHead.code !== 0 || targetHead.stdoutTruncated || targetHead.stdout.trim().toLowerCase() !== manifest.baseHead) {
+      throw new Error(
+        `Checkpoint target HEAD must equal ${manifest.baseHead}; got ${targetHead.stdout.trim() || "unknown"}`
+      );
+    }
+    const targetStatus = await this.runGit(
+      ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignored=matching"],
+      target
+    );
+    if (targetStatus.code !== 0 || targetStatus.stdoutTruncated) {
+      throw new Error("Unable to verify that the checkpoint target is clean");
+    }
+    if (targetStatus.stdout.length > 0) {
+      throw new Error("Checkpoint target must be a clean checkout before materialization");
+    }
+    const realTarget = await fsp9.realpath(target);
+    const writtenFiles = [];
+    const deletedFiles = [];
+    const errors = [];
+    const prepared = [];
+    for (const entry of manifest.entries) {
+      try {
+        const output = await this.safeOutputPath(target, realTarget, entry.path);
+        if (entry.state === "symlink") {
+          if (path9.isAbsolute(entry.linkTarget)) {
+            throw new Error("absolute symlink target refused");
+          }
+          const resolvedLink = path9.resolve(path9.dirname(output), entry.linkTarget);
+          if (!isInside(target, resolvedLink)) throw new Error("symlink target escapes checkpoint root");
+        }
+        prepared.push({
+          entry,
+          output,
+          ...entry.state === "file" ? { content: await this.readBlob(entry.blobHash) } : {}
+        });
+      } catch (err) {
+        errors.push(`${entry.path}: ${toErrorMessage(err)}`);
+      }
+    }
+    if (errors.length > 0) {
+      return { targetRoot: target, writtenFiles, deletedFiles, errors };
+    }
+    for (const { entry, output, content } of prepared) {
+      try {
+        if (entry.state === "absent") {
+          await fsp9.unlink(output).catch((err) => {
+            if (err.code !== "ENOENT") throw err;
+          });
+          deletedFiles.push(entry.path);
+          continue;
+        }
+        if (entry.state === "symlink") {
+          await fsp9.unlink(output).catch((err) => {
+            if (err.code !== "ENOENT") throw err;
+          });
+          await fsp9.mkdir(path9.dirname(output), { recursive: true });
+          await fsp9.symlink(entry.linkTarget, output);
+          writtenFiles.push(entry.path);
+          continue;
+        }
+        if (!content) throw new Error("CAS blob was not prepared");
+        await atomicWrite(output, content, { mode: entry.mode });
+        await fsp9.chmod(output, entry.mode).catch(() => void 0);
+        writtenFiles.push(entry.path);
+      } catch (err) {
+        errors.push(`${entry.path}: ${toErrorMessage(err)}`);
+      }
+    }
+    return { targetRoot: target, writtenFiles, deletedFiles, errors };
+  }
+  objectPath(hash) {
+    if (!HASH_RE.test(hash)) throw new Error(`Invalid CAS object hash: ${hash}`);
+    return path9.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
+  }
+  manifestPath(hash) {
+    if (!HASH_RE.test(hash)) throw new Error(`Invalid checkpoint manifest hash: ${hash}`);
+    return path9.join(this.rootDir, "manifests", `${hash}.json`);
+  }
+  async putBlob(hash, content) {
+    const target = this.objectPath(hash);
+    await fsp9.mkdir(path9.dirname(target), { recursive: true });
+    try {
+      const existing = await fsp9.readFile(target);
+      if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
+      return;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    const temp = path9.join(
+      path9.dirname(target),
+      `.${path9.basename(target)}.${process.pid}.${randomUUID()}.tmp`
+    );
+    let handle;
+    try {
+      handle = await fsp9.open(temp, "wx", 384);
+      await handle.writeFile(content);
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      try {
+        await fsp9.link(temp, target);
+      } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+        const existing = await fsp9.readFile(target);
+        if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
+      }
+    } finally {
+      await handle?.close().catch(() => void 0);
+      await fsp9.unlink(temp).catch(() => void 0);
+    }
+  }
+  async putManifest(hash, encoded) {
+    const target = this.manifestPath(hash);
+    const existing = await fsp9.readFile(target).catch(() => null);
+    if (existing) {
+      if (sha256(existing) !== hash) throw new Error(`Corrupt checkpoint manifest collision: ${hash}`);
+      return;
+    }
+    await atomicWrite(target, encoded, { mode: 384 });
+  }
+  async readBlob(hash) {
+    const content = await fsp9.readFile(this.objectPath(hash));
+    if (sha256(content) !== hash) throw new Error(`CAS blob integrity check failed: ${hash}`);
+    return content;
+  }
+  async loadManifest(hash) {
+    const raw = await fsp9.readFile(this.manifestPath(hash));
+    if (sha256(raw) !== hash) throw new Error(`Checkpoint manifest integrity check failed: ${hash}`);
+    const parsed = JSON.parse(raw.toString("utf8"));
+    if (parsed.version !== 1 || typeof parsed.baseHead !== "string" || parsed.coverage !== "git-head-plus-dirty" || !Array.isArray(parsed.entries) || !Array.isArray(parsed.unresolved)) {
+      throw new Error(`Invalid workspace checkpoint manifest: ${hash}`);
+    }
+    const entriesValid = parsed.entries.every((entry) => {
+      if (!entry || typeof entry !== "object") return false;
+      const candidate = entry;
+      if (typeof candidate.path !== "string" || !normalizeRelative(candidate.path)) return false;
+      if (candidate.state === "absent") return true;
+      if (candidate.state === "symlink") return typeof candidate.linkTarget === "string";
+      return candidate.state === "file" && typeof candidate.blobHash === "string" && HASH_RE.test(candidate.blobHash) && typeof candidate.mode === "number" && Number.isInteger(candidate.mode) && candidate.mode >= 0 && candidate.mode <= 511;
+    });
+    const unresolvedValid = parsed.unresolved.every(
+      (entry) => entry !== null && typeof entry === "object" && typeof entry.path === "string" && typeof entry.reason === "string"
+    );
+    if (!entriesValid || !unresolvedValid) {
+      throw new Error(`Invalid workspace checkpoint manifest entries: ${hash}`);
+    }
+    return parsed;
+  }
+  async safeOutputPath(target, realTarget, relative4) {
+    const normalized = normalizeRelative(relative4);
+    if (!normalized) throw new Error("invalid relative path");
+    const output = path9.resolve(target, ...normalized.split("/"));
+    if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
+    let probe = output;
+    for (; ; ) {
+      try {
+        const real = await fsp9.realpath(probe);
+        if (!isInside(realTarget, real)) throw new Error("path resolves through a symlink outside checkpoint target");
+        return output;
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+        const parent = path9.dirname(probe);
+        if (parent === probe) throw err;
+        probe = parent;
+      }
+    }
+  }
+};
+function defaultRunGit(args, cwd) {
+  return new Promise((resolve9) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    const child = spawn("git", args, {
+      cwd,
+      env: buildChildEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: AbortSignal.timeout(3e4),
+      windowsHide: true
+    });
+    child.stdout?.on("data", (chunk) => {
+      const remaining = MAX_GIT_OUTPUT - stdoutBytes;
+      if (remaining <= 0) {
+        stdoutTruncated = true;
+        return;
+      }
+      const kept = chunk.subarray(0, remaining);
+      stdoutChunks.push(kept);
+      stdoutBytes += kept.length;
+      if (kept.length < chunk.length) stdoutTruncated = true;
+    });
+    child.stderr?.on("data", (chunk) => {
+      const remaining = MAX_GIT_OUTPUT - stderrBytes;
+      if (remaining <= 0) {
+        stderrTruncated = true;
+        return;
+      }
+      const kept = chunk.subarray(0, remaining);
+      stderrChunks.push(kept);
+      stderrBytes += kept.length;
+      if (kept.length < chunk.length) stderrTruncated = true;
+    });
+    const result = (code, extraStderr) => ({
+      code,
+      stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+      stderr: `${Buffer.concat(stderrChunks).toString("utf8")}${extraStderr ?? ""}`,
+      stdoutTruncated,
+      stderrTruncated
+    });
+    child.on("error", (err) => resolve9(result(1, err.message)));
+    child.on("close", (code) => resolve9(result(code ?? 1)));
+  });
+}
+var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
+var VALIDATION_CONCURRENCY = 8;
+var NOTICE_PATH_LIMIT = 20;
+function isInside2(root, target) {
+  const relative4 = path9.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path9.isAbsolute(relative4);
+}
+function errno(err) {
+  return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
+}
+function latestObservations(events, projectRoot) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "file_observation" || typeof event.path !== "string" || event.path.length === 0 || typeof event.hash !== "string" || !/^[a-f\d]{64}$/i.test(event.hash)) {
+      continue;
+    }
+    const normalized = path9.resolve(projectRoot, event.path);
+    latest.set(normalized, {
+      path: normalized,
+      hash: event.hash.toLowerCase(),
+      ts: event.ts
+    });
+  }
+  return [...latest.values()];
+}
+async function validateOne(observation, lexicalRoot, realRoot) {
+  const base = {
+    path: observation.path,
+    observedAt: observation.ts,
+    expectedHash: observation.hash
+  };
+  if (!isInside2(lexicalRoot, observation.path)) {
+    return {
+      ...base,
+      status: "outside_project",
+      detail: "Recorded path is outside the active project root."
+    };
+  }
+  let realFile;
+  try {
+    realFile = await fsp9.realpath(observation.path);
+  } catch (err) {
+    if (errno(err) === "ENOENT") return { ...base, status: "deleted" };
+    return { ...base, status: "unreadable", detail: toErrorMessage(err) };
+  }
+  if (!isInside2(realRoot, realFile)) {
+    return {
+      ...base,
+      status: "outside_project",
+      detail: "Recorded path resolves through a symlink outside the active project root."
+    };
+  }
+  try {
+    const stat9 = await fsp9.stat(realFile);
+    if (!stat9.isFile()) {
+      return { ...base, status: "unreadable", detail: "Path is no longer a regular file." };
+    }
+    if (stat9.size > MAX_REVALIDATE_BYTES) {
+      return {
+        ...base,
+        status: "unreadable",
+        detail: `File now exceeds the ${MAX_REVALIDATE_BYTES}-byte validation limit.`
+      };
+    }
+    const content = await fsp9.readFile(realFile, "utf8");
+    const actualHash = createHash("sha256").update(content, "utf8").digest("hex");
+    if (actualHash === observation.hash) return null;
+    return { ...base, status: "modified", actualHash };
+  } catch (err) {
+    if (errno(err) === "ENOENT") return { ...base, status: "deleted" };
+    return { ...base, status: "unreadable", detail: toErrorMessage(err) };
+  }
+}
+async function validateResumeFileObservations(events, projectRoot) {
+  const lexicalRoot = path9.resolve(projectRoot);
+  const realRoot = await fsp9.realpath(lexicalRoot).catch(() => lexicalRoot);
+  const observations = latestObservations(events, lexicalRoot);
+  const results = await mapWithConcurrency(
+    observations,
+    VALIDATION_CONCURRENCY,
+    (observation) => validateOne(observation, lexicalRoot, realRoot)
+  );
+  return {
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checkedFileCount: observations.length,
+    staleFiles: results.filter((entry) => entry !== null)
+  };
+}
+function formatResumeValidationNotice(validation, projectRoot) {
+  if (validation.staleFiles.length === 0) return null;
+  const root = path9.resolve(projectRoot);
+  const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
+    const relative4 = path9.relative(root, entry.path);
+    const display = isInside2(root, entry.path) ? relative4 || "." : entry.path;
+    return `- ${JSON.stringify(display)} [${entry.status}]`;
+  });
+  const omitted = validation.staleFiles.length - shown.length;
+  if (omitted > 0) shown.push(`- ... and ${omitted} more stale path(s)`);
+  return [
+    "[SESSION RESUME FILE VALIDATION]",
+    `Journal hash validation found ${validation.staleFiles.length} previously observed file(s) whose current state cannot be trusted.`,
+    "Prior tool results and reasoning based on these paths are stale. Re-read each relevant file before relying on it or editing it.",
+    ...shown
+  ].join("\n");
+}
+
 // src/storage/session-id.ts
 function generateSessionId(startedAt, _model) {
   const date = startedAt.slice(0, 10);
@@ -10645,30 +11316,52 @@ function extractToolCallEnds(events) {
   return out;
 }
 
-// src/storage/storage-concurrency.ts
-async function mapWithConcurrency(items, concurrency, mapper) {
-  if (items.length === 0) return [];
-  const limit = Math.max(1, Math.floor(concurrency));
-  const results = new Array(items.length);
-  let next = 0;
-  async function worker() {
-    while (true) {
-      const index = next;
-      next++;
-      if (index >= items.length) return;
-      results[index] = await mapper(items[index], index);
+// src/storage/session-store.ts
+function isReplayableMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return (candidate.role === "user" || candidate.role === "assistant" || candidate.role === "system") && (typeof candidate.content === "string" || Array.isArray(candidate.content));
+}
+function applyContextSnapshot(target, openToolUses, snapshot) {
+  if (!Array.isArray(snapshot) || !snapshot.every(isReplayableMessage)) return false;
+  target.length = 0;
+  openToolUses.clear();
+  for (const raw of snapshot) {
+    const { _estTokens: _ignored, ...message } = raw;
+    target.push(message);
+    if (!Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (block.type === "tool_use") openToolUses.add(block.id);
+      else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
     }
   }
-  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
+  return true;
+}
+function inheritsIntoFork(event) {
+  switch (event.type) {
+    case "session_start":
+    case "session_resumed":
+    case "session_forked":
+    case "session_end":
+    case "in_flight_start":
+    case "in_flight_end":
+    case "rewound":
+      return false;
+    // Parent snapshots describe mutations owned by the parent journal. A
+    // child that shares the current workspace must not inherit authority to
+    // rewind those historical side effects.
+    case "file_snapshot":
+      return false;
+    default:
+      return true;
+  }
 }
-
-// src/storage/session-store.ts
 var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
+  projectRoot;
+  checkpointCas;
   isSessionInUse;
   /**
    * In-memory cache for load() results, keyed by session ID. The cache is
@@ -10687,6 +11380,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
   static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
+    this.projectRoot = opts.projectRoot ? path9.resolve(opts.projectRoot) : void 0;
+    this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
+      rootDir: path9.join(this.dir, "_cas"),
+      projectRoot: this.projectRoot
+    }) : void 0;
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
     this.isSessionInUse = opts.isSessionInUse;
@@ -10738,17 +11436,17 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   /** Absolute path to the session index file. */
   get indexFile() {
-    return path10.join(this.dir, "_index.jsonl");
+    return path9.join(this.dir, "_index.jsonl");
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
     return sessionScopedPath(this.dir, id, ext);
   }
   shardManifestPath(shardKey) {
-    return shardKey ? path10.join(this.dir, shardKey, "_manifest.json") : path10.join(this.dir, "_manifest.json");
+    return shardKey ? path9.join(this.dir, shardKey, "_manifest.json") : path9.join(this.dir, "_manifest.json");
   }
   shardKeyForSessionId(id) {
-    const dirName = path10.dirname(id);
+    const dirName = path9.dirname(id);
     return dirName === "." ? "" : dirName;
   }
   invalidateShardManifestBySessionId(id) {
@@ -10760,7 +11458,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * subdirectory so sessions group naturally by day.
    */
   async ensureShardDir(id) {
-    const dirPath = path10.dirname(sessionScopedPath(this.dir, id, ""));
+    const dirPath = path9.dirname(sessionScopedPath(this.dir, id, ""));
     await ensureDir(dirPath);
     return dirPath;
   }
@@ -10772,7 +11470,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const t0 = Date.now();
     let handle;
     try {
-      handle = await fsp7.open(file, "a", 384);
+      handle = await fsp9.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "create", toErrorMessage(err), false);
       throw new Error(
@@ -10785,6 +11483,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         dir: shardDir,
         filePath: file,
         secretScrubber: this.secretScrubber,
+        checkpointCas: this.checkpointCas,
         onClose: (s) => this.appendToIndex(s)
       });
       this.emitWrite(id, file, "create", "success", Date.now() - t0);
@@ -10800,13 +11499,99 @@ var DefaultSessionStore = class _DefaultSessionStore {
       throw err;
     }
   }
+  async fork(id, opts = {}) {
+    const parent = await this.load(id);
+    let boundary = parent.events.length - 1;
+    let targetCheckpoint;
+    if (opts.checkpointPromptIndex !== void 0) {
+      boundary = -1;
+      for (let i = 0; i < parent.events.length; i++) {
+        const event = parent.events[i];
+        if (event?.type === "checkpoint" && event.promptIndex === opts.checkpointPromptIndex) {
+          boundary = i;
+          targetCheckpoint = event;
+        }
+      }
+      if (boundary === -1) {
+        throw new Error(
+          `Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`
+        );
+      }
+    }
+    const parentPrefix = parent.events.slice(0, boundary + 1);
+    const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
+    const checkpointHash = createHash("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
+    const inherited = parentPrefix.filter(inheritsIntoFork);
+    const writer = await this.create({
+      id: "",
+      title: parent.metadata.title,
+      model: parent.metadata.model,
+      provider: parent.metadata.provider
+    });
+    try {
+      await writer.append({
+        type: "session_forked",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        parentSessionId: id,
+        parentCheckpointPromptIndex: opts.checkpointPromptIndex,
+        parentCheckpointHash: checkpointHash,
+        workspace: "shared-current",
+        workspaceCheckpointHash: workspaceCheckpoint?.manifestHash
+      });
+      const batchSize = 250;
+      for (let offset = 0; offset < inherited.length; offset += batchSize) {
+        await writer.appendBatch(inherited.slice(offset, offset + batchSize));
+      }
+      await writer.flush();
+      await writer.close();
+      const data = await this.load(writer.id);
+      return {
+        id: writer.id,
+        data,
+        parentSessionId: id,
+        checkpointPromptIndex: opts.checkpointPromptIndex,
+        checkpointHash,
+        workspace: "shared-current",
+        workspaceCheckpoint
+      };
+    } catch (err) {
+      await writer.close().catch(() => void 0);
+      await this.delete(writer.id).catch(() => void 0);
+      throw err;
+    }
+  }
+  async materializeWorkspaceCheckpoint(checkpoint, targetRoot) {
+    if (!this.checkpointCas) {
+      throw new Error("Workspace checkpoint materialization requires a projectRoot-aware session store");
+    }
+    return this.checkpointCas.materialize(checkpoint, targetRoot);
+  }
   async resume(id) {
     const file = this.sessionPath(id, ".jsonl");
     const t0 = Date.now();
     const data = await this.load(id);
+    let resumedData = data;
+    if (this.projectRoot) {
+      try {
+        const resumeValidation = await validateResumeFileObservations(data.events, this.projectRoot);
+        const notice = formatResumeValidationNotice(resumeValidation, this.projectRoot);
+        resumedData = {
+          ...data,
+          resumeValidation,
+          ...notice ? {
+            messages: [
+              ...data.messages,
+              { role: "system", content: notice, ts: resumeValidation.checkedAt }
+            ]
+          } : {}
+        };
+      } catch (err) {
+        this.emitError(id, file, "resume_validation", toErrorMessage(err), true);
+      }
+    }
     let handle;
     try {
-      handle = await fsp7.open(file, "a", 384);
+      handle = await fsp9.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "resume", toErrorMessage(err), false);
       throw new Error(
@@ -10830,14 +11615,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
           // Shard directory (sessions/<date>/) — must match create() so the
           // .summary.json sidecar lands next to the JSONL instead of the
           // sessions root (where summaryFor() would never find it).
-          dir: path10.dirname(file),
+          dir: path9.dirname(file),
           filePath: file,
           secretScrubber: this.secretScrubber,
+          checkpointCas: this.checkpointCas,
           onClose: (s) => this.appendToIndex(s)
         }
       );
       this.emitWrite(id, file, "resume", "success", Date.now() - t0);
-      return { writer, data };
+      return { writer, data: resumedData };
     } catch (err) {
       await handle.close().catch((e) => console.warn(JSON.stringify({
         level: "warn",
@@ -10876,10 +11662,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let errorMsg;
     let cacheHit = false;
     try {
-      const s = await fsp7.stat(file);
-      const stat8 = { mtimeMs: s.mtimeMs, size: s.size };
+      const s = await fsp9.stat(file);
+      const stat9 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat8.mtimeMs && cached.size === stat8.size) {
+      if (cached && cached.mtimeMs === stat9.mtimeMs && cached.size === stat9.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
@@ -10892,6 +11678,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       let sessionModel;
       let sessionProvider;
       let sessionPendingToolUses;
+      let sessionForkedEvent;
       const messages = mode.full ? [] : void 0;
       const openToolUses = mode.full ? /* @__PURE__ */ new Set() : void 0;
       let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
@@ -10914,8 +11701,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
                 sessionEndEvent = ev;
                 sessionPendingToolUses = ev.pendingToolUses;
               }
+              if (ev.type === "session_forked" && !sessionForkedEvent) {
+                sessionForkedEvent = ev;
+              }
               if (mode.full && messages !== void 0 && openToolUses !== void 0) {
-                if (ev.type === "user_input") {
+                if (ev.type === "context_snapshot") {
+                  if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: "Ignored malformed context_snapshot event"
+                    });
+                  }
+                } else if (ev.type === "user_input") {
                   openToolUses.clear();
                   messages.push({ role: "user", content: ev.content, ts: ev.ts });
                 } else if (ev.type === "llm_response") {
@@ -10991,7 +11788,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
         endedAt: sessionEndEvent?.ts,
         model: sessionModel,
         provider: sessionProvider,
-        pendingToolUses: sessionPendingToolUses
+        pendingToolUses: sessionPendingToolUses,
+        forkedFrom: sessionForkedEvent ? {
+          sessionId: sessionForkedEvent.parentSessionId,
+          checkpointPromptIndex: sessionForkedEvent.parentCheckpointPromptIndex,
+          checkpointHash: sessionForkedEvent.parentCheckpointHash,
+          workspace: sessionForkedEvent.workspace,
+          workspaceCheckpointHash: sessionForkedEvent.workspaceCheckpointHash
+        } : void 0
       };
       const toolCallEnds = extractToolCallEnds(events);
       const data = { metadata: meta, events, messages: finalMessages, usage, toolCallEnds };
@@ -11002,7 +11806,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
             this._loadCache.delete(oldest);
           }
         }
-        this._loadCache.set(id, { mtimeMs: stat8.mtimeMs, size: stat8.size, data });
+        this._loadCache.set(id, { mtimeMs: stat9.mtimeMs, size: stat9.size, data });
       }
       return data;
     } catch (err) {
@@ -11044,17 +11848,17 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = opts?.limit;
     const signal = opts?.signal;
     const out = [];
-    let stat8;
+    let stat9;
     try {
-      stat8 = await fsp7.stat(file);
+      stat9 = await fsp9.stat(file);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
-    if (stat8.size === 0) return [];
+    if (stat9.size === 0) return [];
     let fh;
     try {
-      fh = await fsp7.open(file, "r");
+      fh = await fsp9.open(file, "r");
       const CHUNK = 64 * 1024;
       const buf = Buffer.alloc(CHUNK);
       let leftover = "";
@@ -11167,7 +11971,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       let shouldCompact = false;
       await withFileLock(this.indexFile, async () => {
         const line = JSON.stringify(summary) + "\n";
-        await fsp7.appendFile(this.indexFile, line, "utf8");
+        await fsp9.appendFile(this.indexFile, line, "utf8");
         this._indexCache = null;
         this.invalidateShardManifestBySessionId(summary.id);
         this.indexAppendCount++;
@@ -11188,7 +11992,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await ensureDir(this.dir);
       await withFileLock(this.indexFile, async () => {
         const line = JSON.stringify({ action: "delete", id }) + "\n";
-        await fsp7.appendFile(this.indexFile, line, "utf8");
+        await fsp9.appendFile(this.indexFile, line, "utf8");
         this._indexCache = null;
         this.invalidateShardManifestBySessionId(id);
         this.indexAppendCount++;
@@ -11234,20 +12038,20 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
-    let stat8;
+    let stat9;
     try {
-      const s = await fsp7.stat(this.indexFile);
-      stat8 = { mtimeMs: s.mtimeMs, size: s.size };
+      const s = await fsp9.stat(this.indexFile);
+      stat9 = { mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       this._indexCache = null;
       return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat8.mtimeMs && this._indexCache.size === stat8.size) {
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat9.mtimeMs && this._indexCache.size === stat9.size) {
       return [...this._indexCache.summaries];
     }
     let raw;
     try {
-      raw = await fsp7.readFile(this.indexFile, "utf8");
+      raw = await fsp9.readFile(this.indexFile, "utf8");
     } catch {
       this._indexCache = null;
       return [];
@@ -11275,7 +12079,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (a.startedAt > b.startedAt) return -1;
       return a.id.localeCompare(b.id);
     });
-    this._indexCache = { ...stat8, summaries };
+    this._indexCache = { ...stat9, summaries };
     return [...summaries];
   }
   /**
@@ -11318,7 +12122,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async collectShardKeys() {
     let entries;
     try {
-      entries = await fsp7.readdir(this.dir, { withFileTypes: true });
+      entries = await fsp9.readdir(this.dir, { withFileTypes: true });
     } catch {
       return [""];
     }
@@ -11335,7 +12139,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (cached) return cached;
     const manifestPath = this.shardManifestPath(shardKey);
     try {
-      const raw = await fsp7.readFile(manifestPath, "utf8");
+      const raw = await fsp9.readFile(manifestPath, "utf8");
       const parsed = JSON.parse(raw);
       const entry2 = {
         summaries: Array.isArray(parsed.summaries) ? parsed.summaries : [],
@@ -11366,14 +12170,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return entry;
   }
   async collectSessionFilesInShard(shardKey) {
-    const dir = shardKey ? path10.join(this.dir, shardKey) : this.dir;
+    const dir = shardKey ? path9.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
     return shardKey ? entries.filter((entry) => entry.id.startsWith(`${shardKey}/`)) : entries.filter((entry) => !entry.id.includes("/"));
   }
   async collectSessionFiles(dir, prefix = "", depth = 0) {
     let entries;
     try {
-      entries = await fsp7.readdir(dir, { withFileTypes: true });
+      entries = await fsp9.readdir(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -11389,13 +12193,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
         if (entry.name === "_index.jsonl") continue;
         const base = entry.name.replace(/\.jsonl$/, "");
         const id = prefix ? `${prefix}/${base}` : base;
-        files.push({ id, filePath: path10.join(dir, entry.name) });
+        files.push({ id, filePath: path9.join(dir, entry.name) });
       }
     }
     const childFileArrays = await Promise.all(
       dirEntries.map((entry) => {
         const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionFiles(path10.join(dir, entry.name), childPrefix, depth + 1);
+        return this.collectSessionFiles(path9.join(dir, entry.name), childPrefix, depth + 1);
       })
     );
     return [...childFileArrays.flat(), ...files];
@@ -11407,7 +12211,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async collectSessionIds(dir, prefix = "", depth = 0) {
     let entries;
     try {
-      entries = await fsp7.readdir(dir, { withFileTypes: true });
+      entries = await fsp9.readdir(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -11428,7 +12232,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const childIdArrays = await Promise.all(
       dirEntries.map((entry) => {
         const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionIds(path10.join(dir, entry.name), childPrefix, depth + 1);
+        return this.collectSessionIds(path9.join(dir, entry.name), childPrefix, depth + 1);
       })
     );
     return [...childIdArrays.flat(), ...fileIds];
@@ -11442,8 +12246,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (fromManifest) return fromManifest;
     try {
       const full = this.sessionPath(id, ".jsonl");
-      const stat8 = await fsp7.stat(full);
-      const summary = await this.summarize(id, stat8.mtime.toISOString());
+      const stat9 = await fsp9.stat(full);
+      const summary = await this.summarize(id, stat9.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -11476,7 +12280,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async readSummaryManifest(id, startTime = Date.now()) {
     const manifest = this.sessionPath(id, ".summary.json");
     try {
-      const raw = await fsp7.readFile(manifest, "utf8");
+      const raw = await fsp9.readFile(manifest, "utf8");
       this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
       return JSON.parse(raw);
     } catch {
@@ -11486,18 +12290,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async summaryHeaderFor(ref) {
     let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const stat8 = await fsp7.stat(ref.filePath);
-      if (!stat8.isFile()) {
+      const stat9 = await fsp9.stat(ref.filePath);
+      if (!stat9.isFile()) {
         return {
           id: ref.id,
           title: "(damaged)",
-          startedAt: stat8.mtime.toISOString(),
+          startedAt: stat9.mtime.toISOString(),
           model: "unknown",
           provider: "unknown",
           tokenTotal: 0
         };
       }
-      mtime = stat8.mtime.toISOString();
+      mtime = stat9.mtime.toISOString();
     } catch {
       return null;
     }
@@ -11545,15 +12349,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async deleteSession(id) {
     const jsonlPath = this.sessionPath(id, ".jsonl");
     const summaryPath = this.sessionPath(id, ".summary.json");
-    const shardDir = path10.dirname(jsonlPath);
-    const base = path10.basename(id);
-    const sessDir = path10.join(shardDir, base);
+    const shardDir = path9.dirname(jsonlPath);
+    const base = path9.basename(id);
+    const sessDir = path9.join(shardDir, base);
     const deletions = [
-      fsp7.unlink(jsonlPath),
-      fsp7.unlink(summaryPath),
-      fsp7.unlink(sessionScopedPath(this.dir, id, ".plan.json")),
-      fsp7.unlink(sessionScopedPath(this.dir, id, ".tasks.json")),
-      fsp7.unlink(sessionScopedPath(this.dir, id, ".todos.json"))
+      fsp9.unlink(jsonlPath),
+      fsp9.unlink(summaryPath),
+      fsp9.unlink(sessionScopedPath(this.dir, id, ".plan.json")),
+      fsp9.unlink(sessionScopedPath(this.dir, id, ".tasks.json")),
+      fsp9.unlink(sessionScopedPath(this.dir, id, ".todos.json"))
     ];
     const results = await Promise.allSettled(deletions);
     for (const r of results) {
@@ -11570,7 +12374,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         }
       }
     }
-    await fsp7.rm(sessDir, { recursive: true, force: true }).catch((err) => {
+    await fsp9.rm(sessDir, { recursive: true, force: true }).catch((err) => {
       console.warn(JSON.stringify({
         level: "warn",
         event: "session_store.rmdir_failed",
@@ -11588,7 +12392,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async readActiveSessionId() {
     try {
-      const raw = await fsp7.readFile(path10.join(this.dir, "active.json"), "utf8");
+      const raw = await fsp9.readFile(path9.join(this.dir, "active.json"), "utf8");
       const active = JSON.parse(raw);
       return active.sessionId ?? null;
     } catch {
@@ -11615,7 +12419,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const manifest = this.sessionPath(id, ".summary.json");
     const jsonlPath = this.sessionPath(id, ".jsonl");
     try {
-      await fsp7.stat(jsonlPath);
+      await fsp9.stat(jsonlPath);
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") {
@@ -11651,10 +12455,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const activeSessionId = await this.readActiveSessionId();
     const isPrunableJsonl = (name) => name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
     const pruneFile = async (dir, name, prefix) => {
-      const jsonlPath = path10.join(dir, name);
+      const jsonlPath = path9.join(dir, name);
       try {
-        const stat8 = await fsp7.stat(jsonlPath);
-        if (stat8.mtimeMs >= cutoff) return;
+        const stat9 = await fsp9.stat(jsonlPath);
+        if (stat9.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -11664,15 +12468,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await this.deleteSession(id);
       deleted++;
     };
-    const entries = await fsp7.readdir(this.dir, { withFileTypes: true }).catch(() => []);
+    const entries = await fsp9.readdir(this.dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isFile()) {
         if (isPrunableJsonl(entry.name)) await pruneFile(this.dir, entry.name, "");
         continue;
       }
       if (!entry.isDirectory()) continue;
-      const dateDir = path10.join(this.dir, entry.name);
-      const files = await fsp7.readdir(dateDir, { withFileTypes: true }).catch(() => []);
+      const dateDir = path9.join(this.dir, entry.name);
+      const files = await fsp9.readdir(dateDir, { withFileTypes: true }).catch(() => []);
       for (const file of files) {
         if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
         await pruneFile(dateDir, file.name, entry.name);
@@ -11683,11 +12487,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const dateDir = path10.join(this.dir, entry.name);
+      const dateDir = path9.join(this.dir, entry.name);
       try {
-        const remaining = await fsp7.readdir(dateDir);
+        const remaining = await fsp9.readdir(dateDir);
         if (remaining.length === 0) {
-          await fsp7.rmdir(dateDir).catch(() => void 0);
+          await fsp9.rmdir(dateDir).catch(() => void 0);
         }
       } catch {
       }
@@ -11706,8 +12510,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       provider: "unknown"
     })}
 `;
-    await fsp7.writeFile(file, record, "utf8");
-    await fsp7.unlink(meta).catch(() => void 0);
+    await fsp9.writeFile(file, record, "utf8");
+    await fsp9.unlink(meta).catch(() => void 0);
   }
   async summarize(id, mtime) {
     try {
@@ -11814,9 +12618,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path10.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path9.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path10.join(opts.sessionsRoot, runId);
+    dir = path9.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -11862,6 +12666,8 @@ var FleetManager = class {
   /** Fleet-wide cost cap. Infinity = no cap. Distinct from SubagentBudget limits,
    *  which track per-subagent spend — this field caps the entire fleet total. */
   maxFleetCostUsd;
+  /** Fleet-wide input+output token ceiling. Infinity = no cap. */
+  maxFleetTokens;
   manifestEntries = /* @__PURE__ */ new Map();
   /** Pending tasks with their descriptions — populated by `addPendingTask`
    *  and cleared by `removePendingTask`. Replaces the host-side `pending`
@@ -11883,11 +12689,12 @@ var FleetManager = class {
     this.manifestPath = opts.manifestPath;
     this.directorRunId = opts.directorRunId ?? randomUUID();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
-    this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
+    this.maxSpawnDepth = resolveMaxSpawnDepth(opts.maxSpawnDepth);
     this.spawnDepth = opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxFleetTokens = opts.directorBudget?.maxTokens ?? Number.POSITIVE_INFINITY;
     this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
     this.maxContext = opts.maxContext ?? 128e3;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(
@@ -11956,6 +12763,13 @@ var FleetManager = class {
         return { kind: "max_cost_usd", limit: this.maxFleetCostUsd, observed: totalCost };
       }
     }
+    if (this.maxFleetTokens < Number.POSITIVE_INFINITY) {
+      const total = this.usage.snapshot().total;
+      const usedTokens = (total?.input ?? 0) + (total?.output ?? 0);
+      if (usedTokens >= this.maxFleetTokens) {
+        return { kind: "max_tokens", limit: this.maxFleetTokens, observed: usedTokens };
+      }
+    }
     if (this.maxLeaderContextLoad < 1) {
       const maxContext = this.resolveMaxContext();
       const threshold = maxContext * this.maxLeaderContextLoad;
@@ -11969,6 +12783,22 @@ var FleetManager = class {
     }
     return null;
   }
+  budgetSnapshot() {
+    const total = this.usage.snapshot().total;
+    const usedTokens = (total?.input ?? 0) + (total?.output ?? 0);
+    const usedCostUsd = total?.cost ?? 0;
+    return {
+      maxSpawns: this.maxSpawns,
+      usedSpawns: this.spawnCount,
+      remainingSpawns: Math.max(0, this.maxSpawns - this.spawnCount),
+      maxTokens: this.maxFleetTokens,
+      usedTokens,
+      remainingTokens: Math.max(0, this.maxFleetTokens - usedTokens),
+      maxCostUsd: this.maxFleetCostUsd,
+      usedCostUsd,
+      remainingCostUsd: Math.max(0, this.maxFleetCostUsd - usedCostUsd)
+    };
+  }
   setLeaderContextPressure(tokens) {
     this.leaderContextPressure = tokens;
   }
@@ -12072,7 +12902,7 @@ var FleetManager = class {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp7.mkdir(path10.dirname(this.manifestPath), { recursive: true });
+    await fsp9.mkdir(path9.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -12225,7 +13055,7 @@ var REGISTRY_CACHE_TTL_MS = 2e3;
 var LINE_SEPARATOR = "\n";
 var MESSAGE_CACHE_MAX_ENTRIES = 1e4;
 function resolveProjectDir(projectRoot, globalRoot) {
-  return path10.join(globalRoot, "projects", projectSlug(projectRoot));
+  return path9.join(globalRoot, "projects", projectSlug(projectRoot));
 }
 var GlobalMailbox = class {
   /** Path to the JSONL message file. */
@@ -12289,14 +13119,14 @@ var GlobalMailbox = class {
    * @param hqPublisher — optional HQ publisher, or getter, for cross-project telemetry
    */
   constructor(projectDir, events, hqPublisher) {
-    this.messagePath = path10.join(projectDir, MAILBOX_FILE);
-    this.registryPath = path10.join(projectDir, "_mailbox.registry.json");
-    this.clientRegistryPath = path10.join(projectDir, CLIENT_REGISTRY_FILE);
+    this.messagePath = path9.join(projectDir, MAILBOX_FILE);
+    this.registryPath = path9.join(projectDir, "_mailbox.registry.json");
+    this.clientRegistryPath = path9.join(projectDir, CLIENT_REGISTRY_FILE);
     this._events = events;
     this._hqPublisher = hqPublisher;
   }
   get hqMailboxId() {
-    return `${path10.basename(path10.dirname(this.messagePath))}:mailbox`;
+    return `${path9.basename(path9.dirname(this.messagePath))}:mailbox`;
   }
   get hqPublisher() {
     return typeof this._hqPublisher === "function" ? this._hqPublisher() : this._hqPublisher;
@@ -12333,9 +13163,9 @@ var GlobalMailbox = class {
       taskContext: input.taskContext
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR;
-    await fsp7.mkdir(path10.dirname(this.messagePath), { recursive: true });
+    await fsp9.mkdir(path9.dirname(this.messagePath), { recursive: true });
     await withFileLock(this.messagePath, async () => {
-      await fsp7.appendFile(this.messagePath, line, "utf8");
+      await fsp9.appendFile(this.messagePath, line, "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
       this._pushToCache(msg, mtimeMs, size);
     });
@@ -12406,7 +13236,7 @@ var GlobalMailbox = class {
       }
       if (changed) {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-        await fsp7.writeFile(this.messagePath, serialized, "utf8");
+        await fsp9.writeFile(this.messagePath, serialized, "utf8");
       }
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache(all, mtimeMs, size);
@@ -12448,7 +13278,7 @@ var GlobalMailbox = class {
         updated = m;
       }
       const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-      await fsp7.writeFile(this.messagePath, serialized, "utf8");
+      await fsp9.writeFile(this.messagePath, serialized, "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache(all, mtimeMs, size);
     });
@@ -12473,7 +13303,7 @@ var GlobalMailbox = class {
         updated = m;
       }
       const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-      await fsp7.writeFile(this.messagePath, serialized, "utf8");
+      await fsp9.writeFile(this.messagePath, serialized, "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache(all, mtimeMs, size);
     });
@@ -12720,7 +13550,7 @@ var GlobalMailbox = class {
   }
   async clearAll() {
     await withFileLock(this.messagePath, async () => {
-      await fsp7.writeFile(this.messagePath, "", "utf8");
+      await fsp9.writeFile(this.messagePath, "", "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache([], mtimeMs, size);
     });
@@ -12753,7 +13583,7 @@ var GlobalMailbox = class {
       remaining = kept.length;
       if (kept.length < all.length) {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-        await fsp7.writeFile(this.messagePath, content, "utf8");
+        await fsp9.writeFile(this.messagePath, content, "utf8");
       }
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache(kept, mtimeMs, size);
@@ -12774,7 +13604,7 @@ var GlobalMailbox = class {
    */
   async _readMessages() {
     try {
-      const raw = await fsp7.readFile(this.messagePath, "utf8");
+      const raw = await fsp9.readFile(this.messagePath, "utf8");
       return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
@@ -12867,7 +13697,7 @@ var GlobalMailbox = class {
    */
   async _statMessageFile() {
     try {
-      const st = await fsp7.stat(this.messagePath);
+      const st = await fsp9.stat(this.messagePath);
       return { mtimeMs: st.mtimeMs, size: st.size };
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -12913,12 +13743,12 @@ var GlobalMailbox = class {
    */
   async _readMessagesCachedWork() {
     try {
-      const st = await fsp7.stat(this.messagePath);
+      const st = await fsp9.stat(this.messagePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
       if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
-        const fd = await fsp7.open(this.messagePath, "r");
+        const fd = await fsp9.open(this.messagePath, "r");
         try {
           const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
           this._messageCacheMtime = st.mtimeMs;
@@ -12994,14 +13824,14 @@ var GlobalMailbox = class {
     this._messageCacheSize = size;
   }
   async _ensureRegistry() {
-    await fsp7.mkdir(path10.dirname(this.registryPath), { recursive: true });
+    await fsp9.mkdir(path9.dirname(this.registryPath), { recursive: true });
   }
   async _readRegistry(opts) {
     if (!opts?.fresh && this._registryCache && Date.now() - this._registryCacheAt < REGISTRY_CACHE_TTL_MS) {
       return new Map(this._registryCache);
     }
     try {
-      const raw = await fsp7.readFile(this.registryPath, "utf8");
+      const raw = await fsp9.readFile(this.registryPath, "utf8");
       const data = JSON.parse(raw);
       const map = /* @__PURE__ */ new Map();
       for (const [id, agent] of Object.entries(data)) {
@@ -13044,19 +13874,19 @@ var GlobalMailbox = class {
       obj[id] = agent;
     }
     const tmp = `${this.registryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp7.writeFile(tmp, JSON.stringify(obj), "utf8");
-    await fsp7.rename(tmp, this.registryPath);
+    await fsp9.writeFile(tmp, JSON.stringify(obj), "utf8");
+    await fsp9.rename(tmp, this.registryPath);
   }
   // ── Client registry internals ───────────────────────────────────────────
   async _ensureClientRegistry() {
-    await fsp7.mkdir(path10.dirname(this.clientRegistryPath), { recursive: true });
+    await fsp9.mkdir(path9.dirname(this.clientRegistryPath), { recursive: true });
   }
   async _readClientRegistry(opts) {
     if (!opts?.fresh && this._clientRegistryCache && Date.now() - this._clientRegistryCacheAt < REGISTRY_CACHE_TTL_MS) {
       return new Map(this._clientRegistryCache);
     }
     try {
-      const raw = await fsp7.readFile(this.clientRegistryPath, "utf8");
+      const raw = await fsp9.readFile(this.clientRegistryPath, "utf8");
       const data = JSON.parse(raw);
       const map = /* @__PURE__ */ new Map();
       for (const [id, client] of Object.entries(data)) {
@@ -13089,8 +13919,8 @@ var GlobalMailbox = class {
       obj[id] = client;
     }
     const tmp = `${this.clientRegistryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp7.writeFile(tmp, JSON.stringify(obj), "utf8");
-    await fsp7.rename(tmp, this.clientRegistryPath);
+    await fsp9.writeFile(tmp, JSON.stringify(obj), "utf8");
+    await fsp9.rename(tmp, this.clientRegistryPath);
   }
 };
 function defaultResolveProjectDir(ctx) {
@@ -13484,7 +14314,7 @@ var FleetSupervisor = class {
   // ── observation state ─────────────────────────────────────────────────
   /** taskId → first tick timestamp we saw it pending. */
   pendingSince = /* @__PURE__ */ new Map();
-  /** subagentId → last tool.executed timestamp (fleet-wide activity map). */
+  /** subagentId → last observable fleet event timestamp. */
   lastActivityAt = /* @__PURE__ */ new Map();
   /** subagentId → consecutive non-success completions. */
   failStreaks = /* @__PURE__ */ new Map();
@@ -13502,7 +14332,7 @@ var FleetSupervisor = class {
     if (!this.cfg.enabled || this.timer) return;
     this.stopped = false;
     this.offHandles.push(
-      this.opts.fleet.filter("tool.executed", (e) => {
+      this.opts.fleet.onAny((e) => {
         this.lastActivityAt.set(e.subagentId, this.now());
       })
     );
@@ -13610,7 +14440,7 @@ var FleetSupervisor = class {
     this.backlogTicks = backlogged ? this.backlogTicks + 1 : 0;
     if (backlogged && this.backlogTicks >= 2 && this.cfg.allowSpawn) {
       this.backlogTicks = 0;
-      await this.engageBacklog(pending.length, live);
+      await this.engageBacklog(pending, live);
       return;
     }
     for (const s of running) {
@@ -13695,7 +14525,7 @@ var FleetSupervisor = class {
     };
     const decision = await this.opts.brain.decide(request);
     if (decision.type !== "answer") return { choice: null, decision };
-    const choice = decision.optionId ?? options.find((o) => o.recommended)?.id ?? null;
+    const choice = options.some((option) => option.id === decision.optionId) ? decision.optionId ?? null : null;
     return { choice, decision };
   }
   async engageRebalance(kind, fromWorkerId, tasks, idleWorkerIds) {
@@ -13777,10 +14607,11 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
       this.engaging = false;
     }
   }
-  async engageBacklog(pendingCount, liveWorkers) {
+  async engageBacklog(pending, liveWorkers) {
     if (!this.cooldownOk("backlog", "fleet")) return;
     this.engaging = true;
     try {
+      const pendingCount = pending.length;
       this.emitSignal(
         "backlog",
         `${pendingCount} pending tasks vs ${liveWorkers} live worker(s)`
@@ -13810,7 +14641,8 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
         return;
       }
       const res = await this.opts.actions.spawnHelper({
-        reason: `queue backlog: ${pendingCount} pending / ${liveWorkers} workers`
+        reason: `queue backlog: ${pendingCount} pending / ${liveWorkers} workers`,
+        task: pending[0]
       });
       if ("subagentId" in res) {
         this.emitAction("spawn_helper", true, res.subagentId, res.subagentId);
@@ -13851,11 +14683,11 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
     try {
       this.emitSignal(
         "stuck_agent",
-        `no tool activity for \u2265${Math.round(this.cfg.stuckMs / 1e3)}s`,
+        `no observable activity for \u2265${Math.round(this.cfg.stuckMs / 1e3)}s`,
         s.id
       );
       const { choice, decision } = await this.decide(
-        `Worker ${s.name} (${s.id}) is marked running but produced no tool activity for over ${Math.round(this.cfg.stuckMs / 1e3)}s. Nudge it with a steer message?`,
+        `Worker ${s.name} (${s.id}) is marked running but produced no observable activity for over ${Math.round(this.cfg.stuckMs / 1e3)}s. Nudge it with a steer message?`,
         `Current task: ${s.currentTask ?? "unknown"}`,
         [
           {
@@ -13883,12 +14715,12 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
       await this.opts.actions.steerAgent(
         s.id,
         "Progress check from fleet supervisor",
-        `You appear stalled (no tool activity for ${Math.round(this.cfg.stuckMs / 1e3)}s on: ${s.currentTask ?? "your current task"}). If you are blocked, say so via mail_send to the leader and either narrow the scope or hand the task back \u2014 do not keep silently retrying the same step.`
+        `You appear stalled (no observable activity for ${Math.round(this.cfg.stuckMs / 1e3)}s on: ${s.currentTask ?? "your current task"}). If you are blocked, say so via mail_send to the leader and either narrow the scope or hand the task back \u2014 do not keep silently retrying the same step.`
       );
       this.emitAction("steer", true, "stuck nudge", s.id);
       await this.opts.actions.notifyLeader(
         `Worker ${s.name} may be stuck`,
-        `No tool activity for ${Math.round(this.cfg.stuckMs / 1e3)}s. Supervisor nudged it; consider terminate_subagent + reassigning if it stays silent.`
+        `No observable activity for ${Math.round(this.cfg.stuckMs / 1e3)}s. Supervisor nudged it; consider terminate_subagent + reassigning if it stays silent.`
       ).catch(() => {
       });
       this.record({
@@ -14185,7 +15017,7 @@ var DefaultMailbox = class {
   /** Counts malformed JSONL lines skipped during parsing for observability. */
   _corruptionCount = 0;
   constructor(sessionDir) {
-    this.filePath = path10.join(sessionDir, MAILBOX_FILE2);
+    this.filePath = path9.join(sessionDir, MAILBOX_FILE2);
   }
   get mailboxPath() {
     return this.filePath;
@@ -14214,9 +15046,9 @@ var DefaultMailbox = class {
       taskContext: input.taskContext
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR2;
-    await fsp7.mkdir(path10.dirname(this.filePath), { recursive: true });
+    await fsp9.mkdir(path9.dirname(this.filePath), { recursive: true });
     await withFileLock(this.filePath, async () => {
-      await fsp7.appendFile(this.filePath, line, "utf8");
+      await fsp9.appendFile(this.filePath, line, "utf8");
       this._pushToCache(msg);
       const { mtime, size } = await this._statUnderLockOrAbsent();
       this._messageCacheMtime = mtime;
@@ -14316,7 +15148,7 @@ var DefaultMailbox = class {
       }
       if (changed) {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
-        await fsp7.writeFile(this.filePath, serialized, "utf8");
+        await fsp9.writeFile(this.filePath, serialized, "utf8");
       }
       const { mtime, size } = await this._statUnderLockOrAbsent();
       this._setMessageCache(all, mtime, size);
@@ -14377,7 +15209,7 @@ var DefaultMailbox = class {
   }
   async clearAll() {
     await withFileLock(this.filePath, async () => {
-      await fsp7.writeFile(this.filePath, "", "utf8");
+      await fsp9.writeFile(this.filePath, "", "utf8");
       const { mtime, size } = await this._statUnderLockOrAbsent();
       this._setMessageCache([], mtime, size);
     });
@@ -14410,7 +15242,7 @@ var DefaultMailbox = class {
       remaining = kept.length;
       if (kept.length < all.length) {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
-        await fsp7.writeFile(this.filePath, content, "utf8");
+        await fsp9.writeFile(this.filePath, content, "utf8");
       }
       const { mtime, size } = await this._statUnderLockOrAbsent();
       this._setMessageCache(kept, mtime, size);
@@ -14433,7 +15265,7 @@ var DefaultMailbox = class {
   // ── Internal ──────────────────────────────────────────────────────────
   async _readAll() {
     try {
-      const raw = await fsp7.readFile(this.filePath, "utf8");
+      const raw = await fsp9.readFile(this.filePath, "utf8");
       return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
@@ -14508,7 +15340,7 @@ var DefaultMailbox = class {
    */
   async _statUnderLockOrAbsent() {
     try {
-      const st = await fsp7.stat(this.filePath);
+      const st = await fsp9.stat(this.filePath);
       return { mtime: st.mtimeMs, size: st.size };
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -14519,12 +15351,12 @@ var DefaultMailbox = class {
   }
   async _readAllCached() {
     try {
-      const st = await fsp7.stat(this.filePath);
+      const st = await fsp9.stat(this.filePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
       if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
-        const fd = await fsp7.open(this.filePath, "r");
+        const fd = await fsp9.open(this.filePath, "r");
         try {
           const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
           this._messageCacheMtime = st.mtimeMs;
@@ -14866,11 +15698,11 @@ var NULL_FLEET_BUS = new FleetBus();
 var DEFAULT_MAX_ENTRIES = 1e4;
 var LOG_FILENAME = "package-authors.json";
 function logPath(storageDir) {
-  return path10.join(storageDir, LOG_FILENAME);
+  return path9.join(storageDir, LOG_FILENAME);
 }
 async function loadLog(storageDir, projectRoot) {
   try {
-    const raw = await fsp7.readFile(logPath(storageDir), "utf-8");
+    const raw = await fsp9.readFile(logPath(storageDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.entries || !Array.isArray(parsed.entries)) {
       return { projectRoot, entries: [] };
@@ -14884,13 +15716,13 @@ async function loadLog(storageDir, projectRoot) {
   }
 }
 async function saveLog(storageDir, log) {
-  await fsp7.mkdir(storageDir, { recursive: true });
+  await fsp9.mkdir(storageDir, { recursive: true });
   const tmp = `${logPath(storageDir)}.tmp.${Date.now()}`;
-  await fsp7.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
-  await fsp7.rename(tmp, logPath(storageDir));
+  await fsp9.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
+  await fsp9.rename(tmp, logPath(storageDir));
 }
 function detectEcosystem(manifestPath) {
-  const name = path10.basename(manifestPath).toLowerCase();
+  const name = path9.basename(manifestPath).toLowerCase();
   if (name === "package.json") return "npm";
   if (name === "go.mod") return "go";
   if (name === "cargo.toml") return "cargo";
@@ -15138,8 +15970,8 @@ mvn versions:use-latest-versions`;
 var MAILBOX_BRIDGE_LOCK_FILENAME = ".mailbox-bridge.lock";
 var MAILBOX_BRIDGE_TOKEN_FILENAME = ".mailbox.token";
 async function acquireOrJoin(opts) {
-  const lockPath = path10.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path10.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path9.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path9.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const inspected = await readLockForInspection(lockPath);
   if (inspected.kind === "live") {
     const existing = inspected.lock;
@@ -15149,7 +15981,7 @@ async function acquireOrJoin(opts) {
     return { kind: "joined", lock: existing, tokenPath };
   }
   if (inspected.kind === "stale") {
-    await fsp7.unlink(lockPath).catch(() => void 0);
+    await fsp9.unlink(lockPath).catch(() => void 0);
   }
   const generation = inspected.kind === "stale" ? inspected.lock.generation + 1 : 1;
   const token = randomBytes(32).toString("hex");
@@ -15167,34 +15999,34 @@ async function acquireOrJoin(opts) {
   return { kind: "acquired", lock: tentative, tokenPath };
 }
 async function finalize(projectDir, tentative, boundPort) {
-  const lockPath = path10.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path10.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path9.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path9.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const finalized = {
     ...tentative,
     port: boundPort,
     url: `http://${tentative.host}:${boundPort}`
   };
   await atomicWriteJson(lockPath, finalized);
-  await fsp7.writeFile(tokenPath, finalized.token, { mode: 384 });
+  await fsp9.writeFile(tokenPath, finalized.token, { mode: 384 });
   return finalized;
 }
 async function release(projectDir, generation) {
-  const lockPath = path10.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path10.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path9.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path9.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   try {
-    const raw = await fsp7.readFile(lockPath, "utf-8");
+    const raw = await fsp9.readFile(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.generation !== generation) return;
     if (parsed.pid !== process.pid) return;
-    await fsp7.unlink(lockPath).catch(() => void 0);
-    await fsp7.unlink(tokenPath).catch(() => void 0);
+    await fsp9.unlink(lockPath).catch(() => void 0);
+    await fsp9.unlink(tokenPath).catch(() => void 0);
   } catch {
   }
 }
 async function readLockForInspection(lockPath) {
   let raw;
   try {
-    raw = await fsp7.readFile(lockPath, "utf-8");
+    raw = await fsp9.readFile(lockPath, "utf-8");
   } catch {
     return { kind: "absent" };
   }
@@ -15202,7 +16034,7 @@ async function readLockForInspection(lockPath) {
   try {
     parsed = JSON.parse(raw);
   } catch {
-    await fsp7.unlink(lockPath).catch(() => void 0);
+    await fsp9.unlink(lockPath).catch(() => void 0);
     return { kind: "absent" };
   }
   if (!isProcessAlive(parsed.pid)) {
@@ -15214,7 +16046,7 @@ async function readLockForInspection(lockPath) {
   return { kind: "live", lock: parsed };
 }
 async function readLiveLock(projectDir) {
-  const lockPath = path10.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const lockPath = path9.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
   const result = await readLockForInspection(lockPath);
   if (result.kind === "live") {
     return { kind: "live", lock: result.lock };
@@ -15225,15 +16057,15 @@ async function readLiveLock(projectDir) {
   return { kind: "absent" };
 }
 async function atomicWriteJson(targetPath, value) {
-  const dir = path10.dirname(targetPath);
-  await fsp7.mkdir(dir, { recursive: true });
+  const dir = path9.dirname(targetPath);
+  await fsp9.mkdir(dir, { recursive: true });
   const tmp = `${targetPath}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
   const body = JSON.stringify(value, null, 2) + "\n";
-  await fsp7.writeFile(tmp, body, { mode: 384 });
+  await fsp9.writeFile(tmp, body, { mode: 384 });
   try {
-    await fsp7.rename(tmp, targetPath);
+    await fsp9.rename(tmp, targetPath);
   } catch (err) {
-    await fsp7.unlink(tmp).catch(() => void 0);
+    await fsp9.unlink(tmp).catch(() => void 0);
     throw err;
   }
 }
@@ -15697,11 +16529,11 @@ var AgentMonitorService = class {
     this._onEntry?.(entry);
   }
   async _appendToFile(subagentId, entry) {
-    const dir = path10.join(this._transcriptsDir, subagentId);
-    await fsp7.mkdir(dir, { recursive: true });
-    const filePath = path10.join(dir, "transcript.jsonl");
+    const dir = path9.join(this._transcriptsDir, subagentId);
+    await fsp9.mkdir(dir, { recursive: true });
+    const filePath = path9.join(dir, "transcript.jsonl");
     const line = JSON.stringify(entry) + "\n";
-    await fsp7.appendFile(filePath, line, { encoding: "utf8" });
+    await fsp9.appendFile(filePath, line, { encoding: "utf8" });
   }
   _uid() {
     return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
@@ -16105,8 +16937,8 @@ var KnowledgeGraph = class {
     return this.index;
   }
   constructor(sessionDir) {
-    this.filePath = path10.join(sessionDir, "_knowledge_graph");
-    this.graphFilePath = path10.join(this.filePath, "graph.jsonl");
+    this.filePath = path9.join(sessionDir, "_knowledge_graph");
+    this.graphFilePath = path9.join(this.filePath, "graph.jsonl");
   }
   // ── Write ──────────────────────────────────────────────────────────────
   /**
@@ -16300,23 +17132,23 @@ var KnowledgeGraph = class {
     }
   }
   async _persist(node) {
-    await fsp7.mkdir(this.filePath, { recursive: true });
+    await fsp9.mkdir(this.filePath, { recursive: true });
     const line = JSON.stringify(node) + "\n";
     await withFileLock(this.graphFilePath, async () => {
-      await fsp7.appendFile(this.graphFilePath, line, "utf8");
+      await fsp9.appendFile(this.graphFilePath, line, "utf8");
     });
   }
   async _append(node) {
-    await fsp7.mkdir(this.filePath, { recursive: true });
+    await fsp9.mkdir(this.filePath, { recursive: true });
     const line = JSON.stringify({ op: "update", node }) + "\n";
     await withFileLock(this.graphFilePath, async () => {
-      await fsp7.appendFile(this.graphFilePath, line, "utf8");
+      await fsp9.appendFile(this.graphFilePath, line, "utf8");
     });
   }
   /** Rebuild in-memory state from the log file. Call on startup. */
   async load() {
     try {
-      const content = await fsp7.readFile(this.graphFilePath, "utf8");
+      const content = await fsp9.readFile(this.graphFilePath, "utf8");
       const lines = content.split("\n").filter(Boolean);
       for (const line of lines) {
         try {
@@ -17894,17 +18726,17 @@ ${input.detail}`
   _waitForDagProgress(timeoutMs) {
     const before = this._dagProgressKey();
     if (this.dag.isDone()) return Promise.resolve();
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       let off;
       const timer = setTimeout(() => {
         off?.();
-        resolve7();
+        resolve9();
       }, timeoutMs);
       off = this.dag.onEvent(() => {
         if (this._dagProgressKey() === before) return;
         clearTimeout(timer);
         off?.();
-        resolve7();
+        resolve9();
       });
     });
   }
@@ -18179,6 +19011,6 @@ ${input.detail}`
   }
 };
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, AgentMonitorService, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetSupervisor, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MATRIX_PHASE_KEYS, MEDIUM_BUDGET, META_AGENTS, MailboxHealthWatchdog, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, WorktreeIntegrationError, acquireOrJoin, actionToAckInput, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, composeDirectorPrompt, composeSubagentPrompt, createAgentMonitorService, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, finalize, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, isValidMatrixKey, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetTool as makeFleetHealthTool, makeFleetTool as makeFleetSessionTool, makeFleetStatusTool, makeFleetTool, makeFleetTool as makeFleetUsageTool, makeKanbanQueueTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeQualityGateTool, makeRollUpTool, makeSpawnTool, makeTerminateAllTool, makeTerminateTool, makeWorkCompleteTool, matrixKeyKind, normalizeRecipient, phaseForRole, readLiveLock, recordPackageAction, release, resolveImplementationModelTarget, resolveMailboxIdentity, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveProjectDir, resolveSubagentModelTarget, resolveSubagentWorktreeDecision, roleNeedsIndependentReviewModel, rosterSummaryFromConfigs, sameModelReference, scoreAgents, startPackageOutdatedWatcher, subagentNeedsWorktree, updatePackageOutdatedStatus, validateWatchdogOptions, withDisabledToolFiltering, wrapSubagentRunnerWithWorktrees };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, AgentMonitorService, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_FLEET_SPAWNS, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetSupervisor, FleetTokenCapError, FleetUsageAggregator, GlobalMailbox, HARD_MAX_SPAWN_DEPTH, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MATRIX_PHASE_KEYS, MAX_SUBAGENT_STRUCTURED_REPORT_CHARS, MEDIUM_BUDGET, META_AGENTS, MailboxHealthWatchdog, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SUBAGENT_STRUCTURED_REPORT_META_KEY, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, WorktreeIntegrationError, acquireOrJoin, actionToAckInput, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, composeDirectorPrompt, composeSubagentPrompt, createAgentMonitorService, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, finalize, formatHumanPrompt, formatSubagentStructuredReport, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, isValidMatrixKey, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetTool as makeFleetHealthTool, makeFleetTool as makeFleetSessionTool, makeFleetStatusTool, makeFleetTool, makeFleetTool as makeFleetUsageTool, makeKanbanQueueTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeQualityGateTool, makeRollUpTool, makeSpawnTool, makeSubagentResultTool, makeTerminateAllTool, makeTerminateTool, makeWorkCompleteTool, matrixKeyKind, normalizeRecipient, normalizeSubagentStructuredReport, phaseForRole, readLiveLock, readSubagentStructuredReport, recordPackageAction, release, resolveImplementationModelTarget, resolveMailboxIdentity, resolveMaxSpawnDepth, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveProjectDir, resolveSubagentModelTarget, resolveSubagentWorktreeDecision, roleNeedsIndependentReviewModel, rosterSummaryFromConfigs, sameModelReference, scoreAgents, startPackageOutdatedWatcher, subagentNeedsWorktree, updatePackageOutdatedStatus, validateWatchdogOptions, withDisabledToolFiltering, wrapSubagentRunnerWithWorktrees };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map