@wrongstack/core 0.9.7 → 0.9.20

package/dist/index.js

@@ -56,8 +56,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat9 = await fsp2.stat(targetPath);
-      mode = stat9.mode & 511;
+      const stat8 = await fsp2.stat(targetPath);
+      mode = stat8.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -1676,6 +1676,7 @@ var HybridCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateMessages(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
     const policy = readContextWindowPolicy(ctx);
     const preserveK = policy?.preserveK ?? this.preserveK;
@@ -1691,9 +1692,12 @@ var HybridCompactor = class {
       ctx.state.replaceMessages(repaired.messages);
     }
     const afterTokens = this.estimateMessages(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -1702,6 +1706,14 @@ var HybridCompactor = class {
       } : void 0
     };
   }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
+  }
   eliseOldToolResults(ctx, preserveK = this.preserveK, eliseThreshold = this.eliseThreshold) {
     const messages = ctx.messages;
     let pairCount = 0;
@@ -4036,11 +4048,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path31, errors) {
+function walk2(value, schema, path35, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path31 || "<root>",
+        path: path35 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -4049,7 +4061,7 @@ function walk2(value, schema, path31, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path31 || "<root>",
+        path: path35 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -4059,19 +4071,19 @@ function walk2(value, schema, path31, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path31, req), message: "required property missing" });
+        errors.push({ path: joinPath(path35, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk2(obj[key], subSchema, joinPath(path31, key), errors);
+          walk2(obj[key], subSchema, joinPath(path35, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk2(item, schema.items, `${path31}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path35}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -4124,14 +4136,105 @@ function deepEqual(a, b) {
   return false;
 }
 
+// src/utils/json-repair.ts
+function completePartialObject(s) {
+  if (!s.trim().startsWith("{")) return s;
+  if (tryParse(s).ok) return s;
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let sawKey = false;
+  let prevSig = "";
+  let contentEnd = 0;
+  let stringBraceDepth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (inString) {
+      contentEnd = i + 1;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+        prevSig = '"';
+        stringBraceDepth = 0;
+        continue;
+      }
+      if (ch === "{") stringBraceDepth++;
+      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
+    contentEnd = i + 1;
+    if (ch === '"') {
+      inString = true;
+      sawKey = true;
+      stringBraceDepth = 0;
+      prevSig = '"';
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      prevSig = ch;
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      prevSig = ch;
+    } else {
+      prevSig = ch;
+    }
+  }
+  if (!sawKey && !inString) return s;
+  let result = s.slice(0, contentEnd);
+  if (inString) {
+    if (escaped) {
+      result = result.slice(0, -1);
+    } else if (endsWithInvalidEscape(result)) {
+      result = result.slice(0, -2);
+    }
+    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
+    result += '"';
+  } else if (prevSig === ":") {
+    result += "null";
+  }
+  for (let k = stack.length - 1; k >= 0; k--) {
+    result += stack[k] === "{" ? "}" : "]";
+  }
+  if (!tryParse(result).ok) {
+    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
+    if (tryParse(patched).ok) result = patched;
+  }
+  return result;
+}
+var VALID_ESCAPE = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function endsWithInvalidEscape(str) {
+  const last = str[str.length - 1];
+  if (str[str.length - 2] !== "\\" || last === void 0) return false;
+  if (VALID_ESCAPE.has(last)) return false;
+  let backslashes = 0;
+  for (let k = str.length - 2; k >= 0 && str[k] === "\\"; k--) backslashes++;
+  return backslashes % 2 === 1;
+}
+function tryParse(s) {
+  try {
+    return { ok: true, value: JSON.parse(s) };
+  } catch {
+    return { ok: false };
+  }
+}
+
 // src/storage/session-store.ts
 init_atomic_write();
 var DefaultSessionStore = class {
   dir;
   events;
+  secretScrubber;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
+    this.secretScrubber = opts.secretScrubber;
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
@@ -4156,7 +4259,11 @@ var DefaultSessionStore = class {
       );
     }
     try {
-      return new FileSessionWriter(id, handle, startedAt, meta, this.events, { dir: shardDir, filePath: file });
+      return new FileSessionWriter(id, handle, startedAt, meta, this.events, {
+        dir: shardDir,
+        filePath: file,
+        secretScrubber: this.secretScrubber
+      });
     } catch (err) {
       await handle.close().catch(() => {
       });
@@ -4186,7 +4293,7 @@ var DefaultSessionStore = class {
           provider: data.metadata.provider
         },
         this.events,
-        { resumed: true, dir: this.dir, filePath: file }
+        { resumed: true, dir: this.dir, filePath: file, secretScrubber: this.secretScrubber }
       );
       return { writer, data };
     } catch (err) {
@@ -4250,8 +4357,8 @@ var DefaultSessionStore = class {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat9 = await fsp2.stat(full);
-      const summary = await this.summarize(id, stat9.mtime.toISOString());
+      const stat8 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat8.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -4392,6 +4499,7 @@ var FileSessionWriter = class {
     this.resumed = opts.resumed ?? false;
     this.manifestFile = opts.dir ? path6.join(opts.dir, `${id}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
+    this.secretScrubber = opts.secretScrubber;
     this.summary = {
       id,
       title: "(empty session)",
@@ -4420,7 +4528,29 @@ var FileSessionWriter = class {
   resumed;
   appendFailCount = 0;
   lastAppendWarnAt = 0;
-  promptIndex = 0;
+  secretScrubber;
+  /**
+   * Scrub secrets out of conversation-turn events before they are observed
+   * for the summary, written to the JSONL log, or surfaced on resume. Only
+   * `user_input` / `llm_response` carry free-form user/model text; other event
+   * types either have no secret-bearing content or are already scrubbed
+   * upstream (tool results). Returns the event unchanged when no scrubber is
+   * configured.
+   */
+  scrubEvent(event) {
+    const s = this.secretScrubber;
+    if (!s) return event;
+    if (event.type === "user_input") {
+      return {
+        ...event,
+        content: typeof event.content === "string" ? s.scrub(event.content) : s.scrubObject(event.content)
+      };
+    }
+    if (event.type === "llm_response") {
+      return { ...event, content: s.scrubObject(event.content) };
+    }
+    return event;
+  }
   pendingFileSnapshots = [];
   /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
   openToolUses = /* @__PURE__ */ new Set();
@@ -4452,9 +4582,10 @@ var FileSessionWriter = class {
       this.initDone = true;
       await this.writeSessionStartLazy();
     }
-    this.observeForSummary(event);
+    const scrubbed = this.scrubEvent(event);
+    this.observeForSummary(scrubbed);
     try {
-      await this.handle.appendFile(`${JSON.stringify(event)}
+      await this.handle.appendFile(`${JSON.stringify(scrubbed)}
 `, "utf8");
     } catch (err) {
       this.appendFailCount++;
@@ -4510,7 +4641,6 @@ var FileSessionWriter = class {
       await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
-    this.promptIndex = promptIndex + 1;
     await this.append({
       type: "checkpoint",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4606,6 +4736,38 @@ var FileSessionWriter = class {
 `;
     await fsp2.writeFile(this.filePath, record, "utf8");
   }
+  /**
+   * Idea #1 — write an in-flight marker. The agent loop should call
+   * this at the start of each long-running operation; a matching
+   * `clearInFlightMarker` follows on clean exit. A stale marker
+   * (no end) is what `SessionRecovery.detectStale` looks for.
+   */
+  async writeInFlightMarker(context) {
+    if (!context || context.length > 500) {
+      throw new Error("In-flight context must be 1..500 chars");
+    }
+    await this.append({
+      type: "in_flight_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      context
+    });
+    this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  /**
+   * Idea #1 — close the in-flight marker. Idempotent in spirit
+   * (you can call it after a successful iteration even if you
+   * didn't open one this round) — but the session log records
+   * every call so postmortem tooling can see "the agent finished
+   * cleanly X times, then died without finishing Y".
+   */
+  async clearInFlightMarker(reason) {
+    await this.append({
+      type: "in_flight_end",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      reason
+    });
+    this.events?.emit("in_flight.ended", { reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  }
 };
 function userInputTitle(content) {
   const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
@@ -5077,6 +5239,7 @@ function isSecretField2(name) {
 }
 
 // src/storage/config-loader.ts
+init_atomic_write();
 var BEHAVIOR_DEFAULTS = {
   version: 1,
   context: {
@@ -5237,6 +5400,40 @@ var DefaultConfigLoader = class {
     }
     return Object.freeze(cfg);
   }
+  /**
+   * Persist a sync config to ~/.wrongstack/sync.json, with the token encrypted
+   * by the vault (if provided). The file is isolated from the main config
+   * hierarchy to prevent accidental commits.
+   */
+  async persistSyncConfig(cfg) {
+    let toWrite = { ...cfg };
+    if (this.vault && toWrite.githubToken && !toWrite.githubToken.startsWith("enc:")) {
+      toWrite = { ...toWrite, githubToken: this.vault.encrypt(toWrite.githubToken) };
+    }
+    await atomicWrite(this.paths.syncConfig, JSON.stringify(toWrite, null, 2), { mode: 384 });
+  }
+  /**
+   * Read ~/.wrongstack/sync.json (encrypted GitHub token storage) and decrypt
+   * the token if a vault is available. Returns null if the file doesn't exist.
+   * This is separate from main config loading because sync.json is intentionally
+   * isolated — it should never be part of project-local or env-driven config.
+   */
+  async loadSyncConfig() {
+    try {
+      const raw = await fsp2.readFile(this.paths.syncConfig, "utf8");
+      const parsed = safeParse(raw);
+      if (!parsed.ok || !parsed.value) return null;
+      if (this.vault) {
+        const decrypted = decryptConfigSecrets2({ sync: parsed.value }, this.vault);
+        return decrypted.sync ?? null;
+      }
+      return parsed.value;
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      console.warn("[config] Failed to load sync config:", err);
+      return null;
+    }
+  }
   async readJson(file) {
     let raw;
     try {
@@ -6160,7 +6357,11 @@ var DefaultPermissionPolicy = class {
       return { permission: "deny", source: "deny", reason: "session soft deny (user pressed no)" };
     }
     if (this.sessionAllowed.has(subjectKey)) {
-      return { permission: "auto", source: "trust", reason: "session soft allow (user pressed yes)" };
+      return {
+        permission: "auto",
+        source: "trust",
+        reason: "session soft allow (user pressed yes)"
+      };
     }
     if (entry?.deny && subject && matchAny(entry.deny, subject)) {
       return { permission: "deny", source: "deny", reason: "matched deny pattern" };
@@ -6180,7 +6381,11 @@ var DefaultPermissionPolicy = class {
           const decision = await this.promptDelegate(tool, input, subject ?? tool.name);
           if (decision === "always") {
             await this.trust({ tool: tool.name, pattern: subject ?? tool.name });
-            return { permission: "auto", source: "user", reason: "destructive yolo always-allowed" };
+            return {
+              permission: "auto",
+              source: "user",
+              reason: "destructive yolo always-allowed"
+            };
           }
           if (decision === "deny") {
             await this.deny({ tool: tool.name, pattern: subject ?? tool.name });
@@ -6188,13 +6393,22 @@ var DefaultPermissionPolicy = class {
           }
           return { permission: decision === "yes" ? "auto" : "deny", source: "user" };
         }
-        return { permission: "confirm", source: "yolo_destructive", riskTier: "destructive", reason: "destructive tool needs explicit approval even in yolo mode" };
+        return {
+          permission: "confirm",
+          source: "yolo_destructive",
+          riskTier: "destructive",
+          reason: "destructive tool needs explicit approval even in yolo mode"
+        };
       }
       return { permission: "auto", source: "yolo" };
     }
     if (tool.name === "write" && subject) {
       if (ctx.hasRead(subject)) {
-        return { permission: "auto", source: "context", reason: "file already read in this session" };
+        return {
+          permission: "auto",
+          source: "context",
+          reason: "file already read in this session"
+        };
       }
     }
     if (tool.permission === "auto" && !tool.mutating) {
@@ -6302,6 +6516,10 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
     // arbitrary shell — use exec for constrained shell
     "write",
     // arbitrary file write
+    "edit",
+    // arbitrary in-project file modification (equivalent to write)
+    "replace",
+    // arbitrary multi-file find/replace (equivalent to write)
     "scaffold",
     // arbitrary file generation outside project root
     "patch",
@@ -6311,12 +6529,22 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
     "exec"
     // restricted shell but with arbitrary command args
   ]);
+  /**
+   * Tools from MCP servers (`mcp__<server>__<tool>`) are external code of
+   * unknown capability — they may wrap a shell or filesystem. They are
+   * fail-closed here: not auto-approved for subagents by default, so the
+   * leader must allow them explicitly per-spawn.
+   */
+  static isMcpTool(name) {
+    return name.startsWith("mcp__");
+  }
   async evaluate(tool) {
-    if (tool.permission === "deny" || _AutoApprovePermissionPolicy.DENY.has(tool.name)) {
+    const blocked = _AutoApprovePermissionPolicy.DENY.has(tool.name) || _AutoApprovePermissionPolicy.isMcpTool(tool.name);
+    if (tool.permission === "deny" || blocked) {
       return {
         permission: "deny",
         source: "subagent_guard",
-        reason: _AutoApprovePermissionPolicy.DENY.has(tool.name) ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny"
+        reason: blocked ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny"
       };
     }
     return { permission: "auto", source: "yolo" };
@@ -6561,7 +6789,12 @@ function safeJsonOrRaw(s) {
   try {
     return JSON.parse(s);
   } catch {
-    return { _raw: s };
+    const repaired = completePartialObject(s);
+    try {
+      return JSON.parse(repaired);
+    } catch {
+      return { _raw: repaired };
+    }
   }
 }
 function handleToolUseStop(state, ev) {
@@ -6790,8 +7023,9 @@ var IntelligentCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
-    const load = beforeTokens / this.maxContext;
+    const load = beforeFull / this.maxContext;
     const aggressive = load >= this.hardThreshold ? true : opts.aggressive ?? load >= this.softThreshold;
     const saved1 = this.eliseOldToolResults(ctx);
     if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
@@ -6805,9 +7039,12 @@ var IntelligentCompactor = class {
     const repaired = repairToolUseAdjacency(ctx.messages);
     if (repaired.report.changed) ctx.state.replaceMessages(repaired.messages);
     const afterTokens = this.estimateTokens(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -6816,6 +7053,14 @@ var IntelligentCompactor = class {
       } : void 0
     };
   }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
+  }
   async summarizeAncientTurns(ctx) {
     const messages = ctx.messages;
     const cutoff = Math.max(0, messages.length - this.preserveK * 2);
@@ -6828,29 +7073,26 @@ var IntelligentCompactor = class {
     try {
       summaryText = await this.callSummarizer(toSummarize, ctx);
     } catch {
-      const toolNames = /* @__PURE__ */ new Set();
-      const filePaths = /* @__PURE__ */ new Set();
-      let userTurns = 0;
-      let assistantTurns = 0;
+      const preservedMessages = [];
       for (const m of toSummarize) {
-        if (m.role === "user") userTurns++;
-        else if (m.role === "assistant") {
-          assistantTurns++;
-          if (Array.isArray(m.content)) {
-            for (const b of m.content) {
-              if (b.type === "tool_use") toolNames.add(b.name ?? "unknown");
-            }
-          }
+        if (m.role === "system") continue;
+        if (typeof m.content === "string") {
+          preservedMessages.push(m);
+        } else if (Array.isArray(m.content)) {
+          const textParts = m.content.filter(isTextBlock);
+          const toolParts = m.content.filter((b) => b.type === "tool_use" || b.type === "tool_result");
+          const next = {
+            role: m.role,
+            content: [
+              ...textParts,
+              ...toolParts.length > 0 ? [{ type: "text", text: `[${toolParts.length} tool call(s) omitted]` }] : []
+            ]
+          };
+          preservedMessages.push(next);
         }
-        const text = typeof m.content === "string" ? m.content : "";
-        const matches = text.matchAll(/(?:[\w.,\-/@]+\/)*[\w.,\-/@]+\.\w+/g);
-        for (const m_ of matches) filePaths.add(m_[0]);
       }
-      const parts = [`${toSummarize.length} turns (${userTurns} user, ${assistantTurns} assistant)`];
-      if (toolNames.size > 0) parts.push(`tools: ${[...toolNames].join(", ")}`);
-      if (filePaths.size > 0) parts.push(`files: ${[...filePaths].slice(0, 10).join(", ")}`);
-      summaryText = parts.join(" | ");
-      if (!summaryText) summaryText = `${toSummarize.length} earlier turns omitted`;
+      summaryText = preservedMessages.map((m) => `[${m.role}]: ${typeof m.content === "string" ? m.content : m.content.filter(isTextBlock).map((b) => b.text).join(" ")}`).join("\n");
+      if (!summaryText) summaryText = `${toSummarize.length} earlier turns (semantic content preserved)`;
     }
     const summaryMsg = {
       role: "system",
@@ -7096,7 +7338,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       const res = await this.provider.complete(req, { signal: ac.signal });
       const textBlocks = res.content.filter(isTextBlock);
       raw = textBlocks.map((b) => b.text).join("\n").trim();
-    } catch (err) {
+    } catch (_err) {
       return this.fallbackSelect(messages, effectiveBudget);
     }
     return this.parseSelectorOutput(raw, messages.length);
@@ -7188,15 +7430,24 @@ var SelectiveCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
-    const load = beforeTokens / this.maxContext;
+    const load = beforeFull / this.maxContext;
     const shouldCompact = load >= this.warnThreshold || opts.aggressive;
     if (!shouldCompact) {
       const saved = this.eliseOldToolResults(ctx);
       if (saved > 0) reductions.push({ phase: "elision", saved });
       const repair2 = this.repairProtocolAdjacency(ctx);
       const afterTokens2 = this.estimateTokens(ctx.messages);
-      return { before: beforeTokens, after: afterTokens2, reductions, repaired: repair2 };
+      const afterFull2 = this.estimateFullRequest(ctx);
+      return {
+        before: beforeTokens,
+        after: afterTokens2,
+        fullRequestTokensBefore: beforeFull,
+        fullRequestTokensAfter: afterFull2,
+        reductions,
+        repaired: repair2
+      };
     }
     const savedElision = this.eliseOldToolResults(ctx);
     if (savedElision > 0) reductions.push({ phase: "elision", saved: savedElision });
@@ -7208,7 +7459,23 @@ var SelectiveCompactor = class {
     }
     const repair = this.repairProtocolAdjacency(ctx);
     const afterTokens = this.estimateTokens(ctx.messages);
-    return { before: beforeTokens, after: afterTokens, reductions, repaired: repair };
+    const afterFull = this.estimateFullRequest(ctx);
+    return {
+      before: beforeTokens,
+      after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
+      reductions,
+      repaired: repair
+    };
+  }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
   }
   repairProtocolAdjacency(ctx) {
     const repaired = repairToolUseAdjacency(ctx.messages);
@@ -7398,7 +7665,8 @@ var LEVEL_RANK2 = { warn: 0, soft: 1, hard: 2 };
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
-  estimator;
+  /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
+  _estimator;
   warnThreshold;
   softThreshold;
   hardThreshold;
@@ -7408,19 +7676,6 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   events;
   failureMode;
   policyProvider;
-  /**
-   * Calibration factor applied to the estimator output. The estimator is now
-   * expected to already include messages + system prompt + tool definitions
-   * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
-   * as a constant so a future calibration against real provider tokenization
-   * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
-   * threshold-check math.
-   *
-   * Historical note: was 1.3 when the estimator only counted messages — that
-   * double-counted system+tools once the estimator was upgraded, firing
-   * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
-   */
-  static OVERHEAD_FACTOR = 1;
   /**
    * Once a compaction attempt reduces nothing (preserveK protects everything,
    * no oversized tool_results remain to elide), retrying on every iteration
@@ -7433,8 +7688,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   lastNoopAttempt = null;
   /**
    * @param compactor        Compactor to use for compaction.
-   * @param maxContext       Provider's max context window in tokens.
-   * @param estimator        Token estimation function.
+   * @param maxContext Provider's max context window in tokens.
+   * @param _estimator       Deprecated parameter kept for backward compatibility.
+   *                         The middleware now uses `estimateRequestTokens` internally
+   *                         for accurate full-request token counting (messages +
+   *                         systemPrompt + toolDefs).
    * @param thresholds       Threshold fractions (0-1) of maxContext.
    * @param opts             Optional behavior. By default, failures at the
    *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
@@ -7442,11 +7700,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
    *                         provider context overflow. Warn/soft failures
    *                         still emit compaction.failed and continue.
    */
-  constructor(compactor, maxContext, estimator, thresholds, optsOrAggressiveOn = {}, events) {
+  constructor(compactor, maxContext, _estimator, thresholds, optsOrAggressiveOn = {}, events) {
     const opts = typeof optsOrAggressiveOn === "string" ? { aggressiveOn: optsOrAggressiveOn, events } : optsOrAggressiveOn;
     this.compactor = compactor;
     this._maxContext = maxContext;
-    this.estimator = estimator;
+    this._estimator = _estimator;
     this.warnThreshold = thresholds.warn;
     this.softThreshold = thresholds.soft;
     this.hardThreshold = thresholds.hard;
@@ -7462,8 +7720,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   }
   handler() {
     return async (ctx, next) => {
-      const rawTokens = this.estimator(ctx);
-      const tokens = Math.ceil(rawTokens * _AutoCompactionMiddleware.OVERHEAD_FACTOR);
+      const tokens = this._estimator ? this._estimator(ctx) : estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []).total;
       const load = tokens / this._maxContext;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
@@ -7498,7 +7755,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     return delta < _AutoCompactionMiddleware.NOOP_RETRY_DELTA_TOKENS;
   }
   recordAttempt(level, tokens, report) {
-    const reduced = report.before > report.after;
+    const reduced = (report.fullRequestTokensBefore ?? report.before) > (report.fullRequestTokensAfter ?? report.after);
     const repaired = !!report.repaired;
     if (reduced || repaired) {
       this.lastNoopAttempt = null;
@@ -8431,17 +8688,7 @@ var SubagentBudget = class _SubagentBudget {
   startTime = null;
   _onThreshold;
   /**
-   * Tracks which budget kinds currently have an extension request
-   * in flight. While a kind is here, further `checkLimit` calls for the
-   * same kind are no-ops — without this dedup, every `recordIteration`
-   * after the limit is reached spawns a fresh decision Promise (until
-   * the first one lands and patches limits), flooding the FleetBus
-   * with redundant threshold events. Cleared in `negotiateExtension`'s
-   * `finally`.
-   */
-  pendingExtensions = /* @__PURE__ */ new Set();
-  /**
-   * Hard cap on how long `negotiateExtension` waits for the coordinator to
+   * Hard cap on how long `_negotiateExtension` waits for the coordinator to
    * respond before defaulting to 'stop'. Without this fallback an absent
    * or hung listener (Director not built / event filter detached mid-run)
    * leaves the budget over-limit and never enforces anything.
@@ -8503,38 +8750,83 @@ var SubagentBudget = class _SubagentBudget {
    * - `mode === 'auto'` + no listener  → throw `BudgetExceededError` (hard stop; no one to ask)
    * - `mode === 'auto'` + listener     → throw `BudgetThresholdSignal` with async decision promise
    */
-  checkLimit(kind, used, limit) {
+  /**
+   * Collects all exceeded budget kinds into a single NOOP-free negotiation.
+   * Called by recordIteration / recordToolCall / recordUsage — each may call
+   * this for its own kind. The first call starts the negotiation and stores
+   * the Promise in _pendingNegotiation. Subsequent calls for DIFFERENT
+   * kinds (while a negotiation is in flight) are NOOPs — they don't start
+   * new conversations with the coordinator. This prevents an EventBus flood
+   * when multiple budget kinds are exceeded simultaneously in one iteration.
+   *
+   * Returns the kinds that were found to be exceeded (for logging/debugging).
+   */
+  checkLimits(elapsedMs) {
+    const exceeded = [];
+    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
+      exceeded.push({ kind: "iterations", used: this.iterations, limit: this.limits.maxIterations });
+    }
+    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
+      exceeded.push({ kind: "tool_calls", used: this.toolCalls, limit: this.limits.maxToolCalls });
+    }
+    const totalTokens = this.tokenInput + this.tokenOutput;
+    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
+      exceeded.push({ kind: "tokens", used: totalTokens, limit: this.limits.maxTokens });
+    }
+    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
+      exceeded.push({ kind: "cost", used: this.costUsd, limit: this.limits.maxCostUsd });
+    }
+    if (elapsedMs !== void 0 && this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
+      exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
+    }
+    if (exceeded.length === 0) return [];
     if (!this._onThreshold) {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     if (this._mode === "sync") {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
     if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
+    }
+    for (const entry of exceeded) {
+      if (this._pendingNegotiations.has(entry.kind)) continue;
+      const decision2 = this._negotiateExtension(entry.kind, exceeded);
+      this._pendingNegotiations.set(entry.kind, decision2);
     }
-    if (this.pendingExtensions.has(kind)) return;
-    this.pendingExtensions.add(kind);
-    const decision = this.negotiateExtension(kind, used, limit);
-    throw new BudgetThresholdSignal(kind, limit, used, decision);
+    const first = exceeded[0];
+    const decision = this._pendingNegotiations.get(first.kind);
+    throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
   }
+  /**
+   * Per-kind in-flight negotiation Promises. Each budget kind can have its
+   * own concurrent negotiation — e.g. iterations and timeout can both
+   * be exceeded simultaneously without blocking each other. The same kind
+   * cannot start two concurrent negotiations (dedup guard).
+   * Cleared in `_negotiateExtension`'s `finally` block.
+   */
+  _pendingNegotiations = /* @__PURE__ */ new Map();
   /**
    * Drive the threshold handler to a decision. Resolves with `'stop'`
    * (signal the runner to abort) or `{ extend: ... }` (limits already
-   * patched in-place; the runner should not abort). Always releases the
-   * `pendingExtensions` slot in `finally`.
+   * patched in-place; the runner should not abort). Clears the
+   * per-kind slot in `_pendingNegotiations` in `finally`.
    *
    * The 'continue' return from a sync handler is treated as
    * `{ extend: {} }` — keep going without patching; next overrun fires
    * a fresh signal.
    */
-  async negotiateExtension(kind, used, limit) {
+  async _negotiateExtension(kind, exceeded) {
     try {
+      const first = exceeded[0];
       const result = this._onThreshold({
-        kind,
-        used,
-        limit,
+        kind: first.kind,
+        used: first.used,
+        limit: first.limit,
         requestDecision: () => {
           const bus = this._events;
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
@@ -8551,20 +8843,22 @@ var SubagentBudget = class _SubagentBudget {
               () => respond("stop"),
               _SubagentBudget.DECISION_TIMEOUT_MS
             );
-            bus.emit("budget.threshold_reached", {
-              kind,
-              used,
-              limit,
-              timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
-              extend: (extra) => {
-                clearTimeout(fallback);
-                respond({ extend: extra });
-              },
-              deny: () => {
-                clearTimeout(fallback);
-                respond("stop");
-              }
-            });
+            for (const { kind: kind2, used, limit } of exceeded) {
+              bus.emit("budget.threshold_reached", {
+                kind: kind2,
+                used,
+                limit,
+                timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+                extend: (extra) => {
+                  clearTimeout(fallback);
+                  respond({ extend: extra });
+                },
+                deny: () => {
+                  clearTimeout(fallback);
+                  respond("stop");
+                }
+              });
+            }
           });
         }
       });
@@ -8590,47 +8884,39 @@ var SubagentBudget = class _SubagentBudget {
       }
       return decision;
     } finally {
-      this.pendingExtensions.delete(kind);
+      this._pendingNegotiations.delete(kind);
     }
   }
   recordIteration() {
     this.iterations++;
-    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
-      void this.checkLimit("iterations", this.iterations, this.limits.maxIterations);
-    }
+    void this.checkLimits();
   }
   recordToolCall() {
     this.toolCalls++;
-    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
-      void this.checkLimit("tool_calls", this.toolCalls, this.limits.maxToolCalls);
-    }
+    void this.checkLimits();
   }
   recordUsage(usage, costUsd = 0) {
     this.tokenInput += usage.input;
     this.tokenOutput += usage.output;
     this.costUsd += costUsd;
-    const totalTokens = this.tokenInput + this.tokenOutput;
-    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
-      void this.checkLimit("tokens", totalTokens, this.limits.maxTokens);
-    }
-    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
-      void this.checkLimit("cost", this.costUsd, this.limits.maxCostUsd);
-    }
+    void this.checkLimits();
   }
   /**
-   * Wall-clock budget check. Unlike other limits, timeout check passes through
-   * `checkLimit` and is subject to the same negotiation-mode decision table.
-   * In practice, `'sync'` mode (the usual test configuration) means a timeout
-   * immediately throws `BudgetExceededError`. In production with a coordinator,
-   * a timeout emits `budget.threshold_reached` so the Director can decide whether
-   * to extend or abort.
+   * Wall-clock budget check. Unlike other limits, timeout is always a hard stop
+   * — wall-clock time cannot be "extended" by the coordinator, so it throws
+   * synchronously rather than entering the negotiation flow.
+   *
+   * Decision table:
+   * - no `onThreshold` handler         → throw `BudgetExceededError`
+   * - `mode === 'sync'`               → throw `BudgetExceededError`
+   * - `mode === 'auto'` + no listener  → throw `BudgetExceededError`
+   * - `mode === 'auto'` + listener     → throw `BudgetExceededError` (timeout is not extendable)
    */
   checkTimeout() {
     if (this.startTime === null || this.limits.timeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    if (elapsed > this.limits.timeoutMs) {
-      void this.checkLimit("timeout", elapsed, this.limits.timeoutMs);
-    }
+    if (elapsed <= this.limits.timeoutMs) return;
+    void this.checkLimits(elapsed);
   }
   /** Returns true if a timeout has occurred without throwing. Useful for races. */
   isTimedOut() {
@@ -11283,11 +11569,46 @@ Working rules:
 - When in doubt, flag as medium rather than ignoring potential issues`
   // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
+var CRITIC_AGENT = {
+  id: "critic",
+  name: "Critic",
+  role: "critic",
+  prompt: `You are the Critic agent. Your job is to evaluate code quality,
+architectural decisions, and proposed changes against project conventions,
+engineering standards, and known quality gates. You do not write code \u2014
+you judge it.
+
+Scope:
+- Evaluate bug severity and fix quality from Bug Hunter reports
+- Score refactoring plans from Refactor Planner (risk, completeness, trade-offs)
+- Flag gaps in test coverage, error handling, and edge case coverage
+- Assess whether a proposed change aligns with existing project patterns
+- Detect over-engineering or under-engineering relative to the problem scope
+
+Input format you accept:
+{ "task": "evaluate | score | review", "subject": "bug_report | refactor_plan | diff", "focus": "correctness | maintainability | risk | all" }
+
+Output: Markdown critic report:
+- ## Overall Score (0-10 with rationale)
+- ## Strengths (what's solid)
+- ## Weaknesses (what needs work)
+- ## Specific Concerns (with file:line when applicable)
+- ## Verdict: **Approve / Needs Revision / Reject**
+
+Working rules:
+- Be specific \u2014 "looks fine" is not a review. Cite concrete evidence.
+- When scoring, explain the delta from a perfect score.
+- If you have no basis to evaluate a concern, say so rather than speculating.
+- Prioritise correctness over style; correctness issues block approval.
+- Score thresholds: \u22657 = Approve, 4-6 = Needs Revision, <4 = Reject`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
+};
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
   "bug-hunter": BUG_HUNTER_AGENT,
   "refactor-planner": REFACTOR_PLANNER_AGENT,
   "security-scanner": SECURITY_SCANNER_AGENT,
+  "critic": CRITIC_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
@@ -11297,6 +11618,7 @@ var FLEET_ROSTER_BUDGETS = {
   "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 },
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
   )
@@ -11377,10 +11699,111 @@ FLEET_ROSTER_BUDGETS["gemini-cli"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterati
 FLEET_ROSTER_BUDGETS["copilot"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
 FLEET_ROSTER_BUDGETS["openhands"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
 FLEET_ROSTER_BUDGETS["goose"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-({
+var FLEET_ROSTER_WITHACP = {
   ...FLEET_ROSTER,
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
-});
+};
+
+// src/coordination/subagent-nicknames.ts
+var NICKNAME_POOL = {
+  // Physics & fundamental sciences
+  "einstein": { name: "Einstein", domain: "physics" },
+  "newton": { name: "Newton", domain: "physics" },
+  "feynman": { name: "Feynman", domain: "physics" },
+  "dirac": { name: "Dirac", domain: "physics" },
+  "bohr": { name: "Bohr", domain: "physics" },
+  "planck": { name: "Planck", domain: "physics" },
+  "curie": { name: "Curie", domain: "physics" },
+  "fermi": { name: "Fermi", domain: "physics" },
+  "heisenberg": { name: "Heisenberg", domain: "physics" },
+  "schrodinger": { name: "Schr\xF6dinger", domain: "physics" },
+  // Mathematics
+  "euclid": { name: "Euclid", domain: "math" },
+  "gauss": { name: "Gauss", domain: "math" },
+  "turing": { name: "Turing", domain: "math" },
+  "poincare": { name: "Poincar\xE9", domain: "math" },
+  "riemann": { name: "Riemann", domain: "math" },
+  "hilbert": { name: "Hilbert", domain: "math" },
+  "pythagoras": { name: "Pythagoras", domain: "math" },
+  // Computing & information theory
+  "von-neumann": { name: "Von Neumann", domain: "computing" },
+  "shannon": { name: "Shannon", domain: "computing" },
+  "hopper": { name: "Hopper", domain: "computing" },
+  "backus": { name: "Backus", domain: "computing" },
+  "knuth": { name: "Knuth", domain: "computing" },
+  "torvalds": { name: "Torvalds", domain: "computing" },
+  "stallman": { name: "Stallman", domain: "computing" },
+  "berners-lee": { name: "Berners-Lee", domain: "computing" },
+  "babbage": { name: "Babbage", domain: "computing" },
+  "lovelace": { name: "Lovelace", domain: "computing" },
+  "klein": { name: "Klein", domain: "computing" },
+  // Electronics & electrical engineering
+  "edison": { name: "Edison", domain: "ee" },
+  "tesla": { name: "Tesla", domain: "ee" },
+  "faraday": { name: "Faraday", domain: "ee" },
+  "maxwell": { name: "Maxwell", domain: "ee" },
+  "ohm": { name: "Ohm", domain: "ee" },
+  "bell": { name: "Bell", domain: "ee" },
+  "marconi": { name: "Marconi", domain: "ee" },
+  "lamarr": { name: "Lamarr", domain: "ee" },
+  // General science / multi-disciplinary
+  "darwin": { name: "Darwin", domain: "biology" },
+  "mendel": { name: "Mendel", domain: "biology" },
+  "pasteur": { name: "Pasteur", domain: "biology" },
+  "hawking": { name: "Hawking", domain: "cosmology" },
+  "sagan": { name: "Sagan", domain: "cosmology" },
+  // Chemistry / materials
+  "lavoisier": { name: "Lavoisier", domain: "chemistry" },
+  "mendeleev": { name: "Mendeleev", domain: "chemistry" }
+};
+var ALL_NICKNAMES = Object.values(NICKNAME_POOL);
+var DOMAIN_PREFERENCES = {
+  "security": ["shannon", "turing", "lamarr", "stallman"],
+  "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
+  "refactor": ["gauss", "hilbert", "euclid", "planck"],
+  "audit-log": ["sagan", "hawking", "poincare", "newton"],
+  "planner": ["hilbert", "gauss", "turing", "euclid"],
+  "researcher": ["sagan", "hawking", "darwin", "pasteur"],
+  "explorer": ["marconi", "bell", "columbus", "polo"],
+  "testing": ["pasteur", "curie", "fermi", "bohr"],
+  "frontend": ["lovelace", "hopper", "babbage", "backus"],
+  "backend": ["torvalds", "stallman", "von-neumann", "backus"],
+  "database": ["turing", "shannon", "backus", "knuth"],
+  "devops": ["tesla", "edison", "faraday", "bell"],
+  "security-scanner": ["shannon", "turing", "lamarr", "stallman"],
+  "refactor-planner": ["gauss", "hilbert", "planck", "newton"],
+  "architect": ["von-neumann", "turing", "gauss", "hilbert"],
+  "critic": ["einstein", "feynman", "dirac", "bohr"],
+  "e2e": ["hopper", "bell", "marconi", "tesla"],
+  "performance": ["knuth", "gauss", "planck", "feynman"],
+  "chaos": ["tesla", "edison", "curie", "fermi"],
+  "cost": ["ohm", "bell", "marconi", "tesla"],
+  // default fallback
+  "default": ["einstein", "newton", "curie", "tesla", "edison", "turing", "shannon", "hopper", "knuth", "stallman"]
+};
+function assignNickname(role, used) {
+  const preferences = [
+    ...DOMAIN_PREFERENCES[role] ?? [],
+    ...DOMAIN_PREFERENCES["default"] ?? []
+  ];
+  for (const key of preferences) {
+    const entry = NICKNAME_POOL[key];
+    if (entry && !used.has(key)) {
+      return `${entry.name} (${formatRole(role)})`;
+    }
+  }
+  for (const entry of ALL_NICKNAMES) {
+    const key = Object.entries(NICKNAME_POOL).find(([, v]) => v.name === entry.name)?.[0];
+    if (key && !used.has(key)) {
+      return `${entry.name} (${formatRole(role)})`;
+    }
+  }
+  const counter = used.size + 1;
+  return `Scientist #${counter} (${formatRole(role)})`;
+}
+function formatRole(role) {
+  return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
 
 // src/coordination/multi-agent-coordinator.ts
 var DefaultMultiAgentCoordinator = class extends EventEmitter {
@@ -11389,6 +11812,15 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   runner;
   fleetBus;
   subagents = /* @__PURE__ */ new Map();
+  /**
+   * Base nickname keys already handed out this run (e.g. `einstein`, `tesla`).
+   * Prevents two workers sharing a name. Direct `coordinator.spawn()` callers
+   * (parallel/eternal engine, SDD parallel run) don't go through
+   * `Director.spawn()` where nicknames are normally assigned, so the
+   * coordinator upgrades placeholder names ("Executor", "slot-ab12cd", role
+   * names) to memorable ones here — that's what surfaces in the fleet monitor.
+   */
+  usedNicknames = /* @__PURE__ */ new Set();
   pendingTasks = [];
   completedResults = [];
   totalIterations = 0;
@@ -11437,7 +11869,26 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.config.maxConcurrent = Math.floor(n);
     this.tryDispatchNext();
   }
+  /**
+   * Upgrade a placeholder/role-derived name to a memorable scientist nickname
+   * (e.g. "Einstein (Executor)"). A name is treated as a placeholder when it is
+   * empty, equals the role (case-insensitive), is a generic default
+   * ("subagent"/"adhoc"/"generic"), or is an auto-generated `slot-…` id.
+   * Explicit, human-chosen names — including nicknames already assigned by
+   * `Director.spawn()` — are left untouched, so this never double-assigns.
+   */
+  withNickname(subagent) {
+    const role = subagent.role ?? "subagent";
+    const name = subagent.name?.trim() ?? "";
+    const isPlaceholder = name === "" || name.toLowerCase() === role.toLowerCase() || name === "subagent" || name === "adhoc" || name === "generic" || /^slot-/.test(name);
+    if (!isPlaceholder) return subagent;
+    const nickname = assignNickname(role, this.usedNicknames);
+    const baseKey = nickname.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    this.usedNicknames.add(baseKey);
+    return { ...subagent, name: nickname };
+  }
   async spawn(subagent) {
+    subagent = this.withNickname(subagent);
     const id = subagent.id || randomUUID();
     if (this.subagents.has(id)) {
       throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
@@ -12031,12 +12482,12 @@ var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
     this.opts = opts;
-    this.goalPath = goalFilePath(opts.projectRoot);
+    this.goalPath = opts.goalPath ?? goalFilePath(opts.projectRoot);
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
     this.timeoutMs = opts.iterationTimeoutMs ?? 3e5;
     this.dispatchEnabled = opts.dispatch !== false;
     this.dispatchClassifier = opts.dispatchClassifier;
-    this.agentFactory = opts.subagentFactory ?? (async (config) => ({
+    this.agentFactory = opts.subagentFactory ?? (async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     }));
@@ -12130,7 +12581,6 @@ var ParallelEternalEngine = class {
     }
     const tasks = await this.decomposeGoal(goal);
     if (!tasks || tasks.length === 0) {
-      await sleep2(5e3);
       return false;
     }
     const fanOut = await this.fanOut(goal, tasks);
@@ -12151,6 +12601,7 @@ var ParallelEternalEngine = class {
     });
     if (fanOut.goalComplete) {
       this.stopRequested = true;
+      this.state = "stopped";
       return true;
     }
     await this.maybeCompact();
@@ -12331,7 +12782,11 @@ ${lastFew}` : "No prior iterations.",
       } finally {
         clearTimeout(timer);
       }
-    } catch {
+    } catch (err) {
+      this.opts.onError?.(
+        err instanceof Error ? err : new Error(String(err)),
+        this.consecutiveFailures
+      );
       return [];
     }
   }
@@ -12548,7 +13003,11 @@ Working rules:
      thrashing, terminate it rather than letting cost climb silently.
   6. Never claim a subagent's work as your own without verifying it. If a
      result looks wrong, ask_subagent for clarification before passing it
-     to the user.`;
+     to the user.
+  7. Wind down when satisfied. When the results are good enough, call
+     work_complete \u2014 no new subagents will spawn and queued tasks complete
+     as aborted. Running subagents finish naturally. Call terminate_subagent
+     only for ones you need to stop immediately.`;
 var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
 a specific slice of a larger plan \u2014 do that slice well and report back.
 
@@ -12693,14 +13152,12 @@ var FleetBus = class {
 };
 var FleetUsageAggregator = class {
   constructor(bus, priceLookup, metaLookup) {
-    this.bus = bus;
     this.priceLookup = priceLookup;
     this.metaLookup = metaLookup;
     bus.filter("provider.response", (e) => this.onProviderResponse(e));
     bus.filter("tool.executed", (e) => this.onToolExecuted(e));
     bus.filter("iteration.started", (e) => this.onIterationStarted(e));
   }
-  bus;
   priceLookup;
   metaLookup;
   perSubagent = /* @__PURE__ */ new Map();
@@ -12938,7 +13395,7 @@ function makeRollUpTool(director) {
 function makeTerminateTool(director) {
   return {
     name: "terminate_subagent",
-    description: "Forcibly abort a subagent.",
+    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
     permission: "auto",
     mutating: true,
     inputSchema: { type: "object", properties: { subagentId: { type: "string", description: "Subagent to abort." } }, required: ["subagentId"] },
@@ -12949,6 +13406,19 @@ function makeTerminateTool(director) {
     }
   };
 }
+function makeTerminateAllTool(director) {
+  return {
+    name: "terminate_all",
+    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
+    permission: "auto",
+    mutating: true,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      await director.terminateAll();
+      return { ok: true, message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.` };
+    }
+  };
+}
 function makeFleetStatusTool(director) {
   return {
     name: "fleet_status",
@@ -12992,7 +13462,6 @@ function makeFleetSessionTool(director) {
       type: "object",
       properties: {
         subagentId: { type: "string", description: "Subagent id to read the transcript of." },
-        /** Number of trailing lines to return (last N JSONL lines). Default: all. */
         tail: { type: "number", description: "Number of trailing JSONL lines to return. Omit for the full transcript." }
       },
       required: ["subagentId"]
@@ -13028,8 +13497,6 @@ function makeFleetHealthTool(director) {
             id: s.id,
             status: s.status,
             lastEventAt: usage?.lastEventAt,
-            // Budget pressure: fraction of each limit consumed if we have it.
-            // BudgetWarning events carry used/limit ratios; surface them here.
             budgetPressure: {
               iterations: usage?.iterations,
               toolCalls: usage?.toolCalls,
@@ -13041,20 +13508,616 @@ function makeFleetHealthTool(director) {
     }
   };
 }
-
-// src/coordination/director.ts
-var FleetSpawnBudgetError = class extends Error {
-  kind;
-  limit;
-  observed;
-  constructor(kind, limit, observed) {
-    super(
-      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}`
-    );
-    this.name = "FleetSpawnBudgetError";
-    this.kind = kind;
-    this.limit = limit;
-    this.observed = observed;
+function makeCollabDebugTool(director) {
+  return {
+    name: "collab_debug",
+    description: "Start a collaborative debugging session: BugHunter, RefactorPlanner, and Critic run in parallel on the same target files. BugHunter finds bugs and emits bug.found events. RefactorPlanner listens for bug.found and emits refactor.plan events. Critic evaluates both and emits critic.evaluation events. Returns a structured report with overall verdict (approve / needs_revision / reject).",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        targetPaths: {
+          type: "array",
+          items: { type: "string" },
+          description: "File paths / glob patterns to scan for bugs."
+        },
+        timeoutMs: {
+          type: "number",
+          description: "Timeout in ms. Default: 600000 (10 minutes)."
+        }
+      },
+      required: ["targetPaths"]
+    },
+    async execute(input) {
+      const i = input;
+      if (!i.targetPaths?.length) {
+        return { error: "collab_debug: targetPaths is required and must be non-empty." };
+      }
+      const options = {
+        targetPaths: i.targetPaths,
+        timeoutMs: i.timeoutMs
+      };
+      try {
+        const report = await director.spawnCollab(options);
+        return {
+          sessionId: report.sessionId,
+          overallVerdict: report.overallVerdict,
+          bugCount: report.bugs.length,
+          planCount: report.refactorPlans.length,
+          evaluationCount: report.evaluations.length,
+          summary: report.summary,
+          bugs: report.bugs,
+          refactorPlans: report.refactorPlans,
+          evaluations: report.evaluations
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { error: "collab_debug failed: " + msg };
+      }
+    }
+  };
+}
+function makeFleetEmitTool(director) {
+  return {
+    name: "fleet_emit",
+    description: "Emit a structured event on the FleetBus. Any subagent can emit any event type; the Director routes it to all listeners. Use it to stream findings, progress updates, or final results to other agents in real time.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          description: "Event type string (e.g. bug.found, refactor.plan, critic.evaluation, progress, result)."
+        },
+        payload: {
+          type: "object",
+          description: "Event payload. Structure depends on event type. Use null if no payload."
+        }
+      },
+      required: ["type"]
+    },
+    async execute(input) {
+      const i = input;
+      director.fleet.emit({
+        subagentId: director.id,
+        ts: Date.now(),
+        type: i.type,
+        payload: i.payload ?? {}
+      });
+      return { ok: true, event: i.type };
+    }
+  };
+}
+function makeWorkCompleteTool(director) {
+  return {
+    name: "work_complete",
+    description: "Signal that the director is satisfied with the results and the fleet should wind down. After calling this, spawn_subagent will refuse with a budget error and assign_task will instantly complete any queued tasks as aborted. Running subagents finish naturally. Call terminate_subagent separately to stop specific subagents immediately.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      director.workComplete();
+      return { ok: true, message: "Fleet wind-down signaled. No new spawns or task dispatches." };
+    }
+  };
+}
+var CollabSession = class extends EventEmitter {
+  sessionId;
+  options;
+  snapshot;
+  director;
+  fleetBus;
+  subagentIds = /* @__PURE__ */ new Map();
+  // role → subagentId
+  bugs = /* @__PURE__ */ new Map();
+  plans = /* @__PURE__ */ new Map();
+  evaluations = /* @__PURE__ */ new Map();
+  disposers = new Array();
+  settled = false;
+  timeoutMs;
+  cancelled = false;
+  alerts = [];
+  /** Tracks tool call counts per subagent for progress-based timeout decisions. */
+  progressBySubagent = /* @__PURE__ */ new Map();
+  /** Last tool call count when a timeout warning was handled. */
+  lastTimeoutProgress = /* @__PURE__ */ new Map();
+  /** Session-level timeout timer handle (cleared on cancel or natural completion). */
+  _timeoutTimer;
+  constructor(director, fleetBus, options) {
+    super();
+    this.sessionId = randomUUID();
+    this.options = options;
+    this.director = director;
+    this.fleetBus = fleetBus;
+    this.timeoutMs = options.timeoutMs ?? 10 * 60 * 1e3;
+    if (options.prebuiltSnapshot) {
+      this.snapshot = options.prebuiltSnapshot;
+    } else {
+      this.snapshot = {
+        id: this.sessionId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        files: []
+      };
+    }
+  }
+  get id() {
+    return this.sessionId;
+  }
+  getSessionAlerts() {
+    return [...this.alerts];
+  }
+  isCancelled() {
+    return this.cancelled;
+  }
+  /**
+   * Snapshot of role → subagentId map. The Director calls coordinator.stop()
+   * for each agent when cancelling the session, using this map to enumerate
+   * all three collab agents.
+   */
+  getSubagentIds() {
+    return new Map(this.subagentIds);
+  }
+  async buildSnapshot() {
+    if (this.snapshot.files.length > 0) return this.snapshot;
+    for (const filePath of this.options.targetPaths) {
+      try {
+        const content = await fsp2.readFile(filePath, "utf8");
+        const ext = filePath.split(".").pop() ?? "";
+        const language = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" ? "javascript" : ext === "md" ? "markdown" : ext === "json" ? "json" : void 0;
+        this.snapshot.files.push({ path: filePath, content, language });
+      } catch {
+        this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
+      }
+    }
+    return this.snapshot;
+  }
+  /**
+   * Cancel the session. Emits director.cancel_collab on the FleetBus so all
+   * collab agents finish early. The session-level timeout timer is also cleared.
+   * Safe to call multiple times (idempotent after first call).
+   */
+  cancel(reason = "Director cancelled collab session") {
+    if (this.settled) return;
+    this.cancelled = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = void 0;
+    }
+    this.fleetBus.emit({
+      subagentId: this.director.id,
+      ts: Date.now(),
+      type: "director.cancel_collab",
+      payload: { sessionId: this.sessionId, reason, cancelledAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    this.fleetBus.emit({
+      subagentId: this.director.id,
+      ts: Date.now(),
+      type: "collab.cancelled",
+      payload: { sessionId: this.sessionId, reason }
+    });
+  }
+  async start() {
+    if (this.settled) throw new Error("session already settled");
+    this.settled = true;
+    await this.buildSnapshot();
+    this.wireFleetBus();
+    const [bugHunterId, refactorPlannerId, criticId] = await Promise.all([
+      this.spawnAgent("bug-hunter", this.buildBugHunterTask()),
+      this.spawnAgent("refactor-planner", this.buildRefactorPlannerTask()),
+      this.spawnAgent("critic", this.buildCriticTask())
+    ]);
+    this.subagentIds.set("bug-hunter", bugHunterId);
+    this.subagentIds.set("refactor-planner", refactorPlannerId);
+    this.subagentIds.set("critic", criticId);
+    const timeout = new Promise((_, reject) => {
+      this._timeoutTimer = setTimeout(() => {
+        this.cancel("Session-level timeout reached");
+        reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+    });
+    let results;
+    try {
+      results = await Promise.race([
+        Promise.all([
+          this.director.awaitTasks([bugHunterId]),
+          this.director.awaitTasks([refactorPlannerId]),
+          this.director.awaitTasks([criticId])
+        ]),
+        timeout
+      ]);
+    } catch (err) {
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = void 0;
+      }
+      this.cleanup();
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.emit("session.error", error);
+      throw error;
+    }
+    for (const result of results.flat()) {
+      await this.parseAndEmit(result);
+    }
+    const report = this.assembleReport();
+    this.cleanup();
+    this.emit("session.done", report);
+    return report;
+  }
+  async parseAndEmit(result) {
+    if (result.status !== "success" || result.result == null) return;
+    const text = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
+    for (const obj of this.extractJsonObjects(text)) {
+      const type = "finding" in obj ? "bug.found" : "plan" in obj ? "refactor.plan" : "evaluation" in obj ? "critic.evaluation" : null;
+      if (!type) continue;
+      this.fleetBus.emit({
+        subagentId: result.subagentId,
+        taskId: result.taskId,
+        ts: Date.now(),
+        type,
+        payload: obj
+      });
+    }
+  }
+  extractJsonObjects(text) {
+    const objects = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+      } else if (ch === "{") {
+        if (depth === 0) start = i;
+        depth++;
+      } else if (ch === "}" && depth > 0) {
+        depth--;
+        if (depth === 0 && start >= 0) {
+          const candidate = text.slice(start, i + 1);
+          try {
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+              objects.push(parsed);
+            }
+          } catch {
+          }
+          start = -1;
+        }
+      }
+    }
+    return objects;
+  }
+  budgetForRole(role) {
+    if (this.options.budgetOverrides?.[role]) {
+      return this.options.budgetOverrides[role];
+    }
+    const defaults = {
+      "bug-hunter": { maxIterations: 2e3, maxToolCalls: 5e3, timeoutMs: 10 * 60 * 1e3 },
+      "refactor-planner": { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 },
+      "critic": { maxIterations: 1e3, maxToolCalls: 3e3, timeoutMs: 6 * 60 * 1e3 }
+    };
+    return defaults[role] ?? { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 };
+  }
+  async spawnAgent(role, taskBrief) {
+    const budget = this.budgetForRole(role);
+    const cfg = {
+      id: `${role}-${this.sessionId}`,
+      name: role,
+      role,
+      tools: ["fleet_emit", "fleet_status", "read", "grep", "glob", "bash", "write"],
+      maxIterations: budget.maxIterations,
+      maxToolCalls: budget.maxToolCalls,
+      timeoutMs: budget.timeoutMs
+    };
+    const subagentId = await this.director.spawn(cfg);
+    await this.director.assign({ id: randomUUID(), subagentId, description: taskBrief });
+    return subagentId;
+  }
+  buildBugHunterTask() {
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are BugHunter. Scan the following files for bugs and code smells.
+
+Target files:
+${fileContents}
+
+For each bug found, emit it using the fleet_emit tool immediately:
+{ "type": "bug.found", "payload": { "finding": { "id": "<uuid>", "type": "<pattern>", "severity": "<critical|high|medium|low>", "location": { "file": "<path>", "line": <n> }, "description": "<explain>", "suggestedFix": "<optional>" } } }
+
+After scanning all files, write your full markdown bug report to:
+${scratchpad}/bug-hunter-report-${this.sessionId}.md
+
+Important: emit each finding as soon as you find it. Do not batch or wait until the end.`;
+  }
+  buildRefactorPlannerTask() {
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are RefactorPlanner. Plan refactorings for the following files.
+
+Target files:
+${fileContents}
+
+Read the BugHunter report at: ${bugHunterReportPath}
+
+For each bug you can address, emit a refactor plan using fleet_emit:
+{ "type": "refactor.plan", "payload": { "plan": { "id": "<uuid>", "basedOnBugIds": ["<bug-id>"], "phases": [{ "number": 1, "title": "<phase>", "tasks": ["<task>"], "risk": "<low|medium|high>" }], "riskScore": "<low|medium|high>", "estimatedChangeCount": <n>, "rollbackStrategy": "<text>" } } }
+
+Also write your full markdown plan to:
+${scratchpad}/refactor-plan-${this.sessionId}.md
+
+Emit each plan immediately. Do not wait until planning is complete.`;
+  }
+  buildCriticTask() {
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+    const refactorPlanPath = `${scratchpad}/refactor-plan-${this.sessionId}.md`;
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are Critic. Evaluate bug findings and refactor plans.
+
+Target files:
+${fileContents}
+
+Read the BugHunter report at: ${bugHunterReportPath}
+Read the RefactorPlanner report at: ${refactorPlanPath}
+
+For each bug and refactor plan, emit your evaluation using fleet_emit:
+{ "type": "critic.evaluation", "payload": { "evaluation": { "id": "<uuid>", "subjectType": "<bug_finding|refactor_plan>", "subjectId": "<id>", "score": <0-10>, "verdict": "<approve|needs_revision|reject>", "strengths": ["<strength>"], "weaknesses": ["<weakness>"], "concerns": [{ "description": "<concern>", "severity": "<blocking|advisory>" }] } } }
+
+After all evaluations, write your markdown report to:
+${scratchpad}/critic-report-${this.sessionId}.md
+
+Emit each evaluation immediately. Do not wait until you have read all reports.`;
+  }
+  wireFleetBus() {
+    const dTool = this.fleetBus.filter("tool.executed", (e) => {
+      this.progressBySubagent.set(e.subagentId, (this.progressBySubagent.get(e.subagentId) ?? 0) + 1);
+    });
+    this.disposers.push(dTool);
+    const dBudget = this.fleetBus.filter("budget.threshold_reached", (e) => {
+      const payload = e.payload;
+      const role = this.roleFromSubagentId(e.subagentId);
+      if (!role) return;
+      const btwNotes = this.director.getLeaderBtwNotes();
+      const alert = {
+        sessionId: this.sessionId,
+        subagentId: e.subagentId,
+        role,
+        level: "warning" /* WARNING */,
+        message: `${role} hit ${payload.kind} soft limit (${payload.used}/${payload.limit})`,
+        budgetKind: payload.kind,
+        elapsedMs: payload.timeoutMs,
+        limit: payload.limit,
+        btwNotes
+      };
+      this.alerts.push(alert);
+      this.fleetBus.emit({
+        subagentId: e.subagentId,
+        ts: Date.now(),
+        type: "collab.warning",
+        payload: alert
+      });
+      const decision = this.options.onBudgetWarning?.(alert) ?? "ignore";
+      if (decision === "cancel") {
+        this.cancel(`Director cancelled: ${role} ${payload.kind} threshold`);
+        return;
+      }
+      if (payload.kind === "timeout") {
+        const progress = this.progressBySubagent.get(e.subagentId) ?? 0;
+        const lastProgress = this.lastTimeoutProgress.get(e.subagentId) ?? -1;
+        if (progress <= lastProgress) {
+          payload.deny();
+          return;
+        }
+        this.lastTimeoutProgress.set(e.subagentId, progress);
+        const newLimit = Math.min(Math.ceil((payload.timeoutMs ?? payload.limit) * 2), 24 * 60 * 6e4);
+        setImmediate(() => {
+          payload.extend({ timeoutMs: newLimit });
+        });
+        return;
+      }
+      if (decision === "extend") {
+        setImmediate(() => {
+          const base = Math.max(payload.limit, payload.used);
+          const extra = {};
+          switch (payload.kind) {
+            case "iterations":
+              extra.maxIterations = Math.min(Math.ceil(base * 1.5), 5e4);
+              break;
+            case "tool_calls":
+              extra.maxToolCalls = Math.min(Math.ceil(base * 1.5), 1e5);
+              break;
+            case "tokens":
+              extra.maxTokens = Math.min(Math.ceil(base * 1.5), 5e6);
+              break;
+            case "cost":
+              extra.maxCostUsd = Math.min(base * 1.5, 100);
+              break;
+          }
+          payload.extend(extra);
+        });
+        return;
+      }
+      if (payload.kind !== "timeout") {
+        setImmediate(() => {
+          const base = Math.max(payload.limit, payload.used);
+          const extra = {};
+          switch (payload.kind) {
+            case "iterations":
+              extra.maxIterations = Math.min(Math.ceil(base * 1.25), 5e4);
+              break;
+            case "tool_calls":
+              extra.maxToolCalls = Math.min(Math.ceil(base * 1.25), 1e5);
+              break;
+            case "tokens":
+              extra.maxTokens = Math.min(Math.ceil(base * 1.25), 5e6);
+              break;
+            case "cost":
+              extra.maxCostUsd = Math.min(base * 1.25, 100);
+              break;
+          }
+          payload.extend(extra);
+        });
+      }
+    });
+    this.disposers.push(dBudget);
+    const dCancel = this.fleetBus.filter("director.cancel_collab", (e) => {
+      const payload = e.payload;
+      if (payload.sessionId !== this.sessionId) return;
+      this.cancelled = true;
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = void 0;
+      }
+      this.fleetBus.emit({
+        subagentId: this.director.id,
+        ts: Date.now(),
+        type: "collab.cancelled",
+        payload: { sessionId: this.sessionId, reason: payload.reason }
+      });
+    });
+    this.disposers.push(dCancel);
+    const d1 = this.fleetBus.filter("bug.found", (e) => {
+      const payload = e.payload;
+      if (payload?.finding) {
+        this.bugs.set(payload.finding.id, payload.finding);
+        this.emit("bug.found", payload);
+      }
+    });
+    this.disposers.push(d1);
+    const d2 = this.fleetBus.filter("refactor.plan", (e) => {
+      const payload = e.payload;
+      if (payload?.plan) {
+        this.plans.set(payload.plan.id, payload.plan);
+        this.emit("refactor.plan", payload);
+      }
+    });
+    this.disposers.push(d2);
+    const d3 = this.fleetBus.filter("critic.evaluation", (e) => {
+      const payload = e.payload;
+      if (payload?.evaluation) {
+        this.evaluations.set(payload.evaluation.id, payload.evaluation);
+        this.emit("critic.evaluation", payload);
+      }
+    });
+    this.disposers.push(d3);
+  }
+  roleFromSubagentId(subagentId) {
+    for (const [role, id] of this.subagentIds) {
+      if (id === subagentId) return role;
+    }
+    const match = subagentId.match(/^(bug-hunter|refactor-planner|critic)/);
+    return match?.[1] ?? null;
+  }
+  assembleReport() {
+    const bugList = Array.from(this.bugs.values());
+    const planList = Array.from(this.plans.values());
+    const evalList = Array.from(this.evaluations.values());
+    let disposition = "completed";
+    if (this.cancelled) disposition = "cancelled";
+    const verdictOrder = {
+      approve: 0,
+      needs_revision: 1,
+      reject: 2
+    };
+    const overallVerdict = evalList.reduce(
+      (worst, eval_) => {
+        const w = verdictOrder[worst];
+        const c = verdictOrder[eval_.verdict];
+        return c > w ? eval_.verdict : worst;
+      },
+      "approve"
+    );
+    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict, disposition);
+    return {
+      sessionId: this.sessionId,
+      startedAt: this.snapshot.createdAt,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetPaths: this.options.targetPaths,
+      disposition,
+      bugs: bugList,
+      refactorPlans: planList,
+      evaluations: evalList,
+      alerts: [...this.alerts],
+      overallVerdict,
+      summary
+    };
+  }
+  buildMarkdownSummary(bugs, plans, evals, overallVerdict, disposition) {
+    const lines = [
+      `## Collaborative Debugging Report \u2014 ${this.sessionId}`,
+      "",
+      `**Target:** ${this.options.targetPaths.join(", ")}`,
+      `**Disposition:** ${disposition.toUpperCase()}`,
+      `**Overall Verdict:** **${overallVerdict.toUpperCase()}**`,
+      ""
+    ];
+    if (this.alerts.length > 0) {
+      lines.push("### Alerts", "");
+      for (const alert of this.alerts) {
+        lines.push(`- **[${alert.level.toUpperCase()}]** ${alert.role}: ${alert.message}`);
+      }
+      lines.push("");
+    }
+    if (bugs.length > 0) {
+      lines.push("### Bugs Found", "");
+      for (const b of bugs) {
+        lines.push(`- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`);
+      }
+      lines.push("");
+    }
+    if (plans.length > 0) {
+      lines.push("### Refactor Plans", "");
+      for (const p of plans) {
+        lines.push(`- **Phase plan** (risk: ${p.riskScore}, ~${p.estimatedChangeCount} changes)`);
+        for (const phase of p.phases) {
+          lines.push(`  - Phase ${phase.number}: ${phase.title} [${phase.risk}]`);
+        }
+      }
+      lines.push("");
+    }
+    if (evals.length > 0) {
+      lines.push("### Critic Evaluations", "");
+      for (const e of evals) {
+        lines.push(`- [${e.subjectType}] score=${e.score}/10 \u2014 **${e.verdict.toUpperCase()}**`);
+        for (const c of e.concerns) {
+          if (c.severity === "blocking") lines.push(`  - ${c.description}`);
+        }
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  cleanup() {
+    for (const dispose of this.disposers) dispose();
+    this.disposers.length = 0;
+  }
+};
+
+// src/coordination/director.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 {
@@ -13071,6 +14134,20 @@ var FleetCostCapError = class extends Error {
     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;
+  }
+};
 var Director = class {
   /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
   get coordinatorId() {
@@ -13087,6 +14164,25 @@ var Director = class {
    * injected; otherwise own FleetUsageAggregator.
    */
   usage;
+  /**
+   * Update the leader agent's current context pressure (full request tokens:
+   * messages + systemPrompt + toolDefs). The director checks this before every
+   * spawn — if the pressure exceeds `maxLeaderContextLoad * maxContext`,
+   * spawning is refused with a `FleetContextOverflowError`.
+   *
+   * Call this after each leader agent iteration to keep the pressure current.
+   * The compactor's `CompactReport.fullRequestTokensAfter` is a natural source.
+   */
+  setLeaderContextPressure(tokens) {
+    this.leaderContextPressure = tokens;
+    this.fleetManager?.setLeaderContextPressure(tokens);
+  }
+  /**
+   * Read the leader agent's current context pressure.
+   */
+  getLeaderContextPressure() {
+    return this.leaderContextPressure;
+  }
   /**
    * Optional fleet-level policy container. When provided the Director
    * delegates spawn budgeting, manifest entries, and checkpointing to it
@@ -13119,6 +14215,8 @@ var Director = class {
   subagentBridges = /* @__PURE__ */ new Map();
   /** Tracks per-spawn config + assigned task ids for manifest writing. */
   manifestEntries = /* @__PURE__ */ new Map();
+  /** Tracks assigned nicknames so the same name is never reused in one fleet. */
+  _usedNicknames = /* @__PURE__ */ new Set();
   manifestPath;
   roster;
   directorPreamble;
@@ -13170,6 +14268,23 @@ var Director = class {
   taskCompletedListener = null;
   /** Optional LLM classifier for smart dispatch. Passed from options. */
   dispatchClassifier;
+  /** Leader agent's current context pressure (full request tokens). */
+  leaderContextPressure = 0;
+  /** Maximum context load fraction before spawn is refused. */
+  maxLeaderContextLoad;
+  /** Provider's max context window in tokens. */
+  maxContext;
+  /**
+   * When set by `workComplete()`, the director stops dispatching new tasks
+   * and terminates all running subagents. Used when the director's LLM decides
+   * the goal is satisfied and no further spawns are needed — prevents the
+   * 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). */
+  _activeCollabSessions = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID();
     this.manifestPath = opts.manifestPath;
@@ -13185,6 +14300,8 @@ var Director = class {
     this.dispatchClassifier = opts.dispatchClassifier;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
+    this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
+    this.maxContext = opts.maxContext ?? 128e3;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
@@ -13212,7 +14329,7 @@ var Director = class {
       this.fleet = new FleetBus();
       this.usage = new FleetUsageAggregator(
         this.fleet,
-        (id, provider, model) => {
+        (_id, provider, model) => {
           if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
           return void 0;
         },
@@ -13274,6 +14391,9 @@ var Director = class {
     });
     this.fleet.filter("budget.threshold_reached", (e) => {
       const payload = e.payload;
+      if (e.subagentId.startsWith("bug-hunter-") || e.subagentId.startsWith("refactor-planner-") || e.subagentId.startsWith("critic-")) {
+        return;
+      }
       if (payload.kind === "timeout") {
         const progress = progressBySubagent.get(e.subagentId) ?? 0;
         const lastProgress = lastTimeoutProgress.get(e.subagentId) ?? -1;
@@ -13352,6 +14472,107 @@ var Director = class {
   extensionsFor(subagentId) {
     return this.extendTotals.get(subagentId) ?? 0;
   }
+  /**
+   * Signal that the director's work is done. Once called:
+   * - `spawn()` throws `FleetSpawnBudgetError('max_spawns', …)` — no new
+   *   subagents can be created
+   * - Running subagents are NOT forcibly stopped — they finish naturally,
+   *   but no new tasks are dispatched to them
+   *
+   * This lets the director LLM say "I'm satisfied with the results, stop
+   * spawning and wind down" — without killing in-flight work mid-execution.
+   * Call `terminateAll()` separately if you need immediate teardown.
+   *
+   * Idempotent — calling twice is a no-op.
+   */
+  workComplete() {
+    this.workCompleteFlag = true;
+    this.fleet.emit({ subagentId: this.id, ts: Date.now(), type: "director.work_complete", payload: {} });
+  }
+  /** Returns true if `workComplete()` has been called on this director. */
+  isWorkComplete() {
+    return this.workCompleteFlag;
+  }
+  /**
+   * Stashes a /btw note on the leader agent's context. The leader's agent loop
+   * calls `consumeBtwNotes()` at each iteration boundary and folds pending notes
+   * into the conversation as a visible block — no abort, no restart, just a
+   * "by the way" nudge the model picks up on its next turn.
+   *
+   * This is the entry point for the host (CLI, TUI) to inject /btw notes
+   * 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;
+  }
+  /**
+   * Read and clear all pending /btw notes the leader has stashed.
+   * Returns them in FIFO order (empty array when none).
+   *
+   * Called by CollabSession when a budget threshold event fires so the
+   * Director can inspect accumulated /btw notes before deciding whether
+   * to cancel the collab session or let it continue.
+   */
+  getLeaderBtwNotes() {
+    const notes = this._leaderBtwNotes;
+    this._leaderBtwNotes = [];
+    return notes;
+  }
+  /**
+   * Peek at pending /btw notes without consuming them.
+   * Useful for UI to show "N pending notes" without clearing them.
+   */
+  peekLeaderBtwNotes() {
+    return [...this._leaderBtwNotes];
+  }
+  /**
+   * Drain (read + clear) all /btw notes in one call.
+   * Alias for getLeaderBtwNotes() — kept for symmetry with consumeBtwNotes()
+   * in the agent's btw.ts. The Director calls this at the point where it
+   * makes a cancellation decision, not on every budget event.
+   */
+  drainLeaderBtwNotes() {
+    return this.getLeaderBtwNotes();
+  }
+  /**
+   * Cancel an active collab session by its id.
+   * Emits `director.cancel_collab` on the FleetBus so the session's agents
+   * finish early with a 'cancelled' disposition.
+   *
+   * Returns silently if the session id is not tracked or already settled.
+   * The CollabDebugReport will reflect 'cancelled' disposition when awaited.
+   */
+  cancelCollabSession(sessionId, reason = "Director cancelled") {
+    const session = this._activeCollabSessions.get(sessionId);
+    if (!session || session.isCancelled()) return;
+    session.cancel(reason);
+    for (const [_role, subagentId] of session.getSubagentIds()) {
+      this.coordinator.stop(subagentId).catch(() => {
+      });
+    }
+  }
+  /**
+   * Subscribe a callback to be notified whenever a collab session raises
+   * an alert (warning level). The callback receives the full DirectorAlert
+   * payload so the host (CLI, TUI) can display it to the user.
+   * Returns an unsubscribe function.
+   */
+  onCollabAlert(handler) {
+    return this.fleet.filter("collab.warning", (e) => {
+      handler(e.payload);
+    });
+  }
+  /**
+   * Returns all active (not yet settled) collab session ids.
+   * Useful for the TUI to render a "N active sessions" badge and for
+   * the host to know what can be cancelled.
+   */
+  activeCollabSessions() {
+    return Array.from(this._activeCollabSessions.keys());
+  }
   /** Best-effort session-writer append. Swallows failures — the director
    *  must not break a fleet run because the session JSONL handle closed. */
   async appendSessionEvent(event) {
@@ -13390,12 +14611,21 @@ var Director = class {
    * it the `cost` column in `usage.snapshot()` stays at 0.
    */
   async spawn(config, priceLookup) {
+    if (this.workCompleteFlag) {
+      throw new FleetSpawnBudgetError(
+        "max_spawns",
+        this.maxSpawns,
+        this.spawnCount + 1,
+        "workComplete() has been called \u2014 director closed further spawning"
+      );
+    }
     if (this.fleetManager) {
       const rejection = this.fleetManager.canSpawn(config);
       if (rejection) {
         if (rejection.kind === "max_spawn_depth") throw new FleetSpawnBudgetError("max_spawn_depth", rejection.limit, rejection.observed);
         if (rejection.kind === "max_spawns") throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
         if (rejection.kind === "max_cost_usd") throw new FleetCostCapError(rejection.limit, rejection.observed);
+        if (rejection.kind === "max_context_load") throw new FleetContextOverflowError(rejection.limit, rejection.observed);
       }
     } else {
       if (this.spawnDepth >= this.maxSpawnDepth) {
@@ -13410,11 +14640,29 @@ var Director = class {
           throw new FleetCostCapError(this.maxFleetCostUsd, totalCost);
         }
       }
+      if (this.maxLeaderContextLoad < 1) {
+        const threshold = this.maxContext * this.maxLeaderContextLoad;
+        if (this.leaderContextPressure >= threshold) {
+          throw new FleetContextOverflowError(threshold, this.leaderContextPressure);
+        }
+      }
     }
     let result;
+    const needsNickname = config.name === config.role || !config.name || config.name === "subagent" || config.name === "adhoc";
+    if (needsNickname) {
+      const role = config.role ?? "subagent";
+      if (this.fleetManager) {
+        this.fleetManager.assignNicknameAndRecord("", config, priceLookup);
+      } else {
+        config.name = assignNickname(role, this._usedNicknames);
+        this._usedNicknames.add(config.name.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-"));
+      }
+    }
     result = await this.coordinator.spawn(config);
     if (this.fleetManager) {
-      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+      if (!needsNickname) {
+        this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+      }
     } else {
       this.spawnCount += 1;
       this.subagentMeta.set(result.subagentId, {
@@ -13625,6 +14873,24 @@ var Director = class {
    */
   async assign(task) {
     const taskWithId = task.id ? task : { ...task, id: randomUUID() };
+    if (this.workCompleteFlag) {
+      const synthetic = {
+        subagentId: taskWithId.subagentId ?? "unassigned",
+        taskId: taskWithId.id,
+        status: "stopped",
+        error: { kind: "aborted_by_parent", message: "Director called workComplete() \u2014 no further tasks will run", retryable: false },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      };
+      this.completed.set(taskWithId.id, synthetic);
+      const waiter = this.taskWaiters.get(taskWithId.id);
+      if (waiter) {
+        waiter.resolve(synthetic);
+        this.taskWaiters.delete(taskWithId.id);
+      }
+      return taskWithId.id;
+    }
     if (task.subagentId) {
       if (this.fleetManager) {
         this.fleetManager.addTaskToSubagent(task.subagentId, taskWithId.id);
@@ -13847,10 +15113,14 @@ var Director = class {
       makeAskTool(this),
       makeRollUpTool(this),
       makeTerminateTool(this),
+      makeTerminateAllTool(this),
       makeFleetStatusTool(this),
       makeFleetUsageTool(this),
       makeFleetSessionTool(this),
-      makeFleetHealthTool(this)
+      makeFleetHealthTool(this),
+      makeCollabDebugTool(this),
+      makeFleetEmitTool(this),
+      makeWorkCompleteTool(this)
     ];
     return t2;
   }
@@ -13862,6 +15132,25 @@ var Director = class {
   async acquireCheckpointLock() {
     return this.stateCheckpoint ? this.stateCheckpoint.acquireLock() : true;
   }
+  /**
+   * Start a collaborative debugging session: BugHunter, RefactorPlanner,
+   * and Critic run in parallel on the same target files, with findings
+   * flowing through the FleetBus (bug.found → refactor.plan →
+   * critic.evaluation). Returns a structured CollabDebugReport when all
+   * 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";
+      }
+    });
+    this._activeCollabSessions.set(session.sessionId, session);
+    session.on("session.done", () => this._activeCollabSessions.delete(session.sessionId));
+    session.on("session.error", () => this._activeCollabSessions.delete(session.sessionId));
+    return session.start();
+  }
   /**
    * Resume from a prior checkpoint snapshot (loaded via
    * `loadDirectorState()`). Re-attach to the fleet mid-flight so
@@ -14349,8 +15638,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path6.join(modesDir, entry);
-      const stat9 = await fsp2.stat(filePath);
-      if (!stat9.isFile()) continue;
+      const stat8 = await fsp2.stat(filePath);
+      if (!stat8.isFile()) continue;
       const content = await fsp2.readFile(filePath, "utf8");
       const id = path6.basename(entry, path6.extname(entry));
       modes.push({
@@ -15623,10 +16912,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp18 = await import('fs/promises');
-      const path31 = await import('path');
+      const fsp19 = await import('fs/promises');
+      const path35 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp18.mkdir(path31.dirname(this.sessionPath), { recursive: true });
+      await fsp19.mkdir(path35.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -15635,8 +16924,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp18 = await import('fs/promises');
-      const raw = await fsp18.readFile(this.sessionPath, "utf8");
+      const fsp19 = await import('fs/promises');
+      const raw = await fsp19.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -15650,8 +16939,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp18 = await import('fs/promises');
-      await fsp18.unlink(this.sessionPath);
+      const fsp19 = await import('fs/promises');
+      await fsp19.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -16278,7 +17567,7 @@ function analyzeCriticalPath(graph) {
     blockedTasks
   };
 }
-function getTransitiveBlocked(graph, taskId, blocksMap) {
+function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
@@ -16294,7 +17583,7 @@ function getTransitiveBlocked(graph, taskId, blocksMap) {
   }
   return visited;
 }
-function computeCriticalPath(graph, topoOrder, blockedByMap) {
+function computeCriticalPath(graph, _topoOrder, blockedByMap) {
   const allIds = Array.from(graph.nodes.keys());
   if (allIds.length === 0) return [];
   const dist = /* @__PURE__ */ new Map();
@@ -16336,15 +17625,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path31 = [];
+  const path35 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path31.unshift(current);
+    path35.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path31;
+  return path35;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -16712,13 +18001,11 @@ function createAutoExecutor(opts) {
 
 // src/sdd/sdd-task-decomposer.ts
 var SddTaskDecomposer = class {
-  constructor(tracker, graph, opts = {}) {
+  constructor(tracker, _graph, opts = {}) {
     this.tracker = tracker;
-    this.graph = graph;
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
   }
   tracker;
-  graph;
   slots;
   wave = 0;
   // -------------------------------------------------------------------
@@ -16871,7 +18158,7 @@ var SddParallelRun = class {
     this.coordinator.setRunner?.(runner);
   }
   defaultFactory() {
-    return async (config) => ({
+    return async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     });
@@ -17324,7 +18611,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path31 = opts.path ?? "/metrics";
+  const path35 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -17334,7 +18621,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path31) {
+    if (url === path35) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -17398,7 +18685,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path31}`,
+    url: `${protocol}://${host}:${boundPort}${path35}`,
     close: () => new Promise((resolve9, reject) => {
       server.close((err) => err ? reject(err) : resolve9());
     })
@@ -17685,6 +18972,12 @@ function roughEstimate(messages) {
   return total;
 }
 function createContextManagerTool(opts = {}) {
+  const minCompactThreshold = opts.minCompactThreshold ?? 0;
+  const noopRetryDeltaTokens = opts.noopRetryDeltaTokens ?? 2e3;
+  const maxContext = opts.maxContext ?? 128e3;
+  const compactThresholdFraction = opts.compactThresholdFraction ?? 0.5;
+  const effectiveThreshold = minCompactThreshold > 0 ? minCompactThreshold : Math.floor(maxContext * compactThresholdFraction);
+  let lastNoopTokens = 0;
   return {
     name: CONTEXT_MANAGER_TOOL_NAME,
     description: 'Inspect or reorganize the conversation context window. Use "check" to see token budget. Use "summary" to collapse a message range into a concise note (provide "text" for custom summary). Use "prune" to remove specific messages by index. Use "add_note" to inject a summary note. Use "compact" to run aggressive compaction. Use "repair" to remove orphan tool_use/tool_result blocks after manual context surgery.',
@@ -17775,11 +19068,41 @@ function createContextManagerTool(opts = {}) {
               notes: "No compactor registered. Use /compact aggressive via slash command instead."
             };
           }
+          const fullEstimate = input.systemPrompt != null && Array.isArray(input.tools) ? estimateRequestTokens(messages, input.systemPrompt, input.tools) : { total: beforeTokens};
+          const currentTokens = fullEstimate.total;
+          if (lastNoopTokens > 0) {
+            const delta = currentTokens - lastNoopTokens;
+            if (delta < noopRetryDeltaTokens) {
+              return {
+                action: "compact",
+                beforeTokens,
+                afterTokens: beforeTokens,
+                messageCount: messages.length,
+                notes: `Compact is a NOOP retry: context grew only ${delta} tokens since the last no-op attempt (threshold: ${noopRetryDeltaTokens}). Skip until more content accumulates.`
+              };
+            }
+          }
+          if (currentTokens < effectiveThreshold) {
+            return {
+              action: "compact",
+              beforeTokens,
+              afterTokens: beforeTokens,
+              messageCount: messages.length,
+              notes: `Context tokens (${currentTokens}) below compact threshold (${effectiveThreshold}). Skipping.`
+            };
+          }
           const report = await opts.compactor.compact(ctx);
           ctx.clearFileTracking();
           const repair = applyMessages([...ctx.messages]);
           const afterTokens = repair.changed ? roughEstimate(ctx.messages) : report.after;
           const repaired = report.repaired ?? (repair.changed ? repair : void 0);
+          const reduced = report.fullRequestTokensBefore > report.fullRequestTokensAfter;
+          const repairedSomething = !!report.repaired;
+          if (reduced || repairedSomething) {
+            lastNoopTokens = 0;
+          } else {
+            lastNoopTokens = currentTokens;
+          }
           return {
             action: "compact",
             beforeTokens,
@@ -18245,10 +19568,10 @@ var SkillInstaller = class {
           if (!resolved.startsWith(path6.resolve(destDir))) {
             throw new Error(`Path traversal detected in skill file: ${file}`);
           }
-          const stat9 = await fsp2.stat(srcPath);
-          if (stat9.size > MAX_SKILL_FILE_SIZE) {
+          const stat8 = await fsp2.stat(srcPath);
+          if (stat8.size > MAX_SKILL_FILE_SIZE) {
             throw new Error(
-              `Skill file "${file}" is too large (${(stat9.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
+              `Skill file "${file}" is too large (${(stat8.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
             );
           }
           await fsp2.mkdir(path6.dirname(destPath), { recursive: true });
@@ -18287,7 +19610,7 @@ var SkillInstaller = class {
    * - Name: update that specific skill
    * - Name + newRef: update to a different ref
    */
-  async update(nameOrRef, opts) {
+  async update(nameOrRef, _opts) {
     const result = { updated: [], unchanged: [], errors: [] };
     const allEntries = await this.manifest.listAll();
     let targets;
@@ -18366,131 +19689,747 @@ var SkillInstaller = class {
     if (!entry) {
       throw new Error(`Skill "${name}" is not installed${scope === "user" ? " (global)" : ""}.`);
     }
-    await this.removeSkillFiles(name, scope);
-    await this.manifest.removeEntry(name, scope);
-    this.invalidateLoaderCache();
+    await this.removeSkillFiles(name, scope);
+    await this.manifest.removeEntry(name, scope);
+    this.invalidateLoaderCache();
+  }
+  /**
+   * List all installed skills from the manifest.
+   */
+  async listInstalled() {
+    return this.manifest.listAll();
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  /**
+   * Detect skills in an extracted repository.
+   * Returns an array of detected skills with their files.
+   */
+  async detectSkills(baseDir) {
+    const results = [];
+    const rootSkillMd = path6.join(baseDir, "SKILL.md");
+    try {
+      await fsp2.access(rootSkillMd);
+      const content = await fsp2.readFile(rootSkillMd, "utf8");
+      const meta = parseFrontmatter2(content);
+      if (meta.name && meta.description) {
+        results.push({
+          name: meta.name,
+          baseDir,
+          files: ["SKILL.md"]
+        });
+        return results;
+      }
+    } catch {
+    }
+    const skillsDir = path6.join(baseDir, "skills");
+    try {
+      const entries = await fsp2.readdir(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillFile = path6.join(skillsDir, entry.name, "SKILL.md");
+        try {
+          const content = await fsp2.readFile(skillFile, "utf8");
+          const meta = parseFrontmatter2(content);
+          if (meta.name && meta.description) {
+            const skillDir = path6.join(skillsDir, entry.name);
+            const files = await collectFiles(skillDir, skillDir);
+            results.push({
+              name: meta.name,
+              baseDir: skillDir,
+              files
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return results;
+  }
+  /**
+   * Remove all files for an installed skill.
+   */
+  async removeSkillFiles(name, scope) {
+    const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
+    const skillDir = path6.join(targetDir, name);
+    await fsp2.rm(skillDir, { recursive: true, force: true });
+  }
+  /**
+   * Invalidate the skill loader's cache so newly installed skills appear.
+   */
+  invalidateLoaderCache() {
+    const loader = this.opts.skillLoader;
+    if (loader && typeof loader.invalidateCache === "function") {
+      loader.invalidateCache();
+    }
+  }
+};
+function parseFrontmatter2(raw) {
+  if (!raw.startsWith("---")) return {};
+  const end = raw.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const block = raw.slice(4, end);
+  const out = {};
+  let key = null;
+  let value = [];
+  const flush = () => {
+    if (key) {
+      out[key] = value.join("\n").trim();
+    }
+    key = null;
+    value = [];
+  };
+  for (const line of block.split("\n")) {
+    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
+    if (m) {
+      flush();
+      key = m[1] ?? "";
+      const pipe = m[2];
+      const rest = m[3] ?? "";
+      if (pipe === "|") {
+        value = [];
+      } else if (rest) {
+        value = [rest];
+      } else {
+        value = [];
+      }
+    } else if (key) {
+      value.push(line.replace(/^\s+/, ""));
+    }
+  }
+  flush();
+  return out;
+}
+async function collectFiles(dir, baseDir) {
+  const results = [];
+  const entries = await fsp2.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path6.join(dir, entry.name);
+    const relPath = path6.relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      results.push(...await collectFiles(fullPath, baseDir));
+    } else {
+      results.push(relPath);
+    }
+  }
+  return results;
+}
+
+// src/storage/annotations-store.ts
+init_atomic_write();
+var FILE_VERSION = 1;
+var MAX_TEXT_LENGTH = 2e3;
+var MAX_ANNOTATIONS = 1e3;
+var AnnotationsStore = class {
+  dir;
+  /** Per-session write queue. Created lazily on first add. */
+  writeChains = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.dir = opts.dir;
+  }
+  // ── Reads ──────────────────────────────────────────────────────────────
+  /**
+   * Return all annotations for `sessionId` in insertion order
+   * (oldest first). Returns an empty array when no file exists
+   * yet (the normal case for a fresh session).
+   */
+  async list(sessionId) {
+    const file = await this.readFile(sessionId);
+    return file ? file.annotations : [];
+  }
+  /**
+   * Convenience: only unresolved annotations, newest first — the
+   * common UI rendering for "what still needs attention?".
+   */
+  async listOpen(sessionId) {
+    const all = await this.list(sessionId);
+    return all.filter((a) => !a.resolved).reverse();
+  }
+  // ── Writes ─────────────────────────────────────────────────────────────
+  /**
+   * Add a new annotation. Returns the persisted record (with id
+   * and timestamps filled in). Throws when `text` is empty or
+   * exceeds `MAX_TEXT_LENGTH`.
+   */
+  async add(input) {
+    const text = input.text.trim();
+    if (text.length === 0) {
+      throw new Error("Annotation text must be non-empty");
+    }
+    if (text.length > MAX_TEXT_LENGTH) {
+      throw new Error(
+        `Annotation text exceeds ${MAX_TEXT_LENGTH} chars (got ${text.length})`
+      );
+    }
+    if (!Number.isInteger(input.atEventIndex) || input.atEventIndex < 0) {
+      throw new Error("atEventIndex must be a non-negative integer");
+    }
+    const annotation = {
+      id: randomUUID(),
+      sessionId: input.sessionId,
+      atEventIndex: input.atEventIndex,
+      authorId: input.authorId,
+      authorRole: "annotator",
+      text,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      resolved: false
+    };
+    await this.enqueue(input.sessionId, async () => {
+      const all = await this.list(input.sessionId);
+      all.push(annotation);
+      if (all.length > MAX_ANNOTATIONS) {
+        const sorted = all.map((a, i) => ({ a, i })).sort((x, y) => {
+          if (x.a.resolved !== y.a.resolved) return x.a.resolved ? 1 : -1;
+          return x.a.createdAt.localeCompare(y.a.createdAt);
+        });
+        const evictCount = all.length - MAX_ANNOTATIONS;
+        const toEvict = new Set(sorted.slice(0, evictCount).map((s) => s.a.id));
+        const kept = all.filter((a) => !toEvict.has(a.id));
+        await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: kept });
+      } else {
+        await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
+      }
+    });
+    return annotation;
+  }
+  /**
+   * Mark an annotation as resolved. Returns the updated record, or
+   * `null` if no annotation with that id exists in this session.
+   * Idempotent: resolving an already-resolved annotation refreshes
+   * `resolvedAt` / `resolvedBy` to the latest call.
+   */
+  async resolve(input) {
+    let updated = null;
+    await this.enqueue(input.sessionId, async () => {
+      const all = await this.list(input.sessionId);
+      const idx = all.findIndex((a) => a.id === input.annotationId);
+      if (idx === -1) {
+        updated = null;
+        return;
+      }
+      const next = {
+        ...all[idx],
+        resolved: true,
+        resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        resolvedBy: input.resolvedBy
+      };
+      all[idx] = next;
+      await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
+      updated = next;
+    });
+    return updated;
+  }
+  // ── Internals ──────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.annotations.json`);
+  }
+  async readFile(sessionId) {
+    const fp = this.filePath(sessionId);
+    try {
+      const raw = await fsp2.readFile(fp, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== FILE_VERSION) {
+        return { version: FILE_VERSION, annotations: [] };
+      }
+      return parsed;
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return { version: FILE_VERSION, annotations: [] };
+    }
+  }
+  async writeFile(sessionId, file) {
+    const fp = this.filePath(sessionId);
+    await atomicWrite(fp, JSON.stringify(file, null, 2));
+  }
+  /**
+   * Serialize writes per-sessionId. We chain promises instead of
+   * using a Mutex class so the contract is obvious from the
+   * call-site: `enqueue(sid, fn)` runs `fn` after every prior
+   * enqueue for `sid` has settled.
+   */
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
+  }
+};
+
+// src/storage/replay-log-store.ts
+init_atomic_write();
+function stableStringify(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = sortKeys(obj[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function hashRequest(request) {
+  const payload = {
+    model: request.model,
+    system: request.system,
+    messages: request.messages,
+    tools: request.tools,
+    maxTokens: request.maxTokens,
+    temperature: request.temperature,
+    topP: request.topP,
+    stopSequences: request.stopSequences,
+    toolChoice: request.toolChoice
+  };
+  const json = stableStringify(payload);
+  const digest = createHash("sha256").update(json, "utf8").digest("hex");
+  return `sha256:${digest}`;
+}
+var DEFAULT_MAX_ENTRIES = 1e3;
+var ReplayLogStore = class {
+  dir;
+  writeChains = /* @__PURE__ */ new Map();
+  /** Per-session hash → entry index, kept in memory after the first load. */
+  cache = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  // ── Writes ──────────────────────────────────────────────────────────────
+  /**
+   * Record a request/response pair. Idempotent on hash: a second
+   * `record` for the same hash is a no-op (the existing entry wins).
+   * Returns the hash.
+   */
+  async record(input) {
+    const hash = hashRequest(input.request);
+    await this.enqueue(input.sessionId, async () => {
+      const cache = await this.ensureCache(input.sessionId);
+      if (cache.has(hash)) return;
+      const entry = {
+        hash,
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        request: input.request,
+        response: input.response
+      };
+      let all = [...cache.values(), entry];
+      if (all.length > this.maxEntries) {
+        const evictCount = all.length - this.maxEntries;
+        all = all.slice(evictCount);
+      }
+      await this.writeAll(input.sessionId, all);
+      cache.clear();
+      for (const e of all) cache.set(e.hash, e);
+    });
+    return hash;
+  }
+  // ── Reads ───────────────────────────────────────────────────────────────
+  /**
+   * Look up an entry by hash. Returns `null` when the request has
+   * not been recorded for this session. O(1) after the first call
+   * per session (in-memory cache).
+   */
+  async lookup(sessionId, hash) {
+    const cache = await this.ensureCache(sessionId);
+    return cache.get(hash) ?? null;
+  }
+  /** All recorded entries for a session, in insertion order. */
+  async load(sessionId) {
+    const cache = await this.ensureCache(sessionId);
+    return [...cache.values()];
+  }
+  /**
+   * List every session id that has a replay log in the store dir.
+   * Returns an array of `{ sessionId, entryCount, path }` sorted
+   * by sessionId for stable output. Used by `wstack replay --list`.
+   */
+  async list() {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
+    }
+    const out = [];
+    for (const name of entries) {
+      if (!name.endsWith(".replay.jsonl")) continue;
+      const sessionId = name.slice(0, -".replay.jsonl".length);
+      const all = await this.load(sessionId);
+      out.push({
+        sessionId,
+        entryCount: all.length,
+        path: path6.join(this.dir, name)
+      });
+    }
+    return out.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+  }
+  // ── Internals ───────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.replay.jsonl`);
+  }
+  async readAll(sessionId) {
+    const fp = this.filePath(sessionId);
+    try {
+      const raw = await fsp2.readFile(fp, "utf8");
+      const out = [];
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if ("entry" in parsed && parsed.entry) {
+            out.push(parsed.entry);
+          } else {
+            out.push(parsed);
+          }
+        } catch {
+        }
+      }
+      return out;
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
+    }
+  }
+  async writeAll(sessionId, entries) {
+    const fp = this.filePath(sessionId);
+    const body = entries.map((e) => JSON.stringify(e)).join("\n") + (entries.length ? "\n" : "");
+    await atomicWrite(fp, body);
+  }
+  async ensureCache(sessionId) {
+    let cache = this.cache.get(sessionId);
+    if (cache) return cache;
+    const all = await this.readAll(sessionId);
+    cache = /* @__PURE__ */ new Map();
+    for (const e of all) cache.set(e.hash, e);
+    this.cache.set(sessionId, cache);
+    return cache;
+  }
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
+  }
+};
+var SessionRecovery = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  /**
+   * Scan a session log and return a `StaleSession` if and only
+   * if the last event is an `in_flight_start` without a matching
+   * `in_flight_end`. Returns `null` when:
+   *   - the log does not exist;
+   *   - the log is empty;
+   *   - the last event is `in_flight_end` (clean shutdown);
+   *   - the last event is something else (e.g. an unannotated
+   *     legacy log without in-flight markers).
+   */
+  async detectStale(sessionId) {
+    const fp = this.filePath(sessionId);
+    let raw;
+    try {
+      raw = await fsp2.readFile(fp, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return null;
+    }
+    return this.parseForStale(sessionId, fp, raw);
+  }
+  /**
+   * Generate a recovery plan for a session. The plan describes
+   * "what would be re-executed" if the user chose to resume —
+   * everything after the last `checkpoint` event, plus the
+   * dangling in-flight marker if present.
+   *
+   * Returns a non-null plan for ANY session that has at least
+   * one event after a checkpoint (or, for legacy sessions, at
+   * least one event). Pure read; no mutation.
+   */
+  async recover(sessionId) {
+    const fp = this.filePath(sessionId);
+    let raw;
+    try {
+      raw = await fsp2.readFile(fp, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      return null;
+    }
+    const events = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    if (events.length === 0) return null;
+    let lastCheckpoint = null;
+    let lastCheckpointIdx = -1;
+    for (let i = 0; i < events.length; i++) {
+      if (events[i].type === "checkpoint") {
+        lastCheckpoint = events[i];
+        lastCheckpointIdx = i;
+      }
+    }
+    const pendingEvents = lastCheckpointIdx >= 0 ? events.slice(lastCheckpointIdx + 1) : events;
+    const lastEv = events[events.length - 1];
+    const inFlightStart = lastEv.type === "in_flight_start" ? lastEv : null;
+    const context = inFlightStart && inFlightStart.type === "in_flight_start" ? inFlightStart.context : null;
+    return {
+      sessionId,
+      stale: inFlightStart !== null,
+      lastCheckpoint,
+      pendingEvents,
+      inFlightStart,
+      context
+    };
+  }
+  /**
+   * List every stale session in a directory. Returns an array
+   * (possibly empty) sorted by `lastEventTs` descending — most
+   * recent crash first.
+   */
+  async listResumable() {
+    let entries;
+    try {
+      entries = await fsp2.readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
+    }
+    const out = [];
+    for (const name of entries) {
+      if (!name.endsWith(".jsonl")) continue;
+      const sessionId = name.slice(0, -".jsonl".length);
+      if (sessionId.includes(".replay") || sessionId.includes(".annotations")) continue;
+      const stale = await this.detectStale(sessionId);
+      if (stale) out.push(stale);
+    }
+    return out.sort((a, b) => b.lastEventTs.localeCompare(a.lastEventTs));
+  }
+  // ── Internals ──────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.jsonl`);
+  }
+  /**
+   * Stream-parse the last few lines of a JSONL log. We do NOT load
+   * the whole file into memory — for long-running sessions the log
+   * can be megabytes. Instead we read tail-ward and find the last
+   * `in_flight_start` / `in_flight_end` pair.
+   */
+  async parseForStale(sessionId, fp, raw) {
+    const lines = raw.split("\n");
+    let lastEvent = null;
+    let eventCount = 0;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const ev = JSON.parse(line);
+        lastEvent = ev;
+        eventCount++;
+      } catch {
+      }
+    }
+    if (!lastEvent) return null;
+    if (lastEvent.type === "in_flight_start") {
+      return {
+        sessionId,
+        path: fp,
+        lastEventTs: lastEvent.ts,
+        context: lastEvent.context,
+        eventCount
+      };
+    }
+    return null;
+  }
+};
+
+// src/storage/tool-audit-log.ts
+init_atomic_write();
+var GENESIS_PREV = "0".repeat(64);
+var ToolAuditLog = class {
+  dir;
+  /** In-memory cache of the last entry's hash (per session), to compute chains efficiently. */
+  tailHash = /* @__PURE__ */ new Map();
+  writeChains = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.dir = opts.dir;
   }
   /**
-   * List all installed skills from the manifest.
+   * Append a tool call/result pair to the chain. Returns the
+   * resulting entry. Idempotency is not guaranteed — if you
+   * record the same tool_use twice you get two entries. That's
+   * intentional: the audit log is a record, not a cache.
    */
-  async listInstalled() {
-    return this.manifest.listAll();
+  async record(input) {
+    let entry = null;
+    await this.enqueue(input.sessionId, async () => {
+      const prevHash = this.tailHash.get(input.sessionId) ?? GENESIS_PREV;
+      const id = randomUUID();
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const content = {
+        id,
+        ts,
+        prevHash,
+        toolName: input.toolName,
+        toolUseId: input.toolUseId,
+        input: input.input,
+        output: input.output,
+        isError: input.isError
+      };
+      const hash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
+      entry = {
+        index: this.tailHash.has(input.sessionId) ? -1 : 0,
+        // placeholder; recomputed below
+        id,
+        ts,
+        prevHash,
+        hash,
+        toolName: input.toolName,
+        toolUseId: input.toolUseId,
+        input: input.input,
+        output: input.output,
+        isError: input.isError
+      };
+      const existing = await this.readAll(input.sessionId);
+      const index = existing.length;
+      const finalContent = { ...content, index };
+      const finalHash = createHash("sha256").update(stableStringify2(finalContent), "utf8").digest("hex");
+      entry = { ...entry, index, hash: finalHash };
+      await this.appendLine(input.sessionId, entry);
+      this.tailHash.set(input.sessionId, finalHash);
+    });
+    return entry;
   }
-  // ── Private helpers ──────────────────────────────────────────────
   /**
-   * Detect skills in an extracted repository.
-   * Returns an array of detected skills with their files.
+   * Walk the chain and verify every entry's hash and prevHash.
+   * Returns a structured verdict — never throws.
    */
-  async detectSkills(baseDir) {
-    const results = [];
-    const rootSkillMd = path6.join(baseDir, "SKILL.md");
-    try {
-      await fsp2.access(rootSkillMd);
-      const content = await fsp2.readFile(rootSkillMd, "utf8");
-      const meta = parseFrontmatter2(content);
-      if (meta.name && meta.description) {
-        results.push({
-          name: meta.name,
-          baseDir,
-          files: ["SKILL.md"]
-        });
-        return results;
+  async verify(sessionId) {
+    const entries = await this.readAll(sessionId);
+    if (entries.length === 0) return { ok: true, entries: 0 };
+    if (entries[0].prevHash !== GENESIS_PREV) {
+      return {
+        ok: false,
+        brokenAt: 0,
+        reason: "first entry is not the genesis (prevHash != 0\u20260)"
+      };
+    }
+    let prevHash = GENESIS_PREV;
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      if (e.prevHash !== prevHash) {
+        return {
+          ok: false,
+          brokenAt: i,
+          reason: `prevHash mismatch at entry ${i} (expected ${prevHash.slice(0, 8)}\u2026, got ${e.prevHash.slice(0, 8)}\u2026)`
+        };
       }
-    } catch {
+      const content = {
+        id: e.id,
+        ts: e.ts,
+        prevHash: e.prevHash,
+        toolName: e.toolName,
+        toolUseId: e.toolUseId,
+        input: e.input,
+        output: e.output,
+        isError: e.isError,
+        index: e.index
+      };
+      const expectedHash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
+      if (expectedHash !== e.hash) {
+        return {
+          ok: false,
+          brokenAt: i,
+          reason: `hash mismatch at entry ${i} (entry content was modified)`
+        };
+      }
+      prevHash = e.hash;
     }
-    const skillsDir = path6.join(baseDir, "skills");
+    return { ok: true, entries: entries.length };
+  }
+  /** All entries for a session, in insertion order. */
+  async load(sessionId) {
+    return this.readAll(sessionId);
+  }
+  // ── Internals ────────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
+      throw new Error(`Invalid sessionId: ${sessionId}`);
+    }
+    return path6.join(this.dir, `${sessionId}.audit.jsonl`);
+  }
+  async readAll(sessionId) {
+    const fp = this.filePath(sessionId);
     try {
-      const entries = await fsp2.readdir(skillsDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const skillFile = path6.join(skillsDir, entry.name, "SKILL.md");
+      const raw = await fsp2.readFile(fp, "utf8");
+      const out = [];
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
         try {
-          const content = await fsp2.readFile(skillFile, "utf8");
-          const meta = parseFrontmatter2(content);
-          if (meta.name && meta.description) {
-            const skillDir = path6.join(skillsDir, entry.name);
-            const files = await collectFiles(skillDir, skillDir);
-            results.push({
-              name: meta.name,
-              baseDir: skillDir,
-              files
-            });
-          }
+          out.push(JSON.parse(line));
         } catch {
         }
       }
-    } catch {
+      return out;
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      return [];
     }
-    return results;
   }
-  /**
-   * Remove all files for an installed skill.
-   */
-  async removeSkillFiles(name, scope) {
-    const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
-    const skillDir = path6.join(targetDir, name);
-    await fsp2.rm(skillDir, { recursive: true, force: true });
+  async appendLine(sessionId, entry) {
+    const fp = this.filePath(sessionId);
+    const existing = await this.readAll(sessionId);
+    const all = [...existing, entry];
+    await atomicWrite(fp, all.map((e) => JSON.stringify(e)).join("\n") + (all.length ? "\n" : ""));
   }
-  /**
-   * Invalidate the skill loader's cache so newly installed skills appear.
-   */
-  invalidateLoaderCache() {
-    const loader = this.opts.skillLoader;
-    if (loader && typeof loader.invalidateCache === "function") {
-      loader.invalidateCache();
-    }
+  enqueue(sessionId, fn) {
+    const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.writeChains.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
   }
 };
-function parseFrontmatter2(raw) {
-  if (!raw.startsWith("---")) return {};
-  const end = raw.indexOf("\n---", 4);
-  if (end === -1) return {};
-  const block = raw.slice(4, end);
-  const out = {};
-  let key = null;
-  let value = [];
-  const flush = () => {
-    if (key) {
-      out[key] = value.join("\n").trim();
-    }
-    key = null;
-    value = [];
-  };
-  for (const line of block.split("\n")) {
-    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
-    if (m) {
-      flush();
-      key = m[1] ?? "";
-      const pipe = m[2];
-      const rest = m[3] ?? "";
-      if (pipe === "|") {
-        value = [];
-      } else if (rest) {
-        value = [rest];
-      } else {
-        value = [];
-      }
-    } else if (key) {
-      value.push(line.replace(/^\s+/, ""));
-    }
-  }
-  flush();
-  return out;
+function stableStringify2(value) {
+  return JSON.stringify(sortKeys2(value));
 }
-async function collectFiles(dir, baseDir) {
-  const results = [];
-  const entries = await fsp2.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path6.join(dir, entry.name);
-    const relPath = path6.relative(baseDir, fullPath);
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      results.push(...await collectFiles(fullPath, baseDir));
-    } else {
-      results.push(relPath);
+function sortKeys2(value) {
+  if (Array.isArray(value)) return value.map(sortKeys2);
+  if (value && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = sortKeys2(obj[key]);
     }
+    return sorted;
   }
-  return results;
+  return value;
 }
 
 // src/storage/session-rewinder.ts
@@ -18666,7 +20605,7 @@ var DefaultPromptStore = class {
   }
   async list() {
     await ensureDir(this.dir);
-    let entries = [];
+    const entries = [];
     try {
       const files = await fsp2.readdir(this.dir);
       for (const file of files) {
@@ -18785,7 +20724,25 @@ var CloudSync = class {
       baseTreeSha,
       `Sync ${cfg.categories.join(", ")} \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`
     );
-    await this.updateRef(token, owner, repoName, branch, commitSha);
+    try {
+      await this.updateRef(token, owner, repoName, branch, commitSha);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("422")) {
+        const remote = await this.getRef(token, owner, repoName, branch);
+        const currentSha = remote.object.sha;
+        const rebasedCommitSha = await this.createCommit(
+          token,
+          owner,
+          repoName,
+          newTreeSha,
+          currentSha,
+          `Sync ${cfg.categories.join(", ")} \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`
+        );
+        await this.updateRef(token, owner, repoName, branch, rebasedCommitSha);
+      } else {
+        throw err;
+      }
+    }
     const syncState = {
       version: 1,
       sha: commitSha,
@@ -18924,8 +20881,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat9 = await fsp2.stat(localPath);
-        if (stat9.isDirectory()) {
+        const stat8 = await fsp2.stat(localPath);
+        if (stat8.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file, "utf8");
@@ -18950,8 +20907,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat9 = await fsp2.stat(localPath);
-        if (stat9.isDirectory()) {
+        const stat8 = await fsp2.stat(localPath);
+        if (stat8.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file);
@@ -19552,7 +21509,7 @@ var SkillGenerator = class {
     };
     return [commonInjection, ...stackSpecific[stack] ?? []];
   }
-  getConfigPatterns(stack) {
+  getConfigPatterns(_stack) {
     const commonConfig = [
       {
         id: "insecure-tls",
@@ -20134,7 +22091,6 @@ var SecurityScannerOrchestrator = class {
   retryPolicy;
   errorHandler;
   detector = defaultTechStackDetector;
-  reportGenerator = defaultReportGenerator;
   gitignoreUpdater = defaultGitignoreUpdater;
   /**
    * Wraps provider.complete with retry logic using the injected RetryPolicy.
@@ -20318,7 +22274,7 @@ Return ONLY the JSON object, no markdown, no explanation.`;
   /**
    * Scan a batch of files using LLM.
    */
-  async scanFileBatchLLM(provider, model, files, skill, techStack) {
+  async scanFileBatchLLM(provider, model, files, skill, _techStack) {
     const fileContents = [];
     for (const file of files) {
       try {
@@ -20515,7 +22471,7 @@ Be specific about the vulnerabilities found and how to fix them.`;
   /**
    * Gather project info for skill generation.
    */
-  async gatherProjectInfo(projectRoot, techStack) {
+  async gatherProjectInfo(projectRoot, _techStack) {
     const info = [];
     const keyFiles = [
       "package.json",
@@ -20547,7 +22503,7 @@ ${dirs.join(", ")}`);
   /**
    * Gather files to scan based on patterns.
    */
-  async gatherFiles(root, patterns, depth) {
+  async gatherFiles(root, _patterns, depth) {
     const files = [];
     const maxDepth = depth === "quick" ? 2 : depth === "deep" ? 20 : 5;
     const extensions = [".ts", ".js", ".jsx", ".tsx", ".py", ".go", ".java", ".cs", ".rs"];
@@ -20806,22 +22762,22 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile34 } = await import('fs/promises');
-      const content = await readFile34(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile37 } = await import('fs/promises');
+      const content = await readFile37(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile34 } = await import('fs/promises');
-      const content = await readFile34(join(reportsDir, match), "utf-8");
+      const { readFile: readFile37 } = await import('fs/promises');
+      const content = await readFile37(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     return { message: `\u274C Report "${reportId}" not found. Use \`/security report\` to see available reports.` };
-  } catch (error) {
+  } catch (_error) {
     return { message: "\u{1F4ED} No security reports found. Run `/security scan` first." };
   }
 }
@@ -20874,7 +22830,6 @@ var FleetManager = class {
   /** Usage rollup across all subagents. */
   usage;
   manifestPath;
-  sessionsRoot;
   directorRunId;
   /** Spawn cap (lifetime total). Infinity means unlimited. */
   maxSpawns;
@@ -20898,11 +22853,18 @@ var FleetManager = class {
   pendingTasks = /* @__PURE__ */ new Map();
   subagentMeta = /* @__PURE__ */ new Map();
   priceLookups = /* @__PURE__ */ new Map();
+  /** Tracks which nickname keys are already assigned — prevents collisions. */
+  _usedNicknames = /* @__PURE__ */ new Set();
   /** The coordinator (wired via setCoordinator by Director after construction). */
   coordinator = null;
+  /** Leader agent's current context pressure (full request tokens). */
+  leaderContextPressure = 0;
+  /** Maximum context load fraction before spawn is refused. */
+  maxLeaderContextLoad;
+  /** Provider's max context window in tokens. */
+  maxContext;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
-    this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? randomUUID();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
@@ -20910,6 +22872,8 @@ var FleetManager = class {
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
+    this.maxContext = opts.maxContext ?? 128e3;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(
       opts.stateCheckpointPath,
       {
@@ -20924,7 +22888,7 @@ var FleetManager = class {
     this.fleet = new FleetBus();
     this.usage = new FleetUsageAggregator(
       this.fleet,
-      (id, provider, model) => {
+      (_id, provider, model) => {
         if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
         return void 0;
       },
@@ -20963,7 +22927,7 @@ var FleetManager = class {
    * which cap was exceeded. Does NOT throw — the caller decides
    * how to surface the rejection.
    */
-  canSpawn(config) {
+  canSpawn(_config) {
     if (this.spawnDepth >= this.maxSpawnDepth) {
       return { kind: "max_spawn_depth", limit: this.maxSpawnDepth, observed: this.spawnDepth };
     }
@@ -20976,8 +22940,45 @@ var FleetManager = class {
         return { kind: "max_cost_usd", limit: this.maxFleetCostUsd, observed: totalCost };
       }
     }
+    if (this.maxLeaderContextLoad < 1) {
+      const threshold = this.maxContext * this.maxLeaderContextLoad;
+      if (this.leaderContextPressure >= threshold) {
+        return {
+          kind: "max_context_load",
+          limit: threshold,
+          observed: this.leaderContextPressure
+        };
+      }
+    }
     return null;
   }
+  setLeaderContextPressure(tokens) {
+    this.leaderContextPressure = tokens;
+  }
+  /**
+   * Assign a memorable nickname (e.g. "Einstein (Bug Hunter)") to the config,
+   * record it so the same name is never reused, then record the spawn.
+   *
+   * Call this INSTEAD of `recordSpawn` when you want automatic nicknames.
+   * The nickname is written back to `config.name` BEFORE the coordinator
+   * sees the config, so the manifest, logs, and fleet UI all show it.
+   */
+  assignNicknameAndRecord(subagentId, config, priceLookup) {
+    const role = config.role ?? "subagent";
+    const nickname = assignNickname(role, this._usedNicknames);
+    const baseKey = nickname.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    this._usedNicknames.add(baseKey);
+    config.name = nickname;
+    this.recordSpawn(subagentId, config, priceLookup);
+    return nickname;
+  }
+  /**
+   * Returns the set of already-assigned nickname keys — useful for debugging
+   * and testing.
+   */
+  get usedNicknames() {
+    return this._usedNicknames;
+  }
   /**
    * Records a spawn: increments counter, stores metadata, updates state checkpoint,
    * and schedules a debounced manifest write. Call AFTER the coordinator
@@ -21178,7 +23179,7 @@ function createMcpControlTool(opts) {
     mutating: true,
     riskTier: "standard",
     inputSchema,
-    async execute(raw, ctx) {
+    async execute(raw) {
       const input = raw;
       return mcpControlDispatch(input, { getConfig, configPath, registry });
     }
@@ -21726,7 +23727,6 @@ var Agent = class {
   pipelines;
   ctx;
   maxIterations;
-  iterationTimeoutMs;
   executionStrategy;
   perIterationOutputCapBytes;
   plugins = [];
@@ -21744,7 +23744,6 @@ var Agent = class {
     this.pipelines = init.pipelines;
     this.ctx = init.context;
     this.maxIterations = init.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-    this.iterationTimeoutMs = init.iterationTimeoutMs ?? 3e5;
     this.executionStrategy = init.executionStrategy ?? "smart";
     this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
     this.autoExtendLimit = init.autoExtendLimit ?? true;
@@ -21766,9 +23765,6 @@ var Agent = class {
   get permission() {
     return this.container.resolve(TOKENS.PermissionPolicy);
   }
-  get scrubber() {
-    return this.container.resolve(TOKENS.SecretScrubber);
-  }
   get renderer() {
     return this.container.has(TOKENS.Renderer) ? this.container.resolve(TOKENS.Renderer) : void 0;
   }
@@ -21898,6 +23894,11 @@ var Agent = class {
         if (controller.signal.aborted) {
           return { status: "aborted", iterations };
         }
+        await this.ctx.session.writeInFlightMarker(`iteration ${i} / max ${this.maxIterations}`).catch((err) => {
+          this.logger.debug?.(
+            `in-flight marker write failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
         if (autonomousContinue) {
           consumeAutonomousContinue(this.ctx);
         }
@@ -21979,6 +23980,7 @@ var Agent = class {
         finalText = responseResult.finalText;
         const toolUses = res.content.filter(isToolUseBlock);
         if (toolUses.length === 0) {
+          this.emitContextPct();
           this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
           if (autonomousContinue && responseResult.directive === "continue") {
             await this.compactContextIfNeeded();
@@ -21992,11 +23994,13 @@ var Agent = class {
         }
         await this.executeTools(toolUses);
         if (autonomousContinue && consumeAutonomousContinue(this.ctx)) {
+          this.emitContextPct();
           this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
           await this.compactContextIfNeeded();
           await this.extensions.runAfterIteration(this.ctx, i);
           continue;
         }
+        this.emitContextPct();
         this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
         await this.compactContextIfNeeded();
         await this.extensions.runAfterIteration(this.ctx, i);
@@ -22009,6 +24013,12 @@ var Agent = class {
       }
     } finally {
       offSubagentDone();
+      const reason = controller.signal.aborted ? "aborted" : "clean";
+      await this.ctx.session.clearInFlightMarker(reason).catch((err) => {
+        this.logger.debug?.(
+          `in-flight marker clear failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
     }
   }
   /**
@@ -22301,6 +24311,19 @@ var Agent = class {
   async compactContextIfNeeded() {
     await this.pipelines.contextWindow.run(this.ctx);
   }
+  /**
+   * Emit the current context window load as a `ctx.pct` event so subscribers
+   * (FleetBus → TUI) can render a live fill bar per agent.
+   */
+  emitContextPct() {
+    const maxContext = this.ctx.provider.capabilities.maxContext ?? 2e5;
+    const { total } = estimateRequestTokens(
+      this.ctx.messages,
+      this.ctx.systemPrompt,
+      this.ctx.tools ?? []
+    );
+    this.events.emit("ctx.pct", { load: total / maxContext, tokens: total, maxContext });
+  }
 };
 function toError(err) {
   return err instanceof Error ? err : new Error(String(err));
@@ -22977,8 +25000,8 @@ ${mem}`);
   }
   async dirExists(p) {
     try {
-      const stat9 = await fsp2.stat(p);
-      return stat9.isDirectory();
+      const stat8 = await fsp2.stat(p);
+      return stat8.isDirectory();
     } catch {
       return false;
     }
@@ -23391,10 +25414,28 @@ var DefaultPluginAPI = class {
     }
     this.pipelines = readonlyPipelines;
     const tr = init.toolRegistry;
+    const isOfficial = init.official === true;
+    const assertCanMutateTool = (name, op) => {
+      if (isOfficial) return;
+      const currentOwner = tr.ownerOf(name);
+      if (currentOwner === void 0) return;
+      const ownedSolelyByMe = currentOwner.split("+").every((seg) => seg === owner);
+      if (!ownedSolelyByMe) {
+        throw new Error(
+          `Plugin "${owner}" may not ${op} tool "${name}" \u2014 it is owned by "${currentOwner}". Only official (first-party) plugins may modify tools they do not own.`
+        );
+      }
+    };
     this.tools = {
       register: (t2) => tr.register(t2, owner),
-      unregister: (name) => tr.unregister(name),
-      wrap: (name, wrapper) => tr.wrap(name, wrapper, owner),
+      unregister: (name) => {
+        assertCanMutateTool(name, "unregister");
+        return tr.unregister(name);
+      },
+      wrap: (name, wrapper) => {
+        assertCanMutateTool(name, "wrap");
+        tr.wrap(name, wrapper, owner);
+      },
       get: (name) => tr.get(name),
       list: () => tr.list()
     };
@@ -25296,6 +27337,203 @@ function assertSafePath(dir, projectRoot) {
   }
 }
 
+// src/coordination/collab-bus.ts
+var CollaborationBus = class {
+  pausePromise = null;
+  pauseResolve = null;
+  pausedAtMs = null;
+  pausedBy = null;
+  // ── State queries ──────────────────────────────────────────────────────
+  isPaused() {
+    return this.pausePromise !== null;
+  }
+  getState() {
+    return {
+      paused: this.isPaused(),
+      pausedAt: this.pausedAtMs ? new Date(this.pausedAtMs).toISOString() : null,
+      pausedBy: this.pausedBy
+    };
+  }
+  // ── Pause / resume control ─────────────────────────────────────────────
+  /**
+   * Pause the agent loop. Idempotent: a second `requestPause` while
+   * already paused is a no-op (the original pause wins; we do not
+   * overwrite `pausedBy`). Returns true when the state actually
+   * transitioned, false when it was already paused.
+   */
+  requestPause(byParticipant) {
+    if (this.isPaused()) return false;
+    this.pausedAtMs = Date.now();
+    this.pausedBy = byParticipant;
+    this.pausePromise = new Promise((resolve9) => {
+      this.pauseResolve = resolve9;
+    });
+    return true;
+  }
+  /**
+   * Resume the agent loop. Returns true when the state actually
+   * transitioned from paused → running, false when it was already
+   * running (no-op).
+   */
+  resume() {
+    if (!this.isPaused()) return false;
+    if (this.pauseResolve) this.pauseResolve();
+    this.pausePromise = null;
+    this.pauseResolve = null;
+    this.pausedAtMs = null;
+    this.pausedBy = null;
+    return true;
+  }
+  // ── Wait semantics (consumed by the middleware) ────────────────────────
+  /**
+   * Block until the bus is resumed or the timeout fires. Returns:
+   *   - `true`  → bus was resumed in time
+   *   - `false` → timeout fired; bus was auto-resumed as a side effect
+   *
+   * When `timeoutMs` is `0` the wait is unbounded (the middleware must
+   * be paired with an external AbortSignal in that case — we don't
+   * expose one here to keep the API simple).
+   */
+  async waitForResume(timeoutMs) {
+    if (!this.isPaused()) return true;
+    if (!this.pausePromise) return true;
+    if (timeoutMs === 0) {
+      await this.pausePromise;
+      return true;
+    }
+    let timer;
+    const timeoutPromise = new Promise((resolve9) => {
+      timer = setTimeout(() => resolve9("timeout"), timeoutMs);
+    });
+    const resumedPromise = this.pausePromise.then(() => "resumed");
+    const winner = await Promise.race([resumedPromise, timeoutPromise]);
+    if (timer) clearTimeout(timer);
+    if (winner === "timeout") {
+      this.resume();
+      return false;
+    }
+    return true;
+  }
+  // ── Manual tool-call injection (Phase 4) ─────────────────────────────────
+  //
+  // A controller can ask the agent loop to use a specific tool_result
+  // for a given tool_use_id — bypassing the real tool execution. This
+  // is "I want the agent to think the read returned THIS content" or
+  // "skip the bash call, just give it the answer I typed". The
+  // injection is matched by tool_use_id, consumed once, and discarded.
+  injectionQueue = /* @__PURE__ */ new Map();
+  /**
+   * Queue a manual tool result. The next time the agent's toolCall
+   * pipeline sees a matching `toolUse.id`, the
+   * `collabInjectMiddleware` consumes this entry and replaces the
+   * real tool execution. Returns `false` if an injection for the
+   * same id is already queued (idempotent — first write wins).
+   */
+  injectToolResult(input) {
+    if (this.injectionQueue.has(input.toolUseId)) return false;
+    this.injectionQueue.set(input.toolUseId, input);
+    return true;
+  }
+  /**
+   * Pop an injection from the queue. Returns the payload (and
+   * removes it) if one is pending, or `null` when nothing matches.
+   * Called by the middleware on every tool call.
+   */
+  takeInjection(toolUseId) {
+    const v = this.injectionQueue.get(toolUseId);
+    if (!v) return null;
+    this.injectionQueue.delete(toolUseId);
+    return v;
+  }
+  /** Inspect the queue size (for observability / tests). */
+  pendingInjectionCount() {
+    return this.injectionQueue.size;
+  }
+};
+
+// src/middleware/collab-pause.ts
+function collabPauseMiddleware(bus, opts = {}) {
+  const timeoutMs = opts.defaultTimeoutMs ?? 6e4;
+  const logger = opts.logger;
+  return async function collabPause(payload, next) {
+    if (!bus.isPaused()) {
+      return next();
+    }
+    const state = bus.getState();
+    logger?.debug?.(
+      `collab-pause: tool '${payload.toolUse.name}' blocked \u2014 bus paused by ${state.pausedBy ?? "?"} at ${state.pausedAt ?? "?"}, waiting up to ${timeoutMs}ms for resume`
+    );
+    const resumed = await bus.waitForResume(timeoutMs);
+    if (!resumed) {
+      logger?.warn?.(
+        `collab-pause: timeout after ${timeoutMs}ms \u2014 auto-resuming the bus to unblock the agent loop`
+      );
+    } else {
+      logger?.debug?.(`collab-pause: resumed \u2014 proceeding with tool '${payload.toolUse.name}'`);
+    }
+    return next();
+  };
+}
+function collabInjectMiddleware(bus, opts = {}) {
+  const logger = opts.logger;
+  return async function collabInject(payload, next) {
+    const injected = bus.takeInjection(payload.toolUse.id);
+    if (!injected) {
+      return next();
+    }
+    logger?.debug?.(
+      `collab-inject: tool '${payload.toolUse.name}' (id ${payload.toolUse.id}) \u2014 using controller-injected result (reason: ${injected.reason})`
+    );
+    payload.result = {
+      type: "tool_result",
+      tool_use_id: payload.toolUse.id,
+      content: typeof injected.content === "string" ? injected.content : JSON.stringify(injected.content),
+      is_error: injected.isError
+    };
+  };
+}
+
+// src/replay/replay-provider-runner.ts
+var ReplayProviderRunner = class {
+  constructor(inner, opts) {
+    this.inner = inner;
+    this.opts = opts;
+  }
+  inner;
+  opts;
+  async run(runOpts) {
+    const hash = hashRequest(runOpts.request);
+    const cached = await this.opts.log.lookup(this.opts.sessionId, hash);
+    if (this.opts.mode === "replay") {
+      if (!cached) {
+        this.opts.logger?.warn?.(
+          `replay: no recorded response for hash ${hash} (model ${runOpts.request.model})`
+        );
+        throw new Error(
+          `ReplayProviderRunner: no recorded response for hash ${hash} in session ${this.opts.sessionId}. Either the request changed since recording, or this session has no replay log.`
+        );
+      }
+      this.opts.logger?.debug?.(
+        `replay: served cached response for hash ${hash} (recorded ${cached.ts})`
+      );
+      return cached.response;
+    }
+    if (this.opts.mode === "auto" && cached) {
+      this.opts.logger?.debug?.(
+        `replay: auto-hit hash ${hash}, served cached response`
+      );
+      return cached.response;
+    }
+    const response = await this.inner.run(runOpts);
+    await this.opts.log.record({
+      sessionId: this.opts.sessionId,
+      request: runOpts.request,
+      response
+    });
+    return response;
+  }
+};
+
 // src/plugins/prompts-plugin.ts
 function createPromptsPlugin(opts) {
   let store = null;
@@ -25442,9 +27680,12 @@ function dim2(s) {
 }
 
 // src/plugins/sync-plugin.ts
+init_atomic_write();
 function createSyncPlugin(opts) {
   let cloud = null;
   let configStore;
+  let vault;
+  let syncConfigPath;
   return {
     name: "wstack-sync",
     version: "1.0.0",
@@ -25456,6 +27697,8 @@ function createSyncPlugin(opts) {
       const rawConfig = api.config;
       const paths = opts?.paths ?? rawConfig.paths;
       configStore = opts?.configStore ?? rawConfig.configStore;
+      vault = opts?.vault ?? rawConfig.vault;
+      syncConfigPath = paths?.syncConfig;
       if (!paths || !configStore) {
         api.log.warn("[sync] paths or configStore not available \u2014 /sync disabled");
         return;
@@ -25471,7 +27714,7 @@ function createSyncPlugin(opts) {
         }
       );
       void cloud.loadState();
-      api.slashCommands.register(buildSyncCommand(cloud, configStore));
+      api.slashCommands.register(buildSyncCommand(cloud, configStore, vault, syncConfigPath));
       api.log.info("[sync] loaded \u2014 /sync available. Run /sync to get started.");
     },
     teardown(api) {
@@ -25483,7 +27726,7 @@ function createSyncPlugin(opts) {
     }
   };
 }
-function buildSyncCommand(cloud, configStore) {
+function buildSyncCommand(cloud, configStore, vault, syncConfigPath) {
   return {
     name: "sync",
     description: "Cloud sync: /sync [status|enable|disable|push|pull|categories]",
@@ -25511,13 +27754,17 @@ function buildSyncCommand(cloud, configStore) {
           if (!repo || !repo.includes("/")) {
             return { message: 'Invalid repo format. Expected "owner/repo".' };
           }
+          const storedToken = vault ? vault.encrypt(token) : token;
           const syncConfig = {
             enabled: true,
             repo,
-            githubToken: token,
+            githubToken: storedToken,
             categories: cats.length > 0 ? cats : ALL_SYNC_CATEGORIES,
             lastSyncedAt: void 0
           };
+          if (syncConfigPath) {
+            await atomicWrite(syncConfigPath, JSON.stringify(syncConfig, null, 2), { mode: 384 });
+          }
           configStore.update({ sync: syncConfig });
           await cloud.loadState();
           return {
@@ -26344,6 +28591,6 @@ ${formatPlan(updated)}`
   };
 }
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, CloudSync, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeLLMClassifier, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionRecovery, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, hashRequest, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map