@wrongstack/core 0.286.0 → 0.287.0

package/dist/defaults/index.js

@@ -13,6 +13,7 @@ function assertNever(x, message) {
 // src/utils/atomic-write.ts
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
+import { watch as watchDir } from "node:fs";
 import * as path from "node:path";
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path.dirname(targetPath);
@@ -35,8 +36,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat13 = await fs.stat(targetPath);
-      mode = stat13.mode & 511;
+      const stat12 = await fs.stat(targetPath);
+      mode = stat12.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -80,17 +81,18 @@ async function withFileLock(targetPath, fn, opts = {}) {
         await fs.mkdir(dir, { recursive: true });
         continue;
       }
-      if (code !== "EEXIST") throw err;
+      if (code !== "EEXIST" && code !== "EPERM") throw err;
       try {
-        const stat13 = await fs.stat(lockPath);
-        if (Date.now() - stat13.mtimeMs > staleMs) {
+        const stat12 = await fs.stat(lockPath);
+        if (Date.now() - stat12.mtimeMs > staleMs) {
           await fs.unlink(lockPath);
           continue;
         }
       } catch {
         continue;
       }
-      if (Date.now() - started >= timeoutMs) {
+      const elapsed = Date.now() - started;
+      if (elapsed >= timeoutMs) {
         throw new FsError({
           message: `Timed out waiting for file lock: ${targetPath}`,
           code: "FS_ATOMIC_WRITE_FAILED",
@@ -98,7 +100,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
           context: { timeoutMs }
         });
       }
-      await new Promise((resolve12) => setTimeout(resolve12, 25));
+      await waitForLockRelease(lockPath, timeoutMs - elapsed);
     }
   }
   try {
@@ -114,6 +116,50 @@ async function withFileLock(targetPath, fn, opts = {}) {
     }
   }
 }
+async function waitForLockRelease(lockPath, remainingMs) {
+  const parentDir = path.dirname(lockPath);
+  const lockName = path.basename(lockPath);
+  const intervalMs = Math.min(remainingMs, 100);
+  return new Promise((resolve12) => {
+    let settled = false;
+    let watcher = null;
+    const timer = setTimeout(() => {
+      settled = true;
+      watcher?.close();
+      resolve12();
+    }, intervalMs);
+    try {
+      watcher = watchDir(parentDir, (eventType, filename) => {
+        if (settled) return;
+        if (filename === lockName && (eventType === "rename" || eventType === "change")) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve12();
+        }
+      });
+    } catch {
+      clearTimeout(timer);
+      if (!settled) {
+        settled = true;
+        setTimeout(resolve12, Math.min(remainingMs, 25));
+      }
+      return;
+    }
+    fs.access(lockPath).then(
+      () => {
+      },
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve12();
+        }
+      }
+    );
+  });
+}
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
@@ -572,8 +618,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat13 = await fsp.stat(full);
-          if (stat13.isDirectory()) await walk3(full, rest);
+          const stat12 = await fsp.stat(full);
+          if (stat12.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -590,8 +636,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat13 = await fsp.stat(full);
-          if (stat13.isDirectory()) await walk3(full, rest);
+          const stat12 = await fsp.stat(full);
+          if (stat12.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -782,10 +828,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path29, errors, depth) {
+function walk(value, schema, path28, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path29 || "<root>",
+      path: path28 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -793,7 +839,7 @@ function walk(value, schema, path29, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path29 || "<root>",
+        path: path28 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -802,7 +848,7 @@ function walk(value, schema, path29, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path29 || "<root>",
+        path: path28 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -814,7 +860,7 @@ function walk(value, schema, path29, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path29, req),
+          path: joinPath(path28, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -822,14 +868,14 @@ function walk(value, schema, path29, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path29, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path28, key), errors, depth + 1);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path29}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path28}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -1287,8 +1333,8 @@ function subjectForToolInput(toolName, input, subjectKey) {
 }
 
 // src/utils/tool-wire-compact.ts
-var TOOL_DESCRIPTION_MAX_CHARS = 640;
-var SCHEMA_DESCRIPTION_MAX_CHARS = 180;
+var TOOL_DESCRIPTION_MAX_CHARS = 400;
+var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
 var compactCache = /* @__PURE__ */ new WeakMap();
 function compactToolDefinitionForWire(tool, opts = {}) {
   const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
@@ -2208,14 +2254,34 @@ function resolveToolResultRenderMode(modes, toolName) {
 
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
+import * as fs2 from "node:fs";
 import * as os from "node:os";
 import * as path3 from "node:path";
+function canonicalProjectRoot(absRoot) {
+  const checkoutRoot = path3.resolve(absRoot);
+  const dotGit = path3.join(checkoutRoot, ".git");
+  try {
+    if (!fs2.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs2.readFileSync(dotGit, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
+    if (!match?.[1]) return checkoutRoot;
+    const gitDir = path3.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path3.join(gitDir, "commondir");
+    if (!fs2.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path3.resolve(gitDir, fs2.readFileSync(commonDirFile, "utf8").trim());
+    if (path3.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path3.dirname(commonDir);
+  } catch {
+    return checkoutRoot;
+  }
+}
 function projectHash(absRoot) {
-  return createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 12);
+  return createHash("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
 }
 function projectSlug(absRoot) {
-  const base = slugify2(path3.basename(absRoot));
-  const hash = createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 6);
+  const identityRoot = canonicalProjectRoot(absRoot);
+  const base = slugify2(path3.basename(identityRoot));
+  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify2(name) {
@@ -3526,7 +3592,7 @@ var TOOLS = {
 };
 
 // src/coordination/agents/agent-prompts.ts
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import * as os2 from "node:os";
 import * as path4 from "node:path";
 import { fileURLToPath } from "node:url";
@@ -3541,7 +3607,7 @@ function agentPrompt(id) {
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      resolved = readFileSync(path4.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync2(path4.join(dir, fileName), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -3571,7 +3637,7 @@ function agentPromptDirCandidates(envDir) {
 }
 function isDirectory(candidate) {
   try {
-    return statSync(candidate).isDirectory();
+    return statSync2(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -5162,19 +5228,19 @@ var FLEET_ROSTER = {
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
 };
-var DEFAULT_IDLE_TIMEOUT_MS = 15 * 60 * 1e3;
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
 var FLEET_ROSTER_BUDGETS = {
-  "audit-log": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
-  "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
-  "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
-  "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
-  critic: { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
+  "audit-log": { timeoutMs: 3 * 60 * 60 * 1e3, maxIterations: 2500, maxToolCalls: 7500 },
+  "bug-hunter": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 1e4 },
+  "refactor-planner": { timeoutMs: 4 * 60 * 60 * 1e3, maxIterations: 3e3, maxToolCalls: 9e3 },
+  "security-scanner": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 1e4 },
+  critic: { timeoutMs: 3 * 60 * 60 * 1e3, maxIterations: 2e3, maxToolCalls: 6e3 },
   "shadow-agent": {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
-    maxIterations: 2e3,
-    maxToolCalls: 5e3,
-    maxTokens: 6e4,
-    maxCostUsd: 1
+    maxIterations: 1e3,
+    maxToolCalls: 2500,
+    maxTokens: 3e4,
+    maxCostUsd: 0.5
   },
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
@@ -5182,8 +5248,8 @@ var FLEET_ROSTER_BUDGETS = {
 };
 var GENERIC_SUBAGENT_BUDGET = {
   idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
-  maxIterations: 5e3,
-  maxToolCalls: 15e3
+  maxIterations: 2500,
+  maxToolCalls: 7500
 };
 function applyRosterBudget(cfg) {
   const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
@@ -5239,72 +5305,71 @@ function createDelegateTool(opts) {
     properties: {
       task: {
         type: "string",
-        description: "What the subagent should do \u2014 natural language, complete sentence(s). The subagent has its own tool slice, its own LLM call, and returns when its task is done."
+        description: "What the subagent should do \u2014 natural language, complete sentence(s)."
       },
       role: {
         type: "string",
-        description: rosterIds.length > 0 ? `Roster role (preferred). One of: ${rosterIds.join(", ")}. Picks a pre-tuned config (prompt, budgets, tools) for that role.` : "No roster is configured \u2014 pass `name` instead.",
-        enum: rosterIds.length > 0 ? rosterIds : void 0
+        description: rosterIds.length > 0 ? "Roster role id. Common: bug-hunter, security-scanner, refactor-planner, critic, audit-log, executor, shadow-agent, architect." : "No roster configured \u2014 pass `name` instead."
       },
       name: {
         type: "string",
-        description: "Display name for free-form subagents (not using a roster role). The subagent gets a large default budget (3h, 5000 iter, 15000 tool calls). Required when `role` is omitted."
+        description: "Display name for free-form subagents (no roster role). Required when `role` is omitted."
       },
       provider: {
         type: "string",
-        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the host provider when omitted.'
+        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to host provider.'
       },
       model: {
         type: "string",
-        description: "Model id within the provider. Defaults to the host model when omitted."
+        description: "Model id within the provider. Defaults to host model."
       },
       systemPromptOverride: {
         type: "string",
-        description: "Optional extra prompt text appended to the role baseline."
+        description: "Extra prompt text appended to the role baseline."
       },
       timeoutMs: {
         type: "number",
         minimum: 1,
-        description: `Wall-clock budget for this delegate in milliseconds. No hard cap \u2014 set as high as the task realistically needs (a monorepo audit can take hours, a single-file lint takes seconds). Default ${Math.round(defaultTimeoutMs / 1e3 / 60)} minutes.`
+        description: `Wall-clock budget in ms (default ${Math.round(defaultTimeoutMs / 1e3 / 60)} min). No hard cap \u2014 set as high as the task needs.`
       },
       maxIterations: {
         type: "number",
         minimum: 1,
-        description: "Maximum LLM iterations the subagent may take. Unset = use the role/coordinator default. Raise this for tasks with many tool-think-tool cycles (deep code analysis, multi-file refactors)."
+        description: "Maximum LLM iterations. Unset = role default. Raise for deep multi-step tasks."
       },
       maxToolCalls: {
         type: "number",
         minimum: 1,
-        description: "Maximum number of tool invocations the subagent may make. Unset = use the role/coordinator default. Raise this for tasks that touch many files (large grep + read + report)."
+        description: "Maximum tool invocations. Unset = role default. Raise for file-heavy tasks."
       },
       idleTimeoutMs: {
         type: "number",
         minimum: 1,
-        description: "Idle timeout in ms: reap the subagent after this long with no activity. Resets on every iteration/tool call. Unset = use the role/coordinator default."
+        description: "Idle timeout in ms. Resets on activity. Unset = role default."
       },
       maxTokens: {
         type: "number",
         minimum: 1,
-        description: "Maximum total tokens (input + output) the subagent may use. Unset = use the role/coordinator default."
+        description: "Max total tokens (input+output). Unset = role default."
       },
       maxCostUsd: {
         type: "number",
         minimum: 0,
-        description: "Maximum estimated USD cost the subagent may incur. Unset = use the role/coordinator default."
+        description: "Max estimated USD cost. Unset = role default."
       },
       maxHandoffs: {
         type: "number",
         minimum: 0,
         maximum: 8,
-        description: "Maximum fresh-worker continuations after partial completion or budget exhaustion. Default 1; set 0 to disable. Each successor receives the prior structured/partial report and is told to continue only the remaining work."
+        description: "Max fresh-worker continuations after budget exhaustion. Default 1. Each gets the prior partial report."
       }
     },
     required: ["task"]
   };
   return {
     name: "delegate",
-    description: "Hand a discrete piece of work to a dedicated subagent and wait for its result. The subagent has its own context, its own LLM call, and a generous, auto-extending budget. If it reports explicit partial completion or still exhausts a recoverable budget, delegate can continue the remaining work with a fresh subagent (bounded by `maxHandoffs`, default 1). Workers may ask the leader to spawn a parallel helper through the mailbox, but cannot recursively spawn agents themselves. Use specialized roster roles when possible; otherwise pass `name` + `task`. Call multiple delegates in parallel through the provider's parallel-tool-call surface for independent work.",
-    usageHint: "Set `task` to a complete instruction. Either pick `role` from the roster or pass `name` for a free-form coding agent. Defaults are intentionally generous; override `timeoutMs`, `maxIterations`, `maxToolCalls`, or `maxHandoffs` only when the task warrants it. Returns the final TaskResult plus a `handoffs` history when fresh workers continued partial work. Requires Director mode in normal CLI sessions.",
+    description: "Hand a piece of work to a subagent and wait for its result. Has own context, LLM call, auto-extending budget. Can continue remaining work with a fresh subagent on partial completion (maxHandoffs, default 1). Workers cannot recursively spawn. Use roster roles when possible; otherwise pass `name` + `task`.",
+    usageHint: "Set `task` to a complete instruction. Pick `role` from roster or pass `name` for free-form. Override `timeoutMs`/`maxIterations`/`maxToolCalls` only when needed.",
     permission: "auto",
     mutating: false,
     managesOwnTimeout: true,
@@ -5331,10 +5396,9 @@ function createDelegateTool(opts) {
           director = await opts.host.promoteToDirector();
         }
         if (!director) {
-          const reason = opts.host.getPromotionBlockReason?.();
           return {
             ok: false,
-            error: reason ?? "Director could not be activated \u2014 multi-agent host already running in legacy non-director mode. Restart with `--director` for fleet support."
+            error: "Director could not be activated \u2014 fleet orchestration is unavailable."
           };
         }
         const timeoutMs = i.timeoutMs ?? defaultTimeoutMs;
@@ -6014,6 +6078,63 @@ function resolveMaxSpawnDepth(requested) {
   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;
+  limit;
+  observed;
+  constructor(kind, limit, observed, message) {
+    const defaultMsg = kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`;
+    super(message ?? defaultMsg);
+    this.name = "FleetSpawnBudgetError";
+    this.kind = kind;
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+var FleetCostCapError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
+    );
+    this.name = "FleetCostCapError";
+    this.kind = "max_cost_usd";
+    this.limit = limit;
+    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;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Leader context overflow: leader has ${observed} tokens in flight (limit: ${limit}). Compact the leader context before spawning more subagents.`
+    );
+    this.name = "FleetContextOverflowError";
+    this.kind = "max_context_load";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+
 // src/coordination/collab-debug.ts
 import { EventEmitter } from "node:events";
 import * as fsp4 from "node:fs/promises";
@@ -6230,7 +6351,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat13] = await Promise.all([
+        const [content, stat12] = await Promise.all([
           fsp4.readFile(filePath, "utf8"),
           fsp4.stat(filePath)
         ]);
@@ -6240,8 +6361,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat13.mtimeMs,
-          snapshotSizeBytes: stat13.size
+          snapshotMtimeMs: stat12.mtimeMs,
+          snapshotSizeBytes: stat12.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -6660,9 +6781,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 stat13 = await fsp4.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat13.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat13.size !== file.snapshotSizeBytes;
+        const stat12 = await fsp4.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat12.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat12.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -6737,65 +6858,86 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
   }
 };
 
-// src/coordination/director/director-errors.ts
-var FleetSpawnBudgetError = class extends Error {
-  kind;
-  limit;
-  observed;
-  constructor(kind, limit, observed, message) {
-    const defaultMsg = kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`;
-    super(message ?? defaultMsg);
-    this.name = "FleetSpawnBudgetError";
-    this.kind = kind;
-    this.limit = limit;
-    this.observed = observed;
+// src/coordination/director/director-collab.ts
+var DirectorCollabController = class {
+  constructor(deps) {
+    this.deps = deps;
   }
-};
-var FleetCostCapError = class extends Error {
-  kind;
-  limit;
-  observed;
-  constructor(limit, observed) {
-    super(
-      `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
-    );
-    this.name = "FleetCostCapError";
-    this.kind = "max_cost_usd";
-    this.limit = limit;
-    this.observed = observed;
+  deps;
+  /** Active collab sessions tracked by sessionId (see spawn).
+   *  The tuple holds the session and its Director-registered listener unsubs.
+   *  Calling the unsubs on cancel/premature-cleanup prevents listener accumulation
+   *  on CollabSession (EventEmitter) across many spawn() calls. */
+  activeSessions = /* @__PURE__ */ new Map();
+  async spawn(options) {
+    const session = new CollabSession(this.deps.director, this.deps.fleet, {
+      ...options,
+      onBudgetWarning: (alert) => {
+        return options.onBudgetWarning?.(alert) ?? "ignore";
+      }
+    });
+    const doneHandler = () => this.activeSessions.delete(session.sessionId);
+    const errorHandler = () => this.activeSessions.delete(session.sessionId);
+    session.on("session.done", doneHandler);
+    session.on("session.error", errorHandler);
+    const unsubs = [
+      () => session.off("session.done", doneHandler),
+      () => session.off("session.error", errorHandler)
+    ];
+    this.activeSessions.set(session.sessionId, { session, unsubs });
+    return session.start();
   }
-};
-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;
+  cancel(sessionId, reason = "Director cancelled") {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry || entry.session.isCancelled()) return;
+    for (const unsub of entry.unsubs) unsub();
+    entry.session.cancel(reason);
+    for (const [_role, subagentId] of entry.session.getSubagentIds()) {
+      this.deps.coordinator.stop(subagentId).catch((err) => {
+        this.deps.logger?.debug(
+          `stop subagent ${subagentId} failed (may have already completed)`,
+          {
+            subagentId,
+            err: err instanceof Error ? err.message : String(err)
+          }
+        );
+      });
+    }
+  }
+  onAlert(handler) {
+    return this.deps.fleet.filter("collab.warning", (e) => {
+      handler(e.payload);
+    });
+  }
+  activeSessionIds() {
+    return Array.from(this.activeSessions.keys());
   }
 };
-var FleetContextOverflowError = class extends Error {
-  kind;
-  limit;
-  observed;
-  constructor(limit, observed) {
-    super(
-      `Leader context overflow: leader has ${observed} tokens in flight (limit: ${limit}). Compact the leader context before spawning more subagents.`
-    );
-    this.name = "FleetContextOverflowError";
-    this.kind = "max_context_load";
-    this.limit = limit;
-    this.observed = observed;
+
+// src/coordination/director/director-btw-notes.ts
+var DirectorBtwNotes = class {
+  notes = [];
+  /** Stash a note (trimmed; empty ignored). Returns the pending count. Cap 20. */
+  add(note) {
+    const trimmed = note.trim();
+    if (!trimmed) return this.notes.length;
+    this.notes = [...this.notes, trimmed].slice(-20);
+    return this.notes.length;
+  }
+  /** Read and clear all pending notes, in FIFO order (empty array when none). */
+  drain() {
+    const notes = this.notes;
+    this.notes = [];
+    return notes;
+  }
+  /** Peek at pending notes without consuming them. */
+  peek() {
+    return [...this.notes];
   }
 };
 
 // src/utils/instruction-file.ts
-import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
 import * as path6 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
@@ -6806,7 +6948,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync2(path6.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync3(path6.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -6833,7 +6975,7 @@ function instructionRootCandidates() {
 }
 function isDirectory2(candidate) {
   try {
-    return statSync2(candidate).isDirectory();
+    return statSync3(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -10190,13 +10332,12 @@ var Director = class _Director {
    * coordinator from keeping workers alive for tasks that will never arrive.
    */
   workCompleteFlag = false;
-  /** Pending /btw notes stashed by the leader agent (see setLeaderBtwNote). */
-  _leaderBtwNotes = [];
-  /** Active collab sessions tracked by sessionId (see spawnCollab).
-   *  The tuple holds the session and its Director-registered listener unsubs.
-   *  Calling the unsubs on cancel/premature-cleanup prevents listener accumulation
-   *  on CollabSession (EventEmitter) across many spawnCollab() calls. */
-  _activeCollabSessions = /* @__PURE__ */ new Map();
+  /** Pending /btw notes stashed by the leader agent (see setLeaderBtwNote).
+   *  Owned by DirectorBtwNotes (R4); the public btw methods delegate to it. */
+  btwNotes = new DirectorBtwNotes();
+  /** Owns active collab-debug sessions (spawn/cancel/alert/list). Extracted
+   *  from Director in R4; the public collab methods below delegate to it. */
+  collab;
   /** Prevents large `ask_subagent` answers from bloating the leader's context window. */
   largeAnswerStore;
   constructor(opts) {
@@ -10273,92 +10414,103 @@ var Director = class _Director {
     );
     this.coordinator.setFleetBus(this.fleet);
     this.fleetManager?.setCoordinator(this.coordinator);
-    this.taskCompletedListener = (payload) => {
-      const r = payload.result;
-      const internalTask = this.internalTaskIds.delete(r.taskId);
-      if (!internalTask) {
-        this.completed.set(r.taskId, r);
-        if (this.completed.size > _Director.MAX_COMPLETED) {
-          const toDelete = this.completed.size - _Director.MAX_COMPLETED;
-          const keys = [...this.completed.keys()].slice(0, toDelete);
-          for (const k of keys) this.completed.delete(k);
-        }
-      }
-      const waiter = this.taskWaiters.get(r.taskId);
-      if (waiter) {
-        waiter.resolve(r);
-        this.taskWaiters.delete(r.taskId);
-      }
-      let anyConsumed = false;
-      for (const aw of [...this.anyWaiters]) {
-        if (!aw.ids.has(r.taskId)) continue;
-        if (aw.timer) clearTimeout(aw.timer);
-        this.anyWaiters.delete(aw);
-        aw.resolve(r);
-        anyConsumed = true;
-      }
-      const consumedInBand = !!waiter || anyConsumed;
-      if (internalTask) return;
-      const title = this.taskDescriptions.get(r.taskId) ?? payload.task.description ?? r.taskId;
-      if (!consumedInBand && this.taskResultNotifier) {
-        const resultText = typeof r.result === "string" ? r.result : r.result !== void 0 ? safeStringify(r.result) : void 0;
-        try {
-          void Promise.resolve(
-            this.taskResultNotifier({
-              taskId: r.taskId,
-              title,
-              status: r.status,
-              subagentId: r.subagentId,
-              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
-            })
-          ).catch(() => {
-          });
-        } catch {
-        }
+    this.taskCompletedListener = (payload) => this.handleTaskCompleted(payload);
+    this.coordinator.on("task.completed", this.taskCompletedListener);
+    this.wireBudgetPolicy();
+    this.largeAnswerStore = new LargeAnswerStore(2e3);
+    this.collab = new DirectorCollabController({
+      director: this,
+      fleet: this.fleet,
+      coordinator: this.coordinator,
+      logger: this.logger
+    });
+  }
+  handleTaskCompleted(payload) {
+    const r = payload.result;
+    const internalTask = this.internalTaskIds.delete(r.taskId);
+    if (!internalTask) {
+      this.completed.set(r.taskId, r);
+      if (this.completed.size > _Director.MAX_COMPLETED) {
+        const toDelete = this.completed.size - _Director.MAX_COMPLETED;
+        const keys = [...this.completed.keys()].slice(0, toDelete);
+        for (const k of keys) this.completed.delete(k);
+      }
+    }
+    const waiter = this.taskWaiters.get(r.taskId);
+    if (waiter) {
+      waiter.resolve(r);
+      this.taskWaiters.delete(r.taskId);
+    }
+    let anyConsumed = false;
+    for (const aw of [...this.anyWaiters]) {
+      if (!aw.ids.has(r.taskId)) continue;
+      if (aw.timer) clearTimeout(aw.timer);
+      this.anyWaiters.delete(aw);
+      aw.resolve(r);
+      anyConsumed = true;
+    }
+    const consumedInBand = !!waiter || anyConsumed;
+    if (internalTask) return;
+    const title = this.taskDescriptions.get(r.taskId) ?? payload.task.description ?? r.taskId;
+    if (!consumedInBand && this.taskResultNotifier) {
+      const resultText = typeof r.result === "string" ? r.result : r.result !== void 0 ? safeStringify(r.result) : void 0;
+      try {
+        void Promise.resolve(
+          this.taskResultNotifier({
+            taskId: r.taskId,
+            title,
+            status: r.status,
+            subagentId: r.subagentId,
+            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
+          })
+        ).catch(() => {
+        });
+      } catch {
       }
-      const failed = r.status !== "success";
-      const errorString = r.error ? `${r.error.kind}: ${r.error.message}` : void 0;
-      this.stateCheckpoint?.recordTaskStatus(r.taskId, {
-        status: failed ? r.status : "completed",
-        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        iterations: r.iterations,
-        toolCalls: r.toolCalls,
-        durationMs: r.durationMs,
-        error: errorString
-      });
-      this.stateCheckpoint?.setUsage(this.usage.snapshot());
-      void this.appendSessionEvent(
-        failed ? {
-          type: "task_failed",
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          taskId: r.taskId,
-          title,
-          error: errorString ?? r.status
-        } : {
-          type: "task_completed",
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          taskId: r.taskId,
-          title
-        }
-      );
-      if (this.fleetManager) {
-        void this.fleetManager.flushManifest();
-      } else {
-        this.scheduleManifest();
+    }
+    const failed = r.status !== "success";
+    const errorString = r.error ? `${r.error.kind}: ${r.error.message}` : void 0;
+    this.stateCheckpoint?.recordTaskStatus(r.taskId, {
+      status: failed ? r.status : "completed",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      iterations: r.iterations,
+      toolCalls: r.toolCalls,
+      durationMs: r.durationMs,
+      error: errorString
+    });
+    this.stateCheckpoint?.setUsage(this.usage.snapshot());
+    void this.appendSessionEvent(
+      failed ? {
+        type: "task_failed",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        taskId: r.taskId,
+        title,
+        error: errorString ?? r.status
+      } : {
+        type: "task_completed",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        taskId: r.taskId,
+        title
       }
-      this.armSubagentIdleRetirement(
-        r.subagentId,
-        this.retireSubagentOnTaskComplete ? 0 : this.subagentIdleTimeoutMs
-      );
-    };
-    this.coordinator.on("task.completed", this.taskCompletedListener);
+    );
+    if (this.fleetManager) {
+      void this.fleetManager.flushManifest();
+    } else {
+      this.scheduleManifest();
+    }
+    this.armSubagentIdleRetirement(
+      r.subagentId,
+      this.retireSubagentOnTaskComplete ? 0 : this.subagentIdleTimeoutMs
+    );
+  }
+  wireBudgetPolicy() {
     const extendCounts = /* @__PURE__ */ new Map();
     const progressBySubagent = /* @__PURE__ */ new Map();
     const lastTimeoutProgress = /* @__PURE__ */ new Map();
@@ -10478,7 +10630,6 @@ var Director = class _Director {
       }
       grantExtension();
     });
-    this.largeAnswerStore = new LargeAnswerStore(2e3);
   }
   /**
    * Record a granted budget extension and broadcast it on the FleetBus so
@@ -10536,10 +10687,7 @@ var Director = class _Director {
    * programmatically without going through the slash-command path.
    */
   setLeaderBtwNote(note) {
-    const trimmed = note.trim();
-    if (!trimmed) return this._leaderBtwNotes.length;
-    this._leaderBtwNotes = [...this._leaderBtwNotes, trimmed].slice(-20);
-    return this._leaderBtwNotes.length;
+    return this.btwNotes.add(note);
   }
   /**
    * Read and clear all pending /btw notes the leader has stashed.
@@ -10550,16 +10698,14 @@ var Director = class _Director {
    * to cancel the collab session or let it continue.
    */
   getLeaderBtwNotes() {
-    const notes = this._leaderBtwNotes;
-    this._leaderBtwNotes = [];
-    return notes;
+    return this.btwNotes.drain();
   }
   /**
    * Peek at pending /btw notes without consuming them.
    * Useful for UI to show "N pending notes" without clearing them.
    */
   peekLeaderBtwNotes() {
-    return [...this._leaderBtwNotes];
+    return this.btwNotes.peek();
   }
   /**
    * Drain (read + clear) all /btw notes in one call.
@@ -10579,18 +10725,7 @@ var Director = class _Director {
    * The CollabDebugReport will reflect 'cancelled' disposition when awaited.
    */
   cancelCollabSession(sessionId, reason = "Director cancelled") {
-    const entry = this._activeCollabSessions.get(sessionId);
-    if (!entry || entry.session.isCancelled()) return;
-    for (const unsub of entry.unsubs) unsub();
-    entry.session.cancel(reason);
-    for (const [_role, subagentId] of entry.session.getSubagentIds()) {
-      this.coordinator.stop(subagentId).catch((err) => {
-        this.logger?.debug(`stop subagent ${subagentId} failed (may have already completed)`, {
-          subagentId,
-          err: err instanceof Error ? err.message : String(err)
-        });
-      });
-    }
+    this.collab.cancel(sessionId, reason);
   }
   /**
    * Subscribe a callback to be notified whenever a collab session raises
@@ -10599,9 +10734,7 @@ var Director = class _Director {
    * Returns an unsubscribe function.
    */
   onCollabAlert(handler) {
-    return this.fleet.filter("collab.warning", (e) => {
-      handler(e.payload);
-    });
+    return this.collab.onAlert(handler);
   }
   /**
    * Returns all active (not yet settled) collab session ids.
@@ -10609,7 +10742,7 @@ var Director = class _Director {
    * the host to know what can be cancelled.
    */
   activeCollabSessions() {
-    return Array.from(this._activeCollabSessions.keys());
+    return this.collab.activeSessionIds();
   }
   /** Best-effort session-writer append. Swallows failures — the director
    *  must not break a fleet run because the session JSONL handle closed. */
@@ -10675,17 +10808,90 @@ var Director = class _Director {
       );
     }
     const config = { ...callerConfig };
-    if (!config.model && this.modelMatrix) {
-      const matrix = typeof this.modelMatrix === "function" ? this.modelMatrix() : this.modelMatrix;
-      const resolution = resolveModelMatrixResolution(matrix, config.role);
-      const entry = resolution?.source === "default" && roleNeedsIndependentReviewModel(config.role) ? void 0 : resolution?.entry;
-      if (entry?.model) {
-        config.model = entry.model;
-        if (entry.provider) config.provider = entry.provider;
-        if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
+    this.resolveSpawnModel(config);
+    this.enforceSpawnCaps(config);
+    let result;
+    this.assignSpawnNickname(config);
+    this.applySpawnLineage(config);
+    result = await this.coordinator.spawn(config);
+    if (this.fleetManager) {
+      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+    } else {
+      this.spawnCount += 1;
+      this.subagentMeta.set(result.subagentId, {
+        provider: config.provider,
+        model: config.model
+      });
+      if (priceLookup && config.provider && config.model) {
+        this.priceLookups.set(`${config.provider}/${config.model}`, priceLookup);
       }
     }
-    if (this.fleetManager) {
+    const subagentBridge = new InMemoryAgentBridge(
+      { agentId: result.subagentId, coordinatorId: this.id },
+      this.transport
+    );
+    this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
+    this.subagentBridges.set(result.subagentId, subagentBridge);
+    this.fleet.emit({
+      subagentId: result.subagentId,
+      ts: Date.now(),
+      type: "subagent.spawned",
+      payload: {
+        subagentId: result.subagentId,
+        taskId: "",
+        // taskId will be set when assign() is called
+        name: config.name,
+        role: config.role,
+        provider: config.provider,
+        model: config.model
+      }
+    });
+    if (!this.fleetManager) {
+      this.manifestEntries.set(result.subagentId, {
+        subagentId: result.subagentId,
+        name: config.name,
+        role: config.role,
+        provider: config.provider,
+        model: config.model,
+        taskIds: []
+      });
+      const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.stateCheckpoint?.recordSpawn(
+        {
+          id: result.subagentId,
+          name: config.name,
+          role: config.role,
+          provider: config.provider,
+          model: config.model,
+          spawnedAt
+        },
+        this.spawnCount
+      );
+      void this.appendSessionEvent({
+        type: "agent_spawned",
+        ts: spawnedAt,
+        agentId: result.subagentId,
+        role: config.role ?? config.name
+      });
+      this.scheduleManifest();
+    }
+    this.armSubagentIdleRetirement(result.subagentId, this.subagentIdleTimeoutMs);
+    return result.subagentId;
+  }
+  resolveSpawnModel(config) {
+    if (!config.model && this.modelMatrix) {
+      const matrix = typeof this.modelMatrix === "function" ? this.modelMatrix() : this.modelMatrix;
+      const resolution = resolveModelMatrixResolution(matrix, config.role);
+      const entry = resolution?.source === "default" && roleNeedsIndependentReviewModel(config.role) ? void 0 : resolution?.entry;
+      if (entry?.model) {
+        config.model = entry.model;
+        if (entry.provider) config.provider = entry.provider;
+        if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
+      }
+    }
+  }
+  enforceSpawnCaps(config) {
+    if (this.fleetManager) {
       const rejection = this.fleetManager.canSpawn(config);
       if (rejection) {
         if (rejection.kind === "max_spawn_depth")
@@ -10727,7 +10933,8 @@ var Director = class _Director {
         }
       }
     }
-    let result;
+  }
+  assignSpawnNickname(config) {
     const needsNickname = config.name === config.role || !config.name || config.name === "subagent" || config.name === "adhoc";
     if (needsNickname) {
       const role = config.role ?? "subagent";
@@ -10739,6 +10946,8 @@ var Director = class _Director {
         this._usedNicknames.add(key);
       }
     }
+  }
+  applySpawnLineage(config) {
     const budget = this.fleetManager ? this.fleetManager.budgetSnapshot() : (() => {
       const total = this.usage.snapshot().total;
       const usedTokens = (total?.input ?? 0) + (total?.output ?? 0);
@@ -10767,70 +10976,6 @@ var Director = class _Director {
         ...Number.isFinite(budget.remainingCostUsd) ? { remainingCostUsd: budget.remainingCostUsd } : {}
       }
     };
-    result = await this.coordinator.spawn(config);
-    if (this.fleetManager) {
-      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
-    } else {
-      this.spawnCount += 1;
-      this.subagentMeta.set(result.subagentId, {
-        provider: config.provider,
-        model: config.model
-      });
-      if (priceLookup && config.provider && config.model) {
-        this.priceLookups.set(`${config.provider}/${config.model}`, priceLookup);
-      }
-    }
-    const subagentBridge = new InMemoryAgentBridge(
-      { agentId: result.subagentId, coordinatorId: this.id },
-      this.transport
-    );
-    this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
-    this.subagentBridges.set(result.subagentId, subagentBridge);
-    this.fleet.emit({
-      subagentId: result.subagentId,
-      ts: Date.now(),
-      type: "subagent.spawned",
-      payload: {
-        subagentId: result.subagentId,
-        taskId: "",
-        // taskId will be set when assign() is called
-        name: config.name,
-        role: config.role,
-        provider: config.provider,
-        model: config.model
-      }
-    });
-    if (!this.fleetManager) {
-      this.manifestEntries.set(result.subagentId, {
-        subagentId: result.subagentId,
-        name: config.name,
-        role: config.role,
-        provider: config.provider,
-        model: config.model,
-        taskIds: []
-      });
-      const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
-      this.stateCheckpoint?.recordSpawn(
-        {
-          id: result.subagentId,
-          name: config.name,
-          role: config.role,
-          provider: config.provider,
-          model: config.model,
-          spawnedAt
-        },
-        this.spawnCount
-      );
-      void this.appendSessionEvent({
-        type: "agent_spawned",
-        ts: spawnedAt,
-        agentId: result.subagentId,
-        role: config.role ?? config.name
-      });
-      this.scheduleManifest();
-    }
-    this.armSubagentIdleRetirement(result.subagentId, this.subagentIdleTimeoutMs);
-    return result.subagentId;
   }
   /**
    * Synchronously ask a subagent something via the bridge. Sends a
@@ -10955,6 +11100,23 @@ var Director = class _Director {
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
+  /**
+   * Cancel the pending manifest debounce timer and drain any in-flight
+   * manifest write so that, once this resolves, no Director-owned manifest
+   * write is armed or running.
+   *
+   * Unlike `shutdown()`, this does NOT tear down the coordinator, bridges,
+   * or waiters — it is the lightweight quiesce that `MultiAgentHost.stopAll()`
+   * needs. `stopAll()` flushes the FleetManager's manifest but never touched
+   * the Director's own writer, leaving its armed debounce timer to fire ~2s
+   * later. Under CPU starvation that late, un-awaited `atomicWrite` (temp
+   * sibling + rename) races a caller that deletes the manifest directory,
+   * producing an `ENOTEMPTY` on the parent `rmdir` (Windows especially).
+   */
+  async quiesceManifest() {
+    this.clearManifestTimer();
+    await this.manifestWriteChain.catch(() => void 0);
+  }
   /**
    * Tear down the director: stop every subagent, close every bridge
    * endpoint, and (when configured) write the final manifest. Idempotent
@@ -10966,8 +11128,17 @@ var Director = class _Director {
       this.coordinator.off("task.completed", this.taskCompletedListener);
       this.taskCompletedListener = null;
     }
-    for (const aw of this.anyWaiters) {
+    for (const aw of [...this.anyWaiters]) {
       if (aw.timer) clearTimeout(aw.timer);
+      const firstId = [...aw.ids][0];
+      aw.resolve({
+        taskId: firstId ?? "unknown",
+        subagentId: "director",
+        status: "stopped",
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      });
     }
     this.anyWaiters.clear();
     if (this.toolExecFilter) {
@@ -10981,6 +11152,17 @@ var Director = class _Director {
     for (const timer of this.subagentIdleTimers.values()) clearTimeout(timer);
     this.subagentIdleTimers.clear();
     await this.coordinator.stopAll();
+    for (const [id, waiter] of this.taskWaiters) {
+      waiter.resolve({
+        taskId: id,
+        subagentId: "director",
+        status: "stopped",
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      });
+    }
+    this.taskWaiters.clear();
     for (const b of this.subagentBridges.values()) {
       await b.stop().catch((err) => this.logShutdownError("subagent_bridge_stop", err));
     }
@@ -10988,6 +11170,7 @@ var Director = class _Director {
     await this.bridge.stop().catch((err) => this.logShutdownError("director_bridge_stop", err));
     if (this.fleetManager) {
       await this.fleetManager.flushManifest().catch((err) => this.logShutdownError("fleet_manifest_flush", err));
+      await this.manifestWriteChain.catch(() => void 0);
     } else if (this.manifestPath) {
       await this.writeManifest().catch((err) => this.logShutdownError("manifest_write", err));
     }
@@ -11453,22 +11636,7 @@ var Director = class _Director {
    * three agents complete or the session times out.
    */
   async spawnCollab(options) {
-    const session = new CollabSession(this, this.fleet, {
-      ...options,
-      onBudgetWarning: (alert) => {
-        return options.onBudgetWarning?.(alert) ?? "ignore";
-      }
-    });
-    const doneHandler = () => this._activeCollabSessions.delete(session.sessionId);
-    const errorHandler = () => this._activeCollabSessions.delete(session.sessionId);
-    session.on("session.done", doneHandler);
-    session.on("session.error", errorHandler);
-    const unsubs = [
-      () => session.off("session.done", doneHandler),
-      () => session.off("session.error", errorHandler)
-    ];
-    this._activeCollabSessions.set(session.sessionId, { session, unsubs });
-    return session.start();
+    return this.collab.spawn(options);
   }
   /**
    * Resume from a prior checkpoint snapshot (loaded via
@@ -12341,8 +12509,8 @@ var SessionCheckpointCas = class {
           return null;
         }
         try {
-          const stat13 = await fsp7.lstat(absolute);
-          if (stat13.isSymbolicLink()) {
+          const stat12 = await fsp7.lstat(absolute);
+          if (stat12.isSymbolicLink()) {
             const linkTarget = await fsp7.readlink(absolute);
             const resolvedLink = path9.resolve(path9.dirname(absolute), linkTarget);
             if (path9.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
@@ -12354,29 +12522,29 @@ var SessionCheckpointCas = class {
             }
             return { path: relative4, state: "symlink", linkTarget };
           }
-          if (!stat13.isFile()) {
+          if (!stat12.isFile()) {
             unresolved.push({ path: relative4, reason: "changed path is not a regular file" });
             return null;
           }
-          if (stat13.size > MAX_BLOB_BYTES) {
+          if (stat12.size > MAX_BLOB_BYTES) {
             unresolved.push({
               path: relative4,
               reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
             });
             return null;
           }
-          if (scheduledBytes + stat13.size > MAX_CHECKPOINT_BYTES) {
+          if (scheduledBytes + stat12.size > MAX_CHECKPOINT_BYTES) {
             unresolved.push({
               path: relative4,
               reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
             });
             return null;
           }
-          scheduledBytes += stat13.size;
+          scheduledBytes += stat12.size;
           const content = await fsp7.readFile(absolute);
           const blobHash = sha256(content);
           await this.putBlob(blobHash, content);
-          return { path: relative4, state: "file", blobHash, mode: stat13.mode & 511 };
+          return { path: relative4, state: "file", blobHash, mode: stat12.mode & 511 };
         } catch (err) {
           if (err.code === "ENOENT") {
             return { path: relative4, state: "absent" };
@@ -12697,11 +12865,11 @@ async function validateOne(observation, lexicalRoot, realRoot) {
     };
   }
   try {
-    const stat13 = await fsp8.stat(realFile);
-    if (!stat13.isFile()) {
+    const stat12 = await fsp8.stat(realFile);
+    if (!stat12.isFile()) {
       return { ...base, status: "unreadable", detail: "Path is no longer a regular file." };
     }
-    if (stat13.size > MAX_REVALIDATE_BYTES) {
+    if (stat12.size > MAX_REVALIDATE_BYTES) {
       return {
         ...base,
         status: "unreadable",
@@ -13150,9 +13318,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let cacheHit = false;
     try {
       const s = await fsp9.stat(file);
-      const stat13 = { mtimeMs: s.mtimeMs, size: s.size };
+      const stat12 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat13.mtimeMs && cached.size === stat13.size) {
+      if (cached && cached.mtimeMs === stat12.mtimeMs && cached.size === stat12.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
@@ -13293,7 +13461,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
             this._loadCache.delete(oldest);
           }
         }
-        this._loadCache.set(id, { mtimeMs: stat13.mtimeMs, size: stat13.size, data });
+        this._loadCache.set(id, { mtimeMs: stat12.mtimeMs, size: stat12.size, data });
       }
       return data;
     } catch (err) {
@@ -13335,14 +13503,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = opts?.limit;
     const signal = opts?.signal;
     const out = [];
-    let stat13;
+    let stat12;
     try {
-      stat13 = await fsp9.stat(file);
+      stat12 = await fsp9.stat(file);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
-    if (stat13.size === 0) return [];
+    if (stat12.size === 0) return [];
     let fh;
     try {
       fh = await fsp9.open(file, "r");
@@ -13525,15 +13693,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
-    let stat13;
+    let stat12;
     try {
       const s = await fsp9.stat(this.indexFile);
-      stat13 = { mtimeMs: s.mtimeMs, size: s.size };
+      stat12 = { mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       this._indexCache = null;
       return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat13.mtimeMs && this._indexCache.size === stat13.size) {
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat12.mtimeMs && this._indexCache.size === stat12.size) {
       return [...this._indexCache.summaries];
     }
     let raw;
@@ -13566,7 +13734,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (a.startedAt > b.startedAt) return -1;
       return a.id.localeCompare(b.id);
     });
-    this._indexCache = { ...stat13, summaries };
+    this._indexCache = { ...stat12, summaries };
     return [...summaries];
   }
   /**
@@ -13733,8 +13901,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (fromManifest) return fromManifest;
     try {
       const full = this.sessionPath(id, ".jsonl");
-      const stat13 = await fsp9.stat(full);
-      const summary = await this.summarize(id, stat13.mtime.toISOString());
+      const stat12 = await fsp9.stat(full);
+      const summary = await this.summarize(id, stat12.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -13774,18 +13942,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async summaryHeaderFor(ref) {
     let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const stat13 = await fsp9.stat(ref.filePath);
-      if (!stat13.isFile()) {
+      const stat12 = await fsp9.stat(ref.filePath);
+      if (!stat12.isFile()) {
         return {
           id: ref.id,
           title: "(damaged)",
-          startedAt: stat13.mtime.toISOString(),
+          startedAt: stat12.mtime.toISOString(),
           model: "unknown",
           provider: "unknown",
           tokenTotal: 0
         };
       }
-      mtime = stat13.mtime.toISOString();
+      mtime = stat12.mtime.toISOString();
     } catch {
       return null;
     }
@@ -13941,8 +14109,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path11.join(dir, name);
       try {
-        const stat13 = await fsp9.stat(jsonlPath);
-        if (stat13.mtimeMs >= cutoff) return;
+        const stat12 = await fsp9.stat(jsonlPath);
+        if (stat12.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -14158,6 +14326,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   failureMode;
   policyProvider;
   sessionBridge;
+  onCompact;
   /**
    * Once a compaction attempt reduces nothing (preserveK protects everything,
    * no oversized tool_results remain to elide), retrying on every iteration
@@ -14204,6 +14373,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     this.failureMode = opts.failureMode ?? "throw_on_hard";
     this.policyProvider = opts.policyProvider;
     this.sessionBridge = opts.sessionBridge;
+    this.onCompact = opts.onCompact;
   }
   /** Allow callers (e.g. model-switch in WebUI) to update the context window
    *  denominator when the active model changes. */
@@ -14326,6 +14496,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     try {
       const report = await this.compactor.compact(ctx, { aggressive });
       this.recordAttempt(pressure.level, pressure.tokens, report);
+      this.onCompact?.(report);
       this.events?.emit("compaction.fired", {
         sessionId: ctx.session.id,
         level: pressure.level,
@@ -14354,7 +14525,8 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
       });
       ctx.clearFileTracking();
       const afterTokens = report.fullRequestTokensAfter ?? report.after;
-      const afterLoad = this._maxContext > 0 ? afterTokens / this._maxContext : 0;
+      const afterBudget = computeContextWindowBudget(ctx, afterTokens, this._maxContext);
+      const afterLoad = afterBudget.load;
       const stillHard = afterLoad >= pressure.hardThreshold;
       const fatal = stillHard && (this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard");
       if (stillHard) {
@@ -15009,7 +15181,7 @@ function eliseOldToolResults(messages, opts) {
     }
     if (newContent) {
       next ??= messages.slice();
-      next[i] = { ...msg, content: newContent };
+      next[i] = { ...msg, content: newContent, _estTokens: void 0 };
       changed = true;
     }
     if (compactionDebugEnabled()) {
@@ -15269,7 +15441,7 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   descriptionMode: Object.freeze({}),
   disabledTools: Object.freeze([]),
   autoExtendLimit: true,
-  restrictToProjectRoot: false,
+  restrictToProjectRoot: true,
   loopDetection: Object.freeze({
     mode: "steer-then-cut",
     steerThreshold: 3,
@@ -15279,8 +15451,8 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   })
 });
 var DEFAULT_CONTEXT_CONFIG = Object.freeze({
-  preserveK: 10,
-  eliseThreshold: 2e3
+  preserveK: 8,
+  eliseThreshold: 1e3
 });
 var DEFAULT_AUTONOMY_CONFIG = Object.freeze({
   autoProceedDelayMs: 45e3
@@ -15443,7 +15615,7 @@ function isDesignStack(v) {
 
 // src/execution/design-kit-loader.ts
 import { existsSync } from "node:fs";
-import * as fs2 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import * as path13 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var KIT_FILE = "KIT.md";
@@ -15483,17 +15655,17 @@ function parseKitFrontmatter(raw) {
     else out[key] = items;
   };
   for (const line of lines) {
-    const item = /^\s*-\s+(.*)$/.exec(line);
-    if (listKey && item) {
-      const parsed = parseList(item[1] ?? "");
+    const bulletMatch = /^\s*-\s+(.*)$/.exec(line);
+    if (listKey && bulletMatch) {
+      const parsed = parseList(bulletMatch[1] ?? "");
       if (listKey === "stacks") out.stacks.push(...parsed.filter(isDesignStack));
       else out[listKey].push(...parsed);
       continue;
     }
-    const m = /^([a-zA-Z_]+):\s*(.*)$/.exec(line);
-    if (!m) continue;
-    const key = m[1] ?? "";
-    const rest = (m[2] ?? "").trim();
+    const kvMatch = /^([a-zA-Z_]+):\s*(.*)$/.exec(line);
+    if (!kvMatch) continue;
+    const key = kvMatch[1] ?? "";
+    const rest = (kvMatch[2] ?? "").trim();
     if (key === "tags" || key === "stacks" || key === "themes") {
       if (rest) {
         setList(key, parseList(rest));
@@ -15510,24 +15682,23 @@ function parseKitFrontmatter(raw) {
 }
 function narrowStackSections(body, stack) {
   if (!stack) return body;
-  const re = /^##\s+Stack:\s*([a-z-]+)\s*$/gim;
-  const matches = [];
-  let m;
-  while ((m = re.exec(body)) !== null) {
-    matches.push({ id: (m[1] ?? "").trim(), start: m.index });
-  }
-  if (matches.length === 0) return body;
-  const firstStart = matches[0]?.start ?? body.length;
-  let result = body.slice(0, firstStart).trimEnd();
-  for (let i = 0; i < matches.length; i++) {
-    const cur = matches[i];
-    if (!cur) continue;
-    const next = matches[i + 1];
-    const sectionEnd = next ? next.start : body.length;
-    if (cur.id === stack) {
+  const stackHeading = /^##\s+Stack:\s*([a-z-]+)\s*$/gim;
+  const sections = [];
+  let match;
+  while ((match = stackHeading.exec(body)) !== null) {
+    sections.push({ id: (match[1] ?? "").trim(), start: match.index });
+  }
+  if (sections.length === 0) return body;
+  const preambleEnd = sections[0].start;
+  let result = body.slice(0, preambleEnd).trimEnd();
+  let sectionEnd;
+  for (let i = 0; i < sections.length; i++) {
+    const current = sections[i];
+    sectionEnd = i + 1 < sections.length ? sections[i + 1].start : body.length;
+    if (current.id === stack) {
       result += `
 
-${body.slice(cur.start, sectionEnd).trimEnd()}`;
+${body.slice(current.start, sectionEnd).trimEnd()}`;
     }
   }
   return `${result}
@@ -15552,7 +15723,7 @@ var DefaultDesignKitLoader = class {
     for (const { dir, source } of this.dirs) {
       let entries;
       try {
-        entries = await fs2.readdir(dir, { withFileTypes: true });
+        entries = await fs3.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -15560,7 +15731,7 @@ var DefaultDesignKitLoader = class {
         if (!e.isDirectory()) continue;
         const kitFile = path13.join(dir, e.name, KIT_FILE);
         try {
-          const raw = await fs2.readFile(kitFile, "utf8");
+          const raw = await fs3.readFile(kitFile, "utf8");
           const fm = parseKitFrontmatter(raw);
           const id = fm.id ?? e.name;
           if (!fm.name) continue;
@@ -15621,7 +15792,7 @@ var DefaultDesignKitLoader = class {
     if (cached !== void 0) return cached;
     const m = await this.find(id);
     if (!m) throw new Error(`Design kit "${id}" not found`);
-    const raw = await fs2.readFile(m.path, "utf8");
+    const raw = await fs3.readFile(m.path, "utf8");
     const body = narrowStackSections(stripFrontmatter(raw), stack);
     this.bodyCache.set(key, body);
     return body;
@@ -15634,7 +15805,7 @@ var DefaultDesignKitLoader = class {
     if (m) {
       const tokensPath = path13.join(path13.dirname(m.path), TOKENS_FILE);
       try {
-        const raw = await fs2.readFile(tokensPath, "utf8");
+        const raw = await fs3.readFile(tokensPath, "utf8");
         const parsed = JSON.parse(raw);
         tokens = parsed;
       } catch {
@@ -15692,7 +15863,7 @@ function _resetDesignKitLoaderMemo() {
 
 // src/execution/design-project-store.ts
 import { existsSync as existsSync2 } from "node:fs";
-import * as fs3 from "node:fs/promises";
+import * as fs4 from "node:fs/promises";
 import * as path14 from "node:path";
 var DESIGN_DIR = ".design";
 function designProjectDir(projectRoot) {
@@ -15705,7 +15876,7 @@ async function loadProjectDesignRules(projectRoot) {
   let rules;
   for (const name of RULE_FILES) {
     try {
-      const txt = await fs3.readFile(path14.join(designProjectDir(projectRoot), name), "utf8");
+      const txt = await fs4.readFile(path14.join(designProjectDir(projectRoot), name), "utf8");
       if (txt.trim()) {
         rules = txt.trim();
         break;
@@ -15726,7 +15897,7 @@ function parseOverrides(value) {
 }
 async function loadActiveKit(projectRoot) {
   try {
-    const raw = await fs3.readFile(path14.join(designProjectDir(projectRoot), "active.json"), "utf8");
+    const raw = await fs4.readFile(path14.join(designProjectDir(projectRoot), "active.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.kit === "string") {
       return {
@@ -15759,11 +15930,11 @@ function applyTokenOverrides(tokens, overrides) {
 }
 async function ensureDesignDir(projectRoot) {
   const dir = designProjectDir(projectRoot);
-  await fs3.mkdir(dir, { recursive: true });
+  await fs4.mkdir(dir, { recursive: true });
   const gi = path14.join(dir, ".gitignore");
   if (!existsSync2(gi)) {
     try {
-      await fs3.writeFile(gi, "*\n");
+      await fs4.writeFile(gi, "*\n");
     } catch {
     }
   }
@@ -15774,11 +15945,11 @@ async function recordKitChoice(projectRoot, kit, stack, source, isoTime, overrid
     const dir = await ensureDesignDir(projectRoot);
     const record = { kit, stack: stack ?? null };
     if (overrides && Object.keys(overrides).length > 0) record.overrides = overrides;
-    await fs3.writeFile(path14.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs4.writeFile(path14.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const line = `- ${isoTime} \xB7 kit=${kit}${stack ? ` stack=${stack}` : ""} \xB7 via=${source}
 `;
-    await fs3.appendFile(path14.join(dir, "decisions.md"), line);
+    await fs4.appendFile(path14.join(dir, "decisions.md"), line);
   } catch {
   }
 }
@@ -15794,10 +15965,10 @@ async function recordOverrides(projectRoot, patch, isoTime) {
     const dir = await ensureDesignDir(projectRoot);
     const record = { kit: active.kit, stack: active.stack ?? null };
     if (Object.keys(merged).length > 0) record.overrides = merged;
-    await fs3.writeFile(path14.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs4.writeFile(path14.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const keys = Object.keys(patch).join(",");
-    await fs3.appendFile(
+    await fs4.appendFile(
       path14.join(dir, "decisions.md"),
       `- ${isoTime} \xB7 kit=${active.kit} \xB7 override=${keys} \xB7 via=set
 `
@@ -15808,7 +15979,7 @@ async function recordOverrides(projectRoot, patch, isoTime) {
 }
 async function clearPersistedActiveKit(projectRoot) {
   try {
-    await fs3.rm(path14.join(designProjectDir(projectRoot), "active.json"), { force: true });
+    await fs4.rm(path14.join(designProjectDir(projectRoot), "active.json"), { force: true });
   } catch {
   }
 }
@@ -15924,12 +16095,12 @@ function verifyFiles(tokens, files) {
   const violations = [];
   let onPalette = 0;
   let offPalette = 0;
-  for (const { path: path29, text } of files) {
+  for (const { path: path28, text } of files) {
     const lines = text.split("\n");
     lines.forEach((lineText, i) => {
       const lineNo = i + 1;
       const flag = (snippet, reason) => {
-        violations.push({ file: path29, line: lineNo, snippet: snippet.slice(0, 80), reason });
+        violations.push({ file: path28, line: lineNo, snippet: snippet.slice(0, 80), reason });
       };
       for (const re of [HEX_RE, FUNC_COLOR_RE]) {
         re.lastIndex = 0;
@@ -16433,11 +16604,25 @@ function buildRecoveryStrategies(opts) {
     },
     {
       label: "rate_limit_backoff",
-      async attempt(err) {
+      async attempt(err, ctx) {
         if (!(err instanceof ProviderError) || err.kind !== "rate_limit") return null;
         const delayMs = err.body?.retryAfterMs ?? 5e3;
         const delay = Math.min(6e4, Math.max(1e3, delayMs));
-        await new Promise((r) => setTimeout(r, delay));
+        if (ctx?.signal) {
+          await new Promise((resolve12) => {
+            if (ctx.signal.aborted) {
+              resolve12();
+              return;
+            }
+            const timer = setTimeout(resolve12, delay);
+            ctx.signal.addEventListener("abort", () => {
+              clearTimeout(timer);
+              resolve12();
+            }, { once: true });
+          });
+        } else {
+          await new Promise((r) => setTimeout(r, delay));
+        }
         return { action: "retry", reason: "rate_limit_backoff" };
       }
     },
@@ -17170,8 +17355,8 @@ ${recentJournal}` : "No prior iterations.",
     });
     await saveGoal(this.goalPath, withEntry, this.opts.events);
     try {
-      const { unlink: unlink12 } = await import("node:fs/promises");
-      await unlink12(this.goalPath);
+      const { unlink: unlink11 } = await import("node:fs/promises");
+      await unlink11(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -17188,8 +17373,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned, this.opts.events);
     }
     try {
-      const { unlink: unlink12 } = await import("node:fs/promises");
-      await unlink12(this.goalPath);
+      const { unlink: unlink11 } = await import("node:fs/promises");
+      await unlink11(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -17318,16 +17503,18 @@ var IntelligentCompactor = class {
   eliseThreshold;
   summarizerPrompt;
   summarizerModel;
+  oneShotOrchestrator;
   constructor(opts) {
     this.provider = opts.provider;
-    this.warnThreshold = opts.warnThreshold ?? 0.6;
-    this.softThreshold = opts.softThreshold ?? 0.75;
-    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.warnThreshold = opts.warnThreshold ?? 0.5;
+    this.softThreshold = opts.softThreshold ?? 0.65;
+    this.hardThreshold = opts.hardThreshold ?? 0.8;
     this.maxContext = opts.maxContext ?? 128e3;
     this.preserveK = opts.preserveK ?? 4;
-    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.eliseThreshold = opts.eliseThreshold ?? 300;
     this.summarizerPrompt = opts.summarizerPrompt ?? readBundledInstructionText("llm/intelligent-compactor-summarizer.md");
     this.summarizerModel = opts.summarizerModel;
+    this.oneShotOrchestrator = opts.oneShotOrchestrator;
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = estimateMessages(ctx.messages);
@@ -17340,7 +17527,7 @@ var IntelligentCompactor = class {
     let collapsedDigest;
     if (aggressive) {
       const phase2 = await this.summarizeAncientTurns(ctx);
-      if (phase2.saved > 0) reductions.push({ phase: "summary", saved: phase2.saved });
+      reductions.push({ phase: "summary", saved: Math.max(0, phase2.saved) });
       collapsedDigest = phase2.digest;
     } else if (load >= this.warnThreshold) {
       const saved2 = this.elide(ctx);
@@ -17394,9 +17581,15 @@ var IntelligentCompactor = class {
     } catch {
       summaryText = buildLosslessDigest(toSummarize) || `${toSummarize.length} earlier turns (semantic content preserved)`;
     }
+    const smartDigest = buildSmartDigest(toSummarize);
+    const enriched = smartDigest ? `[CRITICAL]
+${smartDigest}
+
+[SUMMARY]
+${summaryText}` : summaryText;
     const summaryMsg = {
       role: "system",
-      content: `[prior_turns_summary: ${summaryText}]`
+      content: `[prior_turns_summary: ${enriched}]`
     };
     const summaryTokens = estimateMessages([summaryMsg]);
     const tail = ctx.messages.slice(boundary);
@@ -17404,27 +17597,41 @@ var IntelligentCompactor = class {
     return { saved: Math.max(0, removedTokens - summaryTokens), digest: summaryText };
   }
   async callSummarizer(messages, ctx) {
-    const prompt = [
-      { type: "text", text: this.summarizerPrompt },
-      { type: "text", text: "\n\nConversation to summarize:\n" },
-      ...this.messagesToText(messages)
-    ];
-    const req = {
-      model: this.summarizerModel ?? ctx.model,
-      system: prompt,
-      messages: [],
-      maxTokens: 1024
-    };
-    const ac = ctx.signal ? void 0 : new AbortController();
-    const signal = ctx.signal ?? ac?.signal;
-    let res;
-    try {
-      res = await this.provider.complete(req, { signal });
-    } finally {
-      ac?.abort();
+    if (this.oneShotOrchestrator) {
+      const result = await this.oneShotOrchestrator.call({
+        system: this.summarizerPrompt,
+        messages: [{ role: "user", content: this.messagesToSummary(messages) }],
+        model: this.summarizerModel ?? "deepseek-chat",
+        timeoutMs: 3e4,
+        maxTokens: 1024,
+        signal: ctx.signal,
+        fallbackProfile: "summary"
+      });
+      if (result.text && !result.error) return result.text;
+    } else {
+      const prompt = [
+        { type: "text", text: this.summarizerPrompt },
+        { type: "text", text: "\n\nConversation to summarize:\n" },
+        ...this.messagesToText(messages)
+      ];
+      const req = {
+        model: this.summarizerModel ?? ctx.model,
+        system: prompt,
+        messages: [],
+        maxTokens: 1024
+      };
+      const ac = ctx.signal ? void 0 : new AbortController();
+      const signal = ctx.signal ?? ac?.signal;
+      let res;
+      try {
+        res = await this.provider.complete(req, { signal });
+      } finally {
+        ac?.abort();
+      }
+      const textBlocks = res.content.filter(isTextBlock);
+      return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
     }
-    const textBlocks = res.content.filter(isTextBlock);
-    return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
+    return "(empty summary)";
   }
   messagesToText(messages) {
     const lines = [];
@@ -17441,6 +17648,22 @@ var IntelligentCompactor = class {
     }
     return [{ type: "text", text: lines.join("\n") }];
   }
+  /** Compact string summary of messages (no TextBlock wrapper). */
+  messagesToSummary(messages) {
+    const lines = [];
+    for (const m of messages) {
+      const role = m.role.padEnd(10, " ");
+      if (typeof m.content === "string") {
+        lines.push(`[${role}]: ${m.content.slice(0, 500)}`);
+      } else if (Array.isArray(m.content)) {
+        const textParts = m.content.filter(isTextBlock).map((b) => b.text);
+        if (textParts.length > 0) {
+          lines.push(`[${role}]: ${textParts.join(" ").slice(0, 500)}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
 };
 
 // src/execution/parallel-eternal-engine.ts
@@ -18396,6 +18619,7 @@ var LLMSelector = class {
   maxContextTokens;
   systemPrompt;
   maxOutputTokens;
+  oneShotOrchestrator;
   constructor(opts) {
     this.provider = opts.provider;
     this.model = opts.model ?? "unknown";
@@ -18407,6 +18631,7 @@ var LLMSelector = class {
     this.maxContextTokens = opts.maxContextTokens ?? 4e4;
     this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.maxOutputTokens = opts.maxOutputTokens ?? 1024;
+    this.oneShotOrchestrator = opts.oneShotOrchestrator;
   }
   async select(messages, maxToKeep) {
     const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
@@ -18430,12 +18655,23 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
     let raw;
     const ac = new AbortController();
     try {
-      const timeoutSignal = AbortSignal.timeout(3e4);
-      const res = await this.provider.complete(req, {
-        signal: AbortSignal.any([ac.signal, timeoutSignal])
-      });
-      const textBlocks = res.content.filter(isTextBlock);
-      raw = textBlocks.map((b) => b.text).join("\n").trim();
+      if (this.oneShotOrchestrator) {
+        const result = await this.oneShotOrchestrator.call({
+          system: systemText + budgetInstruction,
+          userPrompt: historyText,
+          maxTokens: this.maxOutputTokens,
+          timeoutMs: 3e4
+        });
+        if (result.error) throw new Error(result.error);
+        raw = result.text;
+      } else {
+        const timeoutSignal = AbortSignal.timeout(3e4);
+        const res = await this.provider.complete(req, {
+          signal: AbortSignal.any([ac.signal, timeoutSignal])
+        });
+        const textBlocks = res.content.filter(isTextBlock);
+        raw = textBlocks.map((b) => b.text).join("\n").trim();
+      }
     } catch (err) {
       if (err instanceof Error) {
         console.warn(
@@ -18555,12 +18791,12 @@ var SelectiveCompactor = class {
   constructor(opts) {
     this.provider = opts.provider;
     this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel, maxOutputTokens: opts.selectorMaxOutputTokens });
-    this.warnThreshold = opts.warnThreshold ?? 0.6;
-    this.softThreshold = opts.softThreshold ?? 0.75;
-    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.warnThreshold = opts.warnThreshold ?? 0.5;
+    this.softThreshold = opts.softThreshold ?? 0.65;
+    this.hardThreshold = opts.hardThreshold ?? 0.8;
     this.maxContext = opts.maxContext ?? 128e3;
     this.preserveK = opts.preserveK ?? 4;
-    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.eliseThreshold = opts.eliseThreshold ?? 300;
     this.summarizerModel = opts.summarizerModel ?? opts.selectorModel;
     if (this.summarizerModel === void 0 && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
       console.warn(
@@ -18753,7 +18989,7 @@ Summarize the following message range:`;
 };
 
 // src/execution/skill-loader.ts
-import * as fs4 from "node:fs/promises";
+import * as fs5 from "node:fs/promises";
 import * as path15 from "node:path";
 
 // src/skills/foreign-sources.ts
@@ -18984,7 +19220,7 @@ async function entryIsDirectory(dir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
     try {
-      return (await fs4.stat(path15.join(dir, entry.name))).isDirectory();
+      return (await fs5.stat(path15.join(dir, entry.name))).isDirectory();
     } catch {
       return false;
     }
@@ -19027,12 +19263,12 @@ var DefaultSkillLoader = class {
     const seen = /* @__PURE__ */ new Set();
     for (const { dir, source, originTool } of this.dirs) {
       try {
-        const entries = await fs4.readdir(dir, { withFileTypes: true });
+        const entries = await fs5.readdir(dir, { withFileTypes: true });
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
           const skillFile = path15.join(dir, e.name, "SKILL.md");
           try {
-            const raw = await fs4.readFile(skillFile, "utf8");
+            const raw = await fs5.readFile(skillFile, "utf8");
             const fm = parseSkillFrontmatter(raw);
             if (!fm.name || !fm.description) continue;
             if (!isValidSkillNameFormat(fm.name)) continue;
@@ -19104,7 +19340,7 @@ var DefaultSkillLoader = class {
     if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    const body = await fs4.readFile(m.path, "utf8");
+    const body = await fs5.readFile(m.path, "utf8");
     this.bodyCache.set(key, body);
     return body;
   }
@@ -19117,9 +19353,9 @@ var DefaultSkillLoader = class {
     const savePath = path15.join(path15.dirname(m.path), "SKILL.save.md");
     let result;
     try {
-      result = await fs4.readFile(savePath, "utf8");
+      result = await fs5.readFile(savePath, "utf8");
     } catch {
-      const full = await fs4.readFile(m.path, "utf8");
+      const full = await fs5.readFile(m.path, "utf8");
       const body = stripFrontmatter2(full);
       const compact = compactSkillBody(body);
       if (compact) {
@@ -19147,11 +19383,11 @@ function parseDescriptionFromText(desc) {
 }
 
 // src/execution/prompt-loader.ts
-import * as fs6 from "node:fs/promises";
+import * as fs7 from "node:fs/promises";
 import * as path17 from "node:path";
 
 // src/storage/prompt-store.ts
-import * as fs5 from "node:fs/promises";
+import * as fs6 from "node:fs/promises";
 import * as path16 from "node:path";
 var SCHEMA_VERSION = 2;
 function migratePromptEntry(raw) {
@@ -19213,12 +19449,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fs5.readdir(this.dir);
+      const files = await fs6.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs5.readFile(path16.join(this.dir, file), "utf8")
+            await fs6.readFile(path16.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -19234,7 +19470,7 @@ var DefaultPromptStore = class {
   async get(id) {
     const file = path16.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fs5.readFile(file, "utf8"));
+      const raw = JSON.parse(await fs6.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -19249,7 +19485,7 @@ var DefaultPromptStore = class {
   async delete(id) {
     const file = path16.join(this.dir, `${id}.json`);
     try {
-      await fs5.unlink(file);
+      await fs6.unlink(file);
       return true;
     } catch {
       return false;
@@ -19449,7 +19685,7 @@ var DefaultPromptLoader = class {
     const files = await walkJson(dir);
     for (const file of files) {
       try {
-        const parsed = JSON.parse(await fs6.readFile(file, "utf8"));
+        const parsed = JSON.parse(await fs7.readFile(file, "utf8"));
         const migrated = migratePromptEntry(parsed);
         if (migrated) out.push({ ...migrated, source: "builtin" });
       } catch {
@@ -19463,7 +19699,7 @@ async function walkJson(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs6.readdir(dir, { withFileTypes: true });
+    entries = await fs7.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
@@ -19640,7 +19876,8 @@ var ProviderBackedCompactor = class {
     }
     return new IntelligentCompactor({
       ...common,
-      summarizerModel: this.opts.summarizerModel
+      summarizerModel: this.opts.summarizerModel,
+      oneShotOrchestrator: this.opts.oneShotOrchestrator
     });
   }
 };
@@ -19655,9 +19892,12 @@ function readPolicy(ctx) {
 // src/execution/tool-executor.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import * as fs7 from "node:fs/promises";
+import * as fs8 from "node:fs/promises";
 import * as path18 from "node:path";
 
+// src/types/tool-executor.ts
+var GOVERNED_TOOL_EXECUTOR_META_KEY = "toolExecutor.executeGoverned";
+
 // src/types/tool-markers.ts
 var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
 
@@ -19774,6 +20014,18 @@ var ToolExecutor = class _ToolExecutor {
    * Returns the execution results and the remaining output budget.
    */
   async executeBatch(toolUses, ctx, strategy) {
+    return this.withGovernedExecutionBridge(
+      ctx,
+      () => this.executeBatchInternal(toolUses, ctx, strategy)
+    );
+  }
+  /**
+   * Internal batch implementation. Nested meta-tool calls enter here through
+   * the governed bridge so they traverse the same validation, hooks,
+   * permission/capability, timeout, scrubbing, and audit path without
+   * replacing the bridge that is already active for the outer call.
+   */
+  async executeBatchInternal(toolUses, ctx, strategy) {
     let budget = this.opts.perIterationOutputCapBytes ?? 1e5;
     const runOne = async (use0) => {
       const start = Date.now();
@@ -19944,8 +20196,9 @@ ${errorDetails}`,
           );
           if (post.additionalContext) {
             if (post.contextAs === "separate") {
-              const block = { type: "text", text: post.additionalContext };
-              ctx.state.appendMessage({ role: "user", content: [block] });
+              ctx.pendingPostToolContext = ctx.pendingPostToolContext ? `${ctx.pendingPostToolContext}
+
+${post.additionalContext}` : post.additionalContext;
             } else {
               const appended = `
 
@@ -20045,14 +20298,56 @@ ${post.additionalContext}`;
     };
   }
   /**
-   * Execute a single tool with timeout, permission check, and output capping.
-   * Emits `tool.started` via the injected EventBus (if any) right before
-   * invoking the tool — closes the observability gap between "model decided
-   * to call a tool" and "tool.executed".
+   * Install the executor-owned bridge used by meta-tools for nested calls.
+   * The bridge deliberately returns the governed, scrubbed ToolResultBlock
+   * content rather than the raw tool value. This prevents a meta-tool from
+   * bypassing output controls while preserving structured success/failure.
+   */
+  async withGovernedExecutionBridge(ctx, run) {
+    const previous = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
+    if (typeof previous === "function") return run();
+    const bridge = async (toolName, input) => {
+      const nestedUse = {
+        type: "tool_use",
+        id: `nested-${randomUUID10()}`,
+        name: toolName,
+        input
+      };
+      const batch = await this.executeBatchInternal([nestedUse], ctx, "sequential");
+      const output = batch.outputs[0];
+      if (!output) {
+        return { success: false, error: `tool "${toolName}" produced no result` };
+      }
+      if (output.result.type === "tool_confirm_pending") {
+        return {
+          success: false,
+          error: `tool "${toolName}" requires separate confirmation; call it directly`
+        };
+      }
+      if (output.result.is_error) {
+        return { success: false, error: String(output.result.content) };
+      }
+      return { success: true, result: output.result.content };
+    };
+    ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY] = bridge;
+    try {
+      return await run();
+    } finally {
+      if (previous === void 0) delete ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
+      else ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY] = previous;
+    }
+  }
+  /**
+   * Execute a single tool with timeout and output capping after its permission
+   * decision has already been resolved by executeBatch/the confirmation flow.
+   * Also installs the governed bridge because confirmed tools are re-run
+   * through this method after a pending confirmation.
    */
   async executeTool(tool, use, ctx, budget) {
-    const text = await this.produceToolOutput(tool, use, ctx, budget);
-    return this.settleToolOutput(tool, use, text, budget);
+    return this.withGovernedExecutionBridge(ctx, async () => {
+      const text = await this.produceToolOutput(tool, use, ctx, budget);
+      return this.settleToolOutput(tool, use, text, budget);
+    });
   }
   /**
    * Async "produce" phase: run the tool, serialize, scrub, and spill an
@@ -20407,11 +20702,11 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
   }
   try {
     const dir = path18.join(wstackGlobalRoot(), "tool-output");
-    await fs7.mkdir(dir, { recursive: true });
+    await fs8.mkdir(dir, { recursive: true });
     const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const filePath = path18.join(dir, `${stamp}-${safeTool}-${randomUUID10()}.log`);
-    await fs7.writeFile(filePath, content, "utf8");
+    await fs8.writeFile(filePath, content, "utf8");
     const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
     const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
     const previewBytes = Math.min(
@@ -20467,9 +20762,9 @@ function roughEstimate(messages) {
 }
 function createContextManagerTool(opts = {}) {
   const minCompactThreshold = opts.minCompactThreshold ?? 0;
-  const noopRetryDeltaTokens = opts.noopRetryDeltaTokens ?? 2e3;
+  const noopRetryDeltaTokens = opts.noopRetryDeltaTokens ?? 1e3;
   const configuredMaxContext = opts.maxContext;
-  const compactThresholdFraction = opts.compactThresholdFraction ?? 0.5;
+  const compactThresholdFraction = opts.compactThresholdFraction ?? 0.4;
   let lastNoopTokens = 0;
   return {
     name: CONTEXT_MANAGER_TOOL_NAME,
@@ -21107,17 +21402,17 @@ function codexModelMeta(id) {
 }
 
 // src/models/mode-store.ts
-import * as fs8 from "node:fs/promises";
+import * as fs9 from "node:fs/promises";
 import * as path21 from "node:path";
 
 // src/types/mode-prompts.ts
-import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+import { readFileSync as readFileSync4, statSync as statSync4 } from "node:fs";
 import * as path20 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function modePrompt(id) {
   for (const dir of modePromptDirCandidates()) {
     try {
-      return readFileSync3(path20.join(dir, `${id}.md`), "utf8").trimEnd();
+      return readFileSync4(path20.join(dir, `${id}.md`), "utf8").trimEnd();
     } catch {
     }
   }
@@ -21134,7 +21429,7 @@ function modePromptDirCandidates() {
 }
 function isDirectory3(candidate) {
   try {
-    return statSync3(candidate).isDirectory();
+    return statSync4(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -21361,7 +21656,7 @@ var DefaultModeStore = class {
   async loadActiveMode() {
     try {
       const configPath = path21.join(this.configDir, "mode.json");
-      const content = await fs8.readFile(configPath, "utf8");
+      const content = await fs9.readFile(configPath, "utf8");
       const data = JSON.parse(content);
       this.activeModeId = data.activeMode ?? null;
     } catch {
@@ -21370,7 +21665,7 @@ var DefaultModeStore = class {
   }
   async saveActiveMode() {
     try {
-      await fs8.mkdir(this.configDir, { recursive: true });
+      await fs9.mkdir(this.configDir, { recursive: true });
       const configPath = path21.join(this.configDir, "mode.json");
       await atomicWrite(
         configPath,
@@ -21383,13 +21678,13 @@ var DefaultModeStore = class {
 async function loadProjectModes(modesDir) {
   const modes = [];
   try {
-    const entries = await fs8.readdir(modesDir);
+    const entries = await fs9.readdir(modesDir);
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path21.join(modesDir, entry);
-      const stat13 = await fs8.stat(filePath);
-      if (!stat13.isFile()) continue;
-      const content = await fs8.readFile(filePath, "utf8");
+      const stat12 = await fs9.stat(filePath);
+      if (!stat12.isFile()) continue;
+      const content = await fs9.readFile(filePath, "utf8");
       const id = path21.basename(entry, path21.extname(entry));
       modes.push({
         id,
@@ -21407,7 +21702,7 @@ async function loadUserModes(modesDir) {
   const modes = [];
   try {
     const manifestPath = path21.join(modesDir, "modes.json");
-    const content = await fs8.readFile(manifestPath, "utf8");
+    const content = await fs9.readFile(manifestPath, "utf8");
     const manifest = JSON.parse(content);
     for (const mode of manifest.modes) {
       modes.push(mode);
@@ -21418,7 +21713,7 @@ async function loadUserModes(modesDir) {
 }
 
 // src/models/models-registry.ts
-import * as fs9 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 import * as path22 from "node:path";
 var DEFAULT_URL = "https://models.dev/api.json";
 var ENV_URL_KEY = "WRONGSTACK_MODELS_DEV_URL";
@@ -21660,7 +21955,7 @@ var DefaultModelsRegistry = class {
   async readOverlayFile() {
     if (!this.overlayFile) return void 0;
     try {
-      const raw = await fs9.readFile(this.overlayFile, "utf8");
+      const raw = await fs10.readFile(this.overlayFile, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -21739,7 +22034,7 @@ var DefaultModelsRegistry = class {
   }
   async readCacheAt(file) {
     try {
-      const raw = await fs9.readFile(file, "utf8");
+      const raw = await fs10.readFile(file, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -22171,7 +22466,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path29 = opts.path ?? "/metrics";
+  const path28 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -22181,7 +22476,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path29) {
+    if (url === path28) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -22218,9 +22513,9 @@ async function startMetricsServer(opts) {
   let server;
   if (useHttps && tls) {
     const { createServer } = await import("node:https");
-    const { readFileSync: readFileSync5 } = await import("node:fs");
+    const { readFileSync: readFileSync6 } = await import("node:fs");
     server = createServer(
-      { cert: readFileSync5(tls.cert), key: readFileSync5(tls.key) },
+      { cert: readFileSync6(tls.cert), key: readFileSync6(tls.key) },
       listener
     );
   } else {
@@ -22245,7 +22540,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path29}`,
+    url: `${protocol}://${host}:${boundPort}${path28}`,
     close: () => new Promise((resolve12, reject) => {
       server.close((err) => err ? reject(err) : resolve12());
     })
@@ -22517,7 +22812,7 @@ function startOtlpTraceExporter(opts) {
 }
 
 // src/security/permission-policy.ts
-import * as fs10 from "node:fs/promises";
+import * as fs11 from "node:fs/promises";
 
 // src/security/permission-policy-schema.ts
 var TRUST_POLICY_LIMITS = Object.freeze({
@@ -22562,19 +22857,19 @@ var UNSAFE_PROPERTY_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function error(diagnostics, code, path29, message) {
-  diagnostics.push({ severity: "error", code, path: path29, message });
+function error(diagnostics, code, path28, message) {
+  diagnostics.push({ severity: "error", code, path: path28, message });
 }
-function validatePatterns(value, path29, diagnostics) {
+function validatePatterns(value, path28, diagnostics) {
   if (!Array.isArray(value)) {
-    error(diagnostics, "invalid_pattern_list", path29, "must be an array of strings");
+    error(diagnostics, "invalid_pattern_list", path28, "must be an array of strings");
     return void 0;
   }
   if (value.length > TRUST_POLICY_LIMITS.maxPatternsPerRule) {
     error(
       diagnostics,
       "too_many_patterns",
-      path29,
+      path28,
       `must contain at most ${TRUST_POLICY_LIMITS.maxPatternsPerRule} patterns`
     );
     return void 0;
@@ -22582,7 +22877,7 @@ function validatePatterns(value, path29, diagnostics) {
   const patterns = [];
   const seen = /* @__PURE__ */ new Set();
   for (const [index, pattern] of value.entries()) {
-    const itemPath = `${path29}[${index}]`;
+    const itemPath = `${path28}[${index}]`;
     if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > TRUST_POLICY_LIMITS.maxPatternChars) {
       error(
         diagnostics,
@@ -22906,7 +23201,7 @@ var DefaultPermissionPolicy = class {
     this.policyDiagnostics = [];
     this.policyInvalid = false;
     try {
-      const raw = await fs10.readFile(this.trustFile, "utf8");
+      const raw = await fs11.readFile(this.trustFile, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok) {
         this.policy = {};
@@ -23306,7 +23601,12 @@ function hasCredentialAnchors(text) {
   text.includes("_TOKEN=") || // ACCESS_TOKEN=, AUTH_TOKEN=, ...
   text.includes("_SECRET=") || // API_SECRET=, CLIENT_SECRET=, ...
   text.includes("_PASSWORD=") || // DB_PASSWORD=, ROOT_PASSWORD=, ...
-  text.includes("mongodb://") || text.includes("mongodb+srv://") || text.includes("postgres://") || text.includes("postgresql://") || text.includes("mysql://") || text.includes("redis://");
+  text.includes("mongodb://") || text.includes("mongodb+srv://") || text.includes("postgres://") || text.includes("postgresql://") || text.includes("mysql://") || text.includes("redis://") || // JSON-style credential keys: tool outputs often serialise objects as
+  // raw JSON strings rather than parsed objects. The value may not start
+  // with a recognisable prefix (sk-, ghp_, etc.), so we anchor on common
+  // key names. The `"` prefix avoids matching prose that happens to mention
+  // these words — JSON serialisation always quotes string keys.
+  text.includes('"apiKey"') || text.includes('"api_key"') || text.includes('"token"') || text.includes('"secret"') || text.includes('"password"') || text.includes('"authorization"') || text.includes('"bearer"') || text.includes('"private_key"') || text.includes('"access_token"') || text.includes('"refresh_token"') || text.includes('"client_secret"');
 }
 var DefaultSecretScrubber = class {
   scrub(text) {
@@ -23379,7 +23679,7 @@ var DefaultSecretScrubber = class {
 
 // src/security/secret-vault.ts
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes4, scryptSync } from "node:crypto";
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 import * as fsp12 from "node:fs/promises";
 import * as path23 from "node:path";
 
@@ -23424,7 +23724,7 @@ function walk2(node, vault, transform) {
   }
   return out;
 }
-var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key)/i;
+var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key|token\b)/i;
 var NON_SECRET_OVERRIDES = /* @__PURE__ */ new Set(["publickey", "public_key"]);
 function isSecretField(name) {
   const lc = name.toLowerCase();
@@ -23521,8 +23821,8 @@ function checkKeyFilePermissions(keyFile, opts) {
   if (process.platform === "win32") return;
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   try {
-    const stat13 = fs11.statSync(keyFile);
-    const actualMode = stat13.mode & 511;
+    const stat12 = fs12.statSync(keyFile);
+    const actualMode = stat12.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
       warn(
         `Key file ${keyFile} has mode ${actualMode.toString(8)} \u2014 expected ${KEY_FILE_MODE.toString(8)}. Run: chmod ${KEY_FILE_MODE.toString(8)} ${keyFile}`
@@ -23618,16 +23918,16 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes4(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    fs11.mkdirSync(path23.dirname(this.keyFile), { recursive: true });
+    fs12.mkdirSync(path23.dirname(this.keyFile), { recursive: true });
     const passphrase = getVaultPassphrase();
     if (passphrase) {
-      fs11.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
+      fs12.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
     } else {
       const keyFileBuf = Buffer.alloc(VERSIONED_KEY_FILE_SIZE);
       KEY_FILE_MAGIC.copy(keyFileBuf, 0);
       keyFileBuf[KEY_FILE_MAGIC.length] = newVersion;
       newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
-      fs11.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+      fs12.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
     }
     checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
     this.key = newKey;
@@ -23645,7 +23945,7 @@ var DefaultSecretVault = class {
     const passphrase = getVaultPassphrase();
     if (!passphrase || !this.key) return;
     try {
-      fs11.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
+      fs12.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
         mode: 384
       });
       checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
@@ -23655,7 +23955,7 @@ var DefaultSecretVault = class {
   loadOrCreateKey() {
     if (this.key) return this.key;
     try {
-      const buf = fs11.readFileSync(this.keyFile);
+      const buf = fs12.readFileSync(this.keyFile);
       if (isWrappedKeyFile(buf)) {
         const { key: key2, version } = unwrapDataKey(buf, this.keyFile);
         this.key = key2;
@@ -23702,15 +24002,15 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs11.mkdirSync(path23.dirname(this.keyFile), { recursive: true });
+    fs12.mkdirSync(path23.dirname(this.keyFile), { recursive: true });
     const key = randomBytes4(KEY_BYTES);
     const passphrase = getVaultPassphrase();
     const initialBytes = passphrase ? wrapDataKey(key, 1, passphrase) : key;
     try {
-      fs11.writeFileSync(this.keyFile, initialBytes, { mode: 384, flag: "wx" });
+      fs12.writeFileSync(this.keyFile, initialBytes, { mode: 384, flag: "wx" });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
-      const buf = fs11.readFileSync(this.keyFile);
+      const buf = fs12.readFileSync(this.keyFile);
       if (isWrappedKeyFile(buf)) {
         const { key: winnerKey, version } = unwrapDataKey(buf, this.keyFile);
         this.key = winnerKey;
@@ -23984,24 +24284,24 @@ function mergeAdjacentText(blocks) {
 }
 
 // src/storage/config-loader.ts
-import * as fs12 from "node:fs/promises";
+import * as fs13 from "node:fs/promises";
 import * as path25 from "node:path";
 
 // src/types/config.ts
 var DEFAULT_TUI_THINKING_WORD = "thinking";
 
 // src/types/context-window.ts
-var DEFAULT_CONTEXT_WINDOW_MODE_ID = "balanced";
+var DEFAULT_CONTEXT_WINDOW_MODE_ID = "frugal";
 var CONTEXT_WINDOW_MODES = Object.freeze([
   {
     id: "balanced",
     name: "Balanced",
     description: "Default rolling compaction: recent work stays verbatim, old tool output is trimmed.",
-    thresholds: { warn: 0.6, soft: 0.75, hard: 0.9 },
+    thresholds: { warn: 0.5, soft: 0.65, hard: 0.8 },
     aggressiveOn: "soft",
-    preserveK: 10,
-    eliseThreshold: 2e3,
-    targetLoad: 0.65
+    preserveK: 8,
+    eliseThreshold: 1e3,
+    targetLoad: 0.55
   },
   {
     id: "frugal",
@@ -24115,12 +24415,11 @@ var BEHAVIOR_DEFAULTS = {
   mcpServers: {},
   fallbackAuto: true,
   maxConcurrent: 4,
-  // YOLO on by default: auto-approve non-denied tool calls without a per-call
-  // prompt. Users
-  // who want the per-call prompts set `yolo: false`. Existing installs whose
-  // config lacks this key pick it up via fillMissingDefaults; an explicit
-  // `false` is preserved by the deep-merge (opt-out respected).
-  yolo: true,
+  // YOLO opt-in: users who want auto-approve behaviour set `yolo: true`.
+  // Off by default so prompt injection in repository content, fetched
+  // content, or mailbox messages cannot induce arbitrary shell calls or
+  // write operations without human confirmation.
+  yolo: false,
   nextPrediction: false,
   hints: true,
   debugStream: false,
@@ -24145,7 +24444,7 @@ var BEHAVIOR_DEFAULTS = {
     terminalTitleAnimation: true,
     // Mirrored from the top-level yolo default so the autonomy subsystem
     // (which reads autonomy.yolo) stays consistent with config.yolo.
-    yolo: true,
+    yolo: false,
     streamFleet: true,
     chime: false,
     confirmExit: true,
@@ -24597,7 +24896,7 @@ var DefaultConfigLoader = class {
       await withFileLock(fp, async () => {
         let parsed;
         try {
-          const raw = await fs12.readFile(fp, "utf8");
+          const raw = await fs13.readFile(fp, "utf8");
           const result = safeParse(raw);
           if (!result.ok || !isPlainRecord(result.value)) {
             return;
@@ -24706,7 +25005,7 @@ var DefaultConfigLoader = class {
     const fp = this.paths.syncConfig;
     const t0 = Date.now();
     try {
-      const raw = await fs12.readFile(fp, "utf8");
+      const raw = await fs13.readFile(fp, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok || !parsed.value) {
         this.events?.emit("storage.read", {
@@ -24768,8 +25067,8 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat13 = await fs12.stat(file);
-      mtimeMs = stat13.mtimeMs;
+      const stat12 = await fs13.stat(file);
+      mtimeMs = stat12.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
         return structuredClone(cached.value);
@@ -24797,7 +25096,7 @@ var DefaultConfigLoader = class {
     }
     let raw;
     try {
-      raw = await fs12.readFile(file, "utf8");
+      raw = await fs13.readFile(file, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         this.events?.emit("storage.read", {
@@ -25027,938 +25326,9 @@ function deepFreeze(obj) {
   return Object.freeze(obj);
 }
 
-// src/storage/memory-backend.ts
+// src/storage/plan-store.ts
+import * as fsp14 from "node:fs/promises";
 import { randomUUID as randomUUID11 } from "node:crypto";
-import * as fs13 from "node:fs/promises";
-import * as path26 from "node:path";
-
-// src/types/memory.ts
-var MEMORY_TYPE_LABELS = {
-  fact: "Fact",
-  decision: "Decision",
-  convention: "Convention",
-  preference: "Preference",
-  reference: "Reference",
-  anti_pattern: "Anti-pattern"
-};
-
-// src/storage/memory-backend.ts
-var TYPE_PRIORITY_RE = /^\[(\w+)\|(\w+)\]\s+/;
-var TAG_RE = /#([\w-]+)/g;
-var MAX_MEMORY_CONSOLIDATE_BACKUPS = 5;
-function formatMetadata(entry) {
-  const parts = [];
-  if (entry.type && entry.priority) {
-    parts.push(`[${entry.type}|${entry.priority}]`);
-  } else if (entry.type) {
-    parts.push(`[${entry.type}]`);
-  } else if (entry.priority) {
-    parts.push(`[${entry.priority}]`);
-  }
-  if (entry.tags && entry.tags.length > 0) {
-    parts.push(entry.tags.map((t) => `#${t}`).join(" "));
-  }
-  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
-}
-function lineToEntry(line, scope) {
-  const trimmed = line.trim();
-  if (!trimmed.startsWith("- [")) return null;
-  const tsMatch = trimmed.match(/^-\s*\[([^\]]+)\]/);
-  if (!tsMatch) return null;
-  const ts = tsMatch[1] ?? "";
-  let rest = trimmed.slice(tsMatch[0].length).trim();
-  let type;
-  let priority;
-  const tpMatch = rest.match(TYPE_PRIORITY_RE);
-  if (tpMatch) {
-    const a = tpMatch[1] ?? "";
-    const b = tpMatch[2] ?? "";
-    if (isMemoryType(a)) {
-      type = a;
-      priority = isPriority(b) ? b : void 0;
-    } else if (isPriority(a)) {
-      priority = a;
-    }
-    rest = rest.slice(tpMatch[0].length).trim();
-  }
-  const idMatch = rest.match(/^mem_\d+_\w+\s+/);
-  let text;
-  if (idMatch) {
-    text = rest.slice(idMatch[0].length).trim();
-  } else {
-    text = rest.trim();
-  }
-  const tags = [];
-  let tagMatch;
-  TAG_RE.lastIndex = 0;
-  while ((tagMatch = TAG_RE.exec(text)) !== null) {
-    tags.push(tagMatch[1] ?? "");
-  }
-  const cleanText = text.replace(TAG_RE, "").replace(/\s{2,}/g, " ").trim();
-  if (!cleanText) return null;
-  return {
-    scope,
-    text: cleanText,
-    ts,
-    type,
-    priority,
-    tags: tags.length > 0 ? tags : void 0
-  };
-}
-function isMemoryType(s) {
-  return s in MEMORY_TYPE_LABELS;
-}
-function isPriority(s) {
-  return s === "critical" || s === "high" || s === "medium" || s === "low";
-}
-function buildInvertedIndex(entries) {
-  const wordMap = /* @__PURE__ */ new Map();
-  const tagMap = /* @__PURE__ */ new Map();
-  const indexed = new Array(entries.length);
-  for (let i = 0; i < entries.length; i++) {
-    const e = entries[i];
-    const words = e.text.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
-    const tags = (e.tags ?? []).map((t) => t.toLowerCase());
-    indexed[i] = { entry: e, words, tags };
-    for (const w of words) {
-      const arr = wordMap.get(w);
-      if (arr) arr.push(i);
-      else wordMap.set(w, [i]);
-    }
-    for (const t of tags) {
-      const arr = tagMap.get(t);
-      if (arr) arr.push(i);
-      else tagMap.set(t, [i]);
-    }
-  }
-  return { wordMap, tagMap, entries: indexed, mtimeMs: 0 };
-}
-var MIN_SUBSTRING_NEEDLE_LEN = 3;
-function searchIndex(index, query, limit) {
-  const needles = query.toLowerCase().split(/\s+/).filter((n) => n.length > 0);
-  if (needles.length === 0) return [];
-  const scores = /* @__PURE__ */ new Map();
-  for (const n of needles) {
-    let matched = false;
-    const wordExact = index.wordMap.get(n);
-    if (wordExact) {
-      for (const idx of wordExact) scores.set(idx, (scores.get(idx) ?? 0) + 1);
-      matched = true;
-    }
-    const tagExact = index.tagMap.get(n);
-    if (tagExact) {
-      for (const idx of tagExact) scores.set(idx, (scores.get(idx) ?? 0) + 2);
-      matched = true;
-    }
-    if (matched || n.length < MIN_SUBSTRING_NEEDLE_LEN) continue;
-    for (const [word, indices] of index.wordMap) {
-      if (word.includes(n) || n.includes(word)) {
-        for (const idx of indices) {
-          scores.set(idx, (scores.get(idx) ?? 0) + 1);
-        }
-      }
-    }
-    for (const [tag, indices] of index.tagMap) {
-      if (tag.includes(n) || n.includes(tag)) {
-        for (const idx of indices) {
-          scores.set(idx, (scores.get(idx) ?? 0) + 2);
-        }
-      }
-    }
-  }
-  if (scores.size === 0) return [];
-  const scored = Array.from(scores.entries());
-  scored.sort((a, b) => b[1] - a[1]);
-  const result = [];
-  const max = limit ? Math.min(limit, scored.length) : scored.length;
-  for (let i = 0; i < max; i++) {
-    result.push(index.entries[scored[i][0]].entry);
-  }
-  return result;
-}
-var FileMemoryBackend = class {
-  kind = "file";
-  files;
-  /** Cache of parsed entries per file path. */
-  entryCache = /* @__PURE__ */ new Map();
-  /** Inverted index per file path. */
-  indexCache = /* @__PURE__ */ new Map();
-  /** File mtime cache for invalidation. */
-  mtimeCache = /* @__PURE__ */ new Map();
-  constructor(opts) {
-    this.files = {
-      "project-agents": opts.paths.inProjectAgentsFile,
-      "project-memory": opts.paths.projectMemory,
-      "user-memory": opts.paths.globalMemory
-    };
-  }
-  resolveFile(filePath, scope) {
-    return filePath || this.files[scope];
-  }
-  async getMtime(file) {
-    try {
-      const stat13 = await fs13.stat(file);
-      return stat13.mtimeMs;
-    } catch {
-      return 0;
-    }
-  }
-  invalidateCache(file) {
-    this.entryCache.delete(file);
-    this.indexCache.delete(file);
-    this.mtimeCache.delete(file);
-  }
-  /**
-   * Load (and cache) the parsed entries for a file. Callers that have already
-   * stat'd the file this tick (e.g. `getIndex`) can pass the known `mtime` to
-   * avoid a redundant `fs.stat` — otherwise it's fetched here.
-   */
-  async loadEntries(file, scope, mtime) {
-    const resolvedMtime = mtime ?? await this.getMtime(file);
-    const cachedMtime = this.mtimeCache.get(file);
-    if (cachedMtime === resolvedMtime && this.entryCache.has(file)) {
-      return this.entryCache.get(file);
-    }
-    const raw = await this.readAll(scope, file);
-    if (!raw.trim()) {
-      this.entryCache.set(file, []);
-      this.mtimeCache.set(file, resolvedMtime);
-      return [];
-    }
-    const entries = parseEntries(raw, scope);
-    this.entryCache.set(file, entries);
-    this.mtimeCache.set(file, resolvedMtime);
-    return entries;
-  }
-  async getIndex(file, scope) {
-    const mtime = await this.getMtime(file);
-    const cached = this.indexCache.get(file);
-    if (cached && cached.mtimeMs === mtime) {
-      return cached;
-    }
-    const entries = await this.loadEntries(file, scope, mtime);
-    const index = buildInvertedIndex(entries);
-    index.mtimeMs = mtime;
-    this.indexCache.set(file, index);
-    return index;
-  }
-  async remember(scope, entry, filePath) {
-    const file = this.resolveFile(filePath, scope);
-    await ensureDir(path26.dirname(file));
-    let existing = "";
-    try {
-      existing = await fs13.readFile(file, "utf8");
-    } catch {
-    }
-    const id = `mem_${Date.now()}_${randomUUID11().slice(0, 8)}`;
-    const meta = formatMetadata(entry);
-    const line = `
-- [${entry.ts}] ${id}${meta} ${entry.text.replace(/\n/g, " ")}
-`;
-    const next = existing.trim() ? existing.replace(/\n+$/, "") + line : `# Agent Memory
-${line}`;
-    await atomicWrite(file, next);
-    this.invalidateCache(file);
-  }
-  async forget(scope, query, filePath) {
-    const file = this.resolveFile(filePath, scope);
-    return withFileLock(file, async () => {
-      let existing;
-      try {
-        existing = await fs13.readFile(file, "utf8");
-      } catch {
-        return 0;
-      }
-      const needle = query.toLowerCase();
-      const idMatcher = /mem_\d+_\w+/;
-      let removed = 0;
-      const lines = existing.split("\n").filter((line) => {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("- ")) return true;
-        if (idMatcher.test(query)) {
-          const entryIdMatch = /mem_\d+_\w+/.exec(trimmed);
-          if (entryIdMatch && entryIdMatch[0] === query) {
-            removed++;
-            return false;
-          }
-        }
-        if (trimmed.toLowerCase().includes(needle)) {
-          removed++;
-          return false;
-        }
-        return true;
-      });
-      if (removed > 0) {
-        if (lines.length === 0 || lines.length === 1 && !lines[0]?.trim()) {
-          await atomicWrite(file, "");
-        } else {
-          await atomicWrite(file, lines.join("\n"));
-        }
-      }
-      this.invalidateCache(file);
-      return removed;
-    });
-  }
-  async readAll(scope, filePath) {
-    const file = this.resolveFile(filePath, scope);
-    try {
-      return await fs13.readFile(file, "utf8");
-    } catch {
-      return "";
-    }
-  }
-  async list(scope, filePath, limit) {
-    const file = this.resolveFile(filePath, scope);
-    const entries = await this.loadEntries(file, scope);
-    return limit ? entries.slice(0, limit) : entries;
-  }
-  async search(scope, query, filePath, limit) {
-    const file = this.resolveFile(filePath, scope);
-    const index = await this.getIndex(file, scope);
-    return searchIndex(index, query, limit);
-  }
-  async clear(scope, filePath) {
-    const file = this.resolveFile(filePath, scope);
-    await atomicWrite(file, "");
-    this.invalidateCache(file);
-  }
-  async consolidate(scope, filePath) {
-    const file = this.resolveFile(filePath, scope);
-    let existing;
-    try {
-      existing = await fs13.readFile(file, "utf8");
-    } catch {
-      return 0;
-    }
-    const seen = /* @__PURE__ */ new Set();
-    let removed = 0;
-    const lines = existing.split("\n").filter((line) => {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith("- ")) return true;
-      const norm = trimmed.replace(/\[[^\]]+\]/g, "").replace(/\bmem_\d+_\w+\s*/, "").replace(/#[\w-]+/g, "").replace(/\s+/g, " ").trim().toLowerCase();
-      if (seen.has(norm)) {
-        removed++;
-        return false;
-      }
-      seen.add(norm);
-      return true;
-    });
-    const next = lines.join("\n");
-    const backup = `${file}.bak.${Date.now()}`;
-    try {
-      await fs13.copyFile(file, backup);
-      await pruneConsolidateBackups(file);
-    } catch {
-    }
-    try {
-      await atomicWrite(file, next);
-    } catch {
-      return 0;
-    }
-    this.invalidateCache(file);
-    return removed;
-  }
-};
-async function pruneConsolidateBackups(file) {
-  const dir = path26.dirname(file);
-  const base = path26.basename(file);
-  const prefix = `${base}.bak.`;
-  const backups = (await fs13.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
-  await Promise.all(
-    backups.slice(MAX_MEMORY_CONSOLIDATE_BACKUPS).map(async (name) => {
-      try {
-        await fs13.unlink(path26.join(dir, name));
-      } catch {
-      }
-    })
-  );
-}
-function parseEntries(raw, scope = "project-memory") {
-  const entries = [];
-  for (const line of raw.split("\n")) {
-    const entry = lineToEntry(line, scope);
-    if (entry) entries.push(entry);
-  }
-  return entries.reverse();
-}
-
-// src/storage/memory-store.ts
-var MAX_BYTES_TOTAL = 32e3;
-var DefaultMemoryStore = class {
-  files;
-  events;
-  traceId;
-  backend;
-  /**
-   * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
-   * `clear` are read-modify-write against a single file; without a lock,
-   * two concurrent calls on the same scope can read the same baseline and
-   * the later write silently drops the earlier entry. We chain each
-   * mutation onto the prior promise for the same scope so they run in
-   * issue order. Different scopes still proceed in parallel.
-   *
-   * The chain tracks only the last pending write. If a write fails, its
-   * error is caught and swallowed so the chain stays alive for subsequent
-   * calls. The error is stored in `writeErrors` so callers can learn about
-   * it on the next read operation.
-   */
-  writeChain = /* @__PURE__ */ new Map();
-  /** Last write error per scope — surfaced as warnings on the next readAll(). */
-  writeErrors = /* @__PURE__ */ new Map();
-  /**
-   * When the global root is a temporary directory (opencode, CI sandboxes),
-   * memory files are also mirrored to the project tree so they survive
-   * session cleanup. The primary path stays in the temp root for isolation;
-   * this backup ensures memory is never lost.
-   */
-  persistBackup;
-  backupDir;
-  /**
-   * Per-scope tracked byte sizes — incremented on `remember()`, decremented on
-   * `forget()`, recalculated after `consolidate()`. Eliminates the redundant
-   * readAll() call that previously checked the file size after every write.
-   */
-  _trackedByteSizes = {};
-  /** Result cache for scoreRelevant() — keyed by scope + context hash, TTL 30s. */
-  _scoreCache = /* @__PURE__ */ new Map();
-  /**
-   * Per-entry cached lowercase strings — lazily allocated once and reused
-   * across scoreRelevant() calls so repeated scoring of the same entries skips
-   * re-lowercasing. Keyed by entry object identity; cleared (set to null) on
-   * every mutation (remember/forget/consolidate/clear) via invalidateScoreCaches().
-   */
-  _cachedLower = null;
-  constructor(opts) {
-    this.files = {
-      "project-agents": opts.paths.inProjectAgentsFile,
-      "project-memory": opts.paths.projectMemory,
-      "user-memory": opts.paths.globalMemory
-    };
-    this.events = opts.events;
-    this.backend = opts.backend ?? new FileMemoryBackend({ paths: opts.paths });
-    const root = opts.paths.globalRoot.toLowerCase();
-    this.persistBackup = /[/\\](tmp|temp|cache)[/\\]/.test(root);
-    this.backupDir = this.persistBackup ? opts.paths.inProjectAgentsFile.replace(/AGENTS\.md$/, "memory-persist") : "";
-  }
-  /** Expose the backend for plugin introspection and advanced queries. */
-  getBackend() {
-    return this.backend;
-  }
-  async runSerialized(scope, work) {
-    const prior = this.writeChain.get(scope) ?? Promise.resolve();
-    const next = prior.catch((err) => {
-      this.writeErrors.set(scope, err);
-    }).then(() => work());
-    this.writeChain.set(scope, next);
-    try {
-      return await next;
-    } catch (err) {
-      this.writeErrors.set(scope, err);
-      throw err;
-    } finally {
-      if (this.writeChain.get(scope) === next) {
-        this.writeChain.delete(scope);
-      }
-    }
-  }
-  /**
-   * Recalculate the tracked byte size for a scope by re-reading the file and
-   * summing the serialized byte length of each line. Called after consolidate()
-   * (which modifies the file) to keep the tracker accurate.
-   */
-  async _recalcTrackedByteSize(scope) {
-    const raw = await this.backend.readAll(scope, this.files[scope]);
-    let total = 0;
-    for (const line of raw.split("\n")) {
-      if (line.trim()) total += Buffer.byteLength(line, "utf8");
-    }
-    this._trackedByteSizes[scope] = total;
-    return total;
-  }
-  async readAll() {
-    const parts = [];
-    for (const scope of ["project-agents", "project-memory", "user-memory"]) {
-      const writeErr2 = this.writeErrors.get(scope);
-      if (writeErr2) {
-        parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr2.message}`);
-      }
-      const t0 = Date.now();
-      const filePath = this.files[scope];
-      try {
-        const body = await this.backend.readAll(scope, filePath);
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.read", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "readAll",
-          outcome: "success",
-          durationMs: dur,
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        if (body.trim()) parts.push(`## ${labelOf(scope)}
-
-${body.trim()}`);
-      } catch (err) {
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.read", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "readAll",
-          outcome: "failure",
-          durationMs: dur,
-          error: toErrorMessage(err),
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        throw err;
-      }
-    }
-    return parts.join("\n\n");
-  }
-  async read(scope) {
-    const t0 = Date.now();
-    const filePath = this.files[scope];
-    try {
-      const body = await this.backend.readAll(scope, filePath);
-      const dur = Date.now() - t0;
-      this.events?.emit("storage.read", {
-        sessionId: "~memory~",
-        store: "memory",
-        filePath,
-        operation: "read",
-        outcome: "success",
-        durationMs: dur,
-        ...this.traceId !== void 0 && { traceId: this.traceId }
-      });
-      return body;
-    } catch (err) {
-      const dur = Date.now() - t0;
-      this.events?.emit("storage.read", {
-        sessionId: "~memory~",
-        store: "memory",
-        filePath,
-        operation: "read",
-        outcome: "failure",
-        durationMs: dur,
-        error: toErrorMessage(err),
-        ...this.traceId !== void 0 && { traceId: this.traceId }
-      });
-      throw err;
-    }
-  }
-  /**
-   * List entries from a scope, newest first. Delegates to the backend
-   * so graph/semantic backends can return enriched or filtered results.
-   */
-  async list(scope = "project-memory", limit) {
-    return this.backend.list(scope, this.files[scope], limit);
-  }
-  /**
-   * Find memories related to the given text via graph traversal.
-   * Falls back to content search when no graph backend is available.
-   */
-  async findRelated(text, scope = "project-memory", limit = 5) {
-    if (this.backend.findRelated) {
-      return this.backend.findRelated(scope, this.files[scope], text, limit);
-    }
-    return this.search(text, scope, limit);
-  }
-  async search(query, scope = "project-memory", limit) {
-    return this.backend.search(scope, query, this.files[scope], limit);
-  }
-  async remember(text, scope = "project-memory", metadata) {
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    return this.runSerialized(scope, async () => {
-      const entry = { scope, text, ts, ...metadata };
-      const filePath = this.files[scope];
-      const t0 = Date.now();
-      try {
-        await this.backend.remember(scope, entry, filePath);
-        this.invalidateScoreCaches();
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "remember",
-          outcome: "success",
-          durationMs: dur,
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-      } catch (err) {
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "remember",
-          outcome: "failure",
-          durationMs: dur,
-          error: toErrorMessage(err),
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        throw err;
-      }
-      let trackedSize = this._trackedByteSizes[scope];
-      if (trackedSize === void 0) {
-        trackedSize = await this._recalcTrackedByteSize(scope);
-      }
-      if (trackedSize > MAX_BYTES_TOTAL) {
-        const removed = await this.backend.consolidate(scope, this.files[scope]);
-        if (removed > 0) {
-          this.events?.emit("memory.consolidated", {
-            scope,
-            removed
-          });
-          await this._recalcTrackedByteSize(scope);
-        }
-      }
-      this._trackedByteSizes[scope] = (this._trackedByteSizes[scope] ?? 0) + Buffer.byteLength(JSON.stringify(entry), "utf8");
-      await this.mirrorBackup(scope);
-      this.events?.emit("memory.remembered", {
-        scope,
-        text,
-        ts,
-        type: entry.type,
-        tags: entry.tags,
-        priority: entry.priority
-      });
-    });
-  }
-  /**
-   * Drop the relevance caches after a mutation. Both the per-context score
-   * cache and the per-entry lowercase cache are keyed on entry objects that a
-   * mutation invalidates, so they must be cleared together when entries change.
-   */
-  invalidateScoreCaches() {
-    this._scoreCache.clear();
-    this._cachedLower = null;
-  }
-  /**
-   * Score and rank memories by relevance to the current context.
-   * Returns entries with score >= MIN_RELEVANCE_SCORE, sorted highest first.
-   */
-  async scoreRelevant(ctx, scope = "project-memory", limit = 8) {
-    const all = await this.list(scope);
-    if (all.length === 0) return [];
-    const ctxHash = `${scope}|${ctx.currentTask}|${(ctx.activeSkills ?? []).join(",")}|${(ctx.toolNames ?? []).join(",")}`;
-    const now = Date.now();
-    const TTL_MS = 3e4;
-    const cached = this._scoreCache.get(ctxHash);
-    if (cached && cached.expiresAt > now && cached.entries === all) {
-      return cached.scored.slice(0, Math.min(limit, 15));
-    }
-    const taskWords = ctx.currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-    const skillWords = (ctx.activeSkills ?? []).flatMap((s) => s.split("-"));
-    const toolWords = (ctx.toolNames ?? []).flatMap((t) => t.toLowerCase().split("_"));
-    this._cachedLower ??= /* @__PURE__ */ new WeakMap();
-    const lowerCache = this._cachedLower;
-    const scored = [];
-    for (const entry of all) {
-      let score = 0;
-      const reasons = [];
-      let cachedLower = lowerCache.get(entry);
-      if (!cachedLower) {
-        cachedLower = {
-          textLower: entry.text.toLowerCase(),
-          tagsLower: (entry.tags ?? []).map((t) => t.toLowerCase())
-        };
-        lowerCache.set(entry, cachedLower);
-      }
-      const { textLower, tagsLower } = cachedLower;
-      let taskHits = 0;
-      for (const w of taskWords) {
-        if (textLower.includes(w)) {
-          taskHits++;
-          score += 2;
-        }
-        if (tagsLower.some((t) => t.includes(w))) {
-          taskHits++;
-          score += 3;
-        }
-      }
-      if (taskHits > 0) reasons.push(`task match (${taskHits})`);
-      let skillHits = 0;
-      for (const w of skillWords) {
-        if (w.length > 2 && (textLower.includes(w) || tagsLower.some((t) => t.includes(w)))) {
-          skillHits++;
-        }
-      }
-      score += skillHits;
-      if (skillHits > 0) reasons.push(`skill match (${skillHits})`);
-      for (const w of toolWords) {
-        if (w.length > 2 && (textLower.includes(w) || tagsLower.some((t) => t.includes(w)))) {
-          score += 1;
-          reasons.push(`tool mention: ${w}`);
-        }
-      }
-      switch (entry.priority) {
-        case "critical":
-          score += 5;
-          reasons.push("critical");
-          break;
-        case "high":
-          score += 3;
-          reasons.push("high priority");
-          break;
-        case "medium":
-          score += 1;
-          break;
-        case "low":
-          score -= 2;
-          reasons.push("low priority");
-          break;
-      }
-      switch (entry.type) {
-        case "decision":
-          score += 2;
-          reasons.push("decision");
-          break;
-        case "convention":
-          score += 2;
-          reasons.push("convention");
-          break;
-        case "anti_pattern":
-          score += 3;
-          reasons.push("anti-pattern");
-          break;
-        case "preference":
-          score += 1;
-          reasons.push("preference");
-          break;
-        case "reference":
-          break;
-        case "fact":
-          break;
-      }
-      const ageDays = (now - new Date(entry.ts).getTime()) / (1e3 * 60 * 60 * 24);
-      if (ageDays < 1) score += 1;
-      else if (ageDays > 30) score -= 1;
-      if (entry.confidence !== void 0 && entry.confidence < 0.5) {
-        score -= 2;
-        reasons.push("low confidence");
-      }
-      if (entry.lastAccessed) {
-        const hoursSinceAccess = (now - new Date(entry.lastAccessed).getTime()) / (1e3 * 60 * 60);
-        if (hoursSinceAccess < 1) score -= 1;
-      }
-      if (score > 0) {
-        scored.push({
-          ...entry,
-          score,
-          matchReason: reasons.join(", ") || "keyword match"
-        });
-      }
-    }
-    scored.sort((a, b) => b.score - a.score);
-    const threshold = 2;
-    const relevant = scored.filter(
-      (s) => s.score >= threshold || s.priority === "critical" || s.priority === "high"
-    );
-    this._scoreCache.set(ctxHash, { entries: all, scored: relevant, expiresAt: now + TTL_MS });
-    return relevant.slice(0, Math.min(limit, 15));
-  }
-  async forget(query, scope = "project-memory") {
-    return this.runSerialized(scope, async () => {
-      const filePath = this.files[scope];
-      const t0 = Date.now();
-      let removed = 0;
-      try {
-        removed = await this.backend.forget(scope, query, filePath);
-        this.invalidateScoreCaches();
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "forget",
-          outcome: "success",
-          durationMs: dur,
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-      } catch (err) {
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "forget",
-          outcome: "failure",
-          durationMs: dur,
-          error: toErrorMessage(err),
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        throw err;
-      }
-      if (removed > 0) {
-        this.events?.emit("memory.forgotten", {
-          scope,
-          query,
-          removed
-        });
-        await this.mirrorBackup(scope);
-        await this._recalcTrackedByteSize(scope);
-      }
-      return removed;
-    });
-  }
-  async consolidate(scope) {
-    return this.runSerialized(scope, async () => {
-      const filePath = this.files[scope];
-      const t0 = Date.now();
-      let removed = 0;
-      try {
-        removed = await this.backend.consolidate(scope, filePath);
-        this.invalidateScoreCaches();
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "consolidate",
-          outcome: "success",
-          durationMs: dur,
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-      } catch (err) {
-        const dur = Date.now() - t0;
-        this.events?.emit("storage.write", {
-          sessionId: "~memory~",
-          store: "memory",
-          filePath,
-          operation: "consolidate",
-          outcome: "failure",
-          durationMs: dur,
-          error: toErrorMessage(err),
-          ...this.traceId !== void 0 && { traceId: this.traceId }
-        });
-        throw err;
-      }
-      if (removed > 0) {
-        this.events?.emit("memory.consolidated", {
-          scope,
-          removed
-        });
-        await this.mirrorBackup(scope);
-        await this._recalcTrackedByteSize(scope);
-      }
-    });
-  }
-  async clear(scope) {
-    if (scope) {
-      await this.runSerialized(scope, async () => {
-        const filePath = this.files[scope];
-        const t0 = Date.now();
-        try {
-          await this.backend.clear(scope, filePath);
-          this.invalidateScoreCaches();
-          const dur = Date.now() - t0;
-          this.events?.emit("storage.write", {
-            sessionId: "~memory~",
-            store: "memory",
-            filePath,
-            operation: "clear",
-            outcome: "success",
-            durationMs: dur,
-            ...this.traceId !== void 0 && { traceId: this.traceId }
-          });
-        } catch (err) {
-          const dur = Date.now() - t0;
-          this.events?.emit("storage.write", {
-            sessionId: "~memory~",
-            store: "memory",
-            filePath,
-            operation: "clear",
-            outcome: "failure",
-            durationMs: dur,
-            error: toErrorMessage(err),
-            ...this.traceId !== void 0 && { traceId: this.traceId }
-          });
-          throw err;
-        }
-        this.events?.emit("memory.cleared", { scope });
-        await this.mirrorBackup(scope);
-        this._trackedByteSizes[scope] = 0;
-      });
-      return;
-    }
-    await Promise.all(
-      ["project-agents", "project-memory", "user-memory"].map(
-        async (s) => this.runSerialized(s, async () => {
-          const filePath = this.files[s];
-          const t0 = Date.now();
-          try {
-            await this.backend.clear(s, filePath);
-            const dur = Date.now() - t0;
-            this.events?.emit("storage.write", {
-              sessionId: "~memory~",
-              store: "memory",
-              filePath,
-              operation: "clear",
-              outcome: "success",
-              durationMs: dur,
-              ...this.traceId !== void 0 && { traceId: this.traceId }
-            });
-          } catch (err) {
-            const dur = Date.now() - t0;
-            this.events?.emit("storage.write", {
-              sessionId: "~memory~",
-              store: "memory",
-              filePath,
-              operation: "clear",
-              outcome: "failure",
-              durationMs: dur,
-              error: toErrorMessage(err),
-              ...this.traceId !== void 0 && { traceId: this.traceId }
-            });
-            throw err;
-          }
-          this.events?.emit("memory.cleared", { scope: s });
-          await this.mirrorBackup(s);
-        })
-      )
-    );
-    this.invalidateScoreCaches();
-  }
-  /**
-   * Return a new MemoryStore proxy that carries `traceId` on every storage
-   * event. The original store is left unchanged — callers that need a
-   * trace-decorated view (e.g. session-run tools) receive the proxy while
-   * the singleton remains trace-free for boot-time use.
-   *
-   * The proxy implements the full `MemoryStore` interface; all other
-   * properties (backend, etc.) are delegated to the original store.
-   */
-  withTraceId(traceId) {
-    this.traceId = traceId;
-    return this;
-  }
-  async mirrorBackup(scope) {
-    if (!this.persistBackup || scope === "project-agents") return;
-    try {
-      const content = await this.backend.readAll(scope, this.files[scope]);
-      const { writeFile: writeFile7, mkdir: mkdir10 } = await import("node:fs/promises");
-      await mkdir10(this.backupDir, { recursive: true });
-      await writeFile7(`${this.backupDir}/${scope}.md`, content, "utf8");
-    } catch {
-    }
-  }
-};
-function labelOf(scope) {
-  switch (scope) {
-    case "project-agents":
-      return "Project AGENTS.md";
-    case "project-memory":
-      return "Project memory";
-    case "user-memory":
-      return "User memory";
-  }
-}
-
-// src/storage/plan-store.ts
-import * as fsp14 from "node:fs/promises";
-import { randomUUID as randomUUID12 } from "node:crypto";
 async function loadPlan(filePath, events) {
   const t0 = Date.now();
   let raw;
@@ -26056,7 +25426,7 @@ function emptyPlan(sessionId, title) {
 function addPlanItem(plan, title, details) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const item = {
-    id: `plan_${Date.now()}_${randomUUID12().slice(0, 6)}`,
+    id: `plan_${Date.now()}_${randomUUID11().slice(0, 6)}`,
     title,
     details,
     status: "open",
@@ -26128,7 +25498,7 @@ function deriveTodosFromPlanItem(plan, idOrIndex, subtasks) {
   if (subtasks && subtasks.length > 0) {
     for (const st of subtasks) {
       todos.push({
-        id: `todo_${Date.now()}_${randomUUID12().slice(0, 6)}`,
+        id: `todo_${Date.now()}_${randomUUID11().slice(0, 6)}`,
         content: st,
         status: "pending",
         promotedFromPlan: item.id
@@ -26256,7 +25626,7 @@ ${cat}:`);
 
 // src/storage/queue-store.ts
 import * as fsp15 from "node:fs/promises";
-import * as path27 from "node:path";
+import * as path26 from "node:path";
 var QueueStore = class {
   file;
   // Use `| undefined` (not `?`) so exactOptionalPropertyTypes doesn't
@@ -26265,7 +25635,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path27.join(opts.dir, "queue.json");
+    this.file = path26.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
     this.logger = opts.logger;
@@ -26423,7 +25793,7 @@ function isPersistedQueueItem(v) {
 // src/storage/recovery-lock.ts
 import * as fsp16 from "node:fs/promises";
 import * as os3 from "node:os";
-import * as path28 from "node:path";
+import * as path27 from "node:path";
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -26434,7 +25804,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path28.join(opts.dir, LOCK_FILE);
+    this.file = path27.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os3.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -26495,7 +25865,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path28.dirname(this.file));
+    await ensureDir(path27.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -26800,8 +26170,8 @@ var DefaultSessionReader = class _DefaultSessionReader {
     const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat13 = await fs14.stat(sessionPath);
-      mtimeMs = stat13.mtimeMs;
+      const stat12 = await fs14.stat(sessionPath);
+      mtimeMs = stat12.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);
       this.eventCacheMtimes.delete(sessionId);
@@ -27319,7 +26689,6 @@ export {
   DefaultErrorHandler,
   DefaultHealthRegistry,
   DefaultLogger,
-  DefaultMemoryStore,
   DefaultModeStore,
   DefaultModelsRegistry,
   DefaultMultiAgentCoordinator,