@wrongstack/core 0.308.6 → 0.309.0

package/dist/index.js

@@ -1171,7 +1171,7 @@ __export(review_report_store_exports, {
   REPORT_STORE_FILE: () => REPORT_STORE_FILE,
   resolveReportStorePath: () => resolveReportStorePath
 });
-import { randomUUID as randomUUID30 } from "node:crypto";
+import { randomUUID as randomUUID32 } from "node:crypto";
 import * as fsp35 from "node:fs/promises";
 import * as path76 from "node:path";
 function resolveReportStorePath(projectDir) {
@@ -1238,7 +1238,7 @@ var init_review_report_store = __esm({
             ...input.evidenceChecks !== void 0 ? { evidenceChecks: input.evidenceChecks } : {}
           };
           const createdEvent = {
-            id: randomUUID30(),
+            id: randomUUID32(),
             reportId: report.id,
             eventType: "created",
             fromLifecycle: null,
@@ -1261,7 +1261,7 @@ var init_review_report_store = __esm({
           const from = this._materialize(entry).lifecycle;
           validateReportTransition(from, to);
           const event = {
-            id: randomUUID30(),
+            id: randomUUID32(),
             reportId,
             eventType: reportEventTypeFor(to),
             fromLifecycle: from,
@@ -1304,7 +1304,7 @@ var init_review_report_store = __esm({
           if (!entry) throw new Error(`Review report not found: ${reportId}`);
           const materialized = this._materialize(entry);
           const event = {
-            id: randomUUID30(),
+            id: randomUUID32(),
             reportId,
             eventType: "note_added",
             fromLifecycle: materialized.lifecycle,
@@ -1527,7 +1527,7 @@ __export(review_finding_store_exports, {
   JsonlFindingStore: () => JsonlFindingStore,
   resolveFindingStorePath: () => resolveFindingStorePath
 });
-import { randomUUID as randomUUID40 } from "node:crypto";
+import { randomUUID as randomUUID42 } from "node:crypto";
 import * as fsp48 from "node:fs/promises";
 import * as path105 from "node:path";
 function resolveFindingStorePath(projectDir) {
@@ -1616,7 +1616,7 @@ var init_review_finding_store = __esm({
           validateTransition(from, to);
           validateResolution(to, opts?.outcome);
           const event = {
-            id: randomUUID40(),
+            id: randomUUID42(),
             findingId,
             eventType: to === "resolved" ? "resolved" : to === "ignored" ? "ignored" : this._eventTypeFor(to),
             fromStatus: from,
@@ -1800,7 +1800,7 @@ var init_review_finding_store = __esm({
       }
       _makeEvent(findingId, eventType, fromStatus, toStatus, context) {
         return {
-          id: randomUUID40(),
+          id: randomUUID42(),
           findingId,
           eventType,
           fromStatus,
@@ -19762,9 +19762,68 @@ function resourceId3(kind, value) {
   return `${kind}_${createHash17("sha256").update(value).digest("hex").slice(0, 24)}`;
 }
 
+// src/core/btw.ts
+var META_KEY2 = "_btwNotes";
+var MAX_PENDING = 20;
+function readQueue(ctx) {
+  const raw = ctx.meta[META_KEY2];
+  return Array.isArray(raw) ? raw : [];
+}
+function setBtwNote(ctx, text2) {
+  const trimmed = text2.trim();
+  if (!trimmed) return readQueue(ctx).length;
+  const next = [...readQueue(ctx), trimmed].slice(-MAX_PENDING);
+  ctx.meta[META_KEY2] = next;
+  return next.length;
+}
+function pendingBtwCount(ctx) {
+  return readQueue(ctx).length;
+}
+function consumeBtwNotes(ctx) {
+  const notes = readQueue(ctx);
+  if (notes.length > 0) delete ctx.meta[META_KEY2];
+  return notes;
+}
+function buildBtwBlock(notes) {
+  const body = notes.map((n) => `- ${n}`).join("\n");
+  return [
+    "[BY THE WAY \u2014 the user added this while you were working. Fold it into",
+    "your current task; do not restart from scratch unless it contradicts the",
+    "goal:",
+    "",
+    body,
+    "]"
+  ].join("\n");
+}
+
 // src/coordination/agent-subagent-runner.ts
 init_errors();
 
+// src/coordination/subagent-finish.ts
+var SUBAGENT_FINISH_REQUESTED_EVENT = "subagent.finish_requested";
+var DEFAULT_SUBAGENT_FINISH_GRACE_MS = 12e4;
+function resolveGracefulFinish(config) {
+  const raw = config.gracefulFinish;
+  if (raw === void 0 || raw === false) return void 0;
+  if (raw === true) return { graceMs: DEFAULT_SUBAGENT_FINISH_GRACE_MS };
+  const graceMs = typeof raw.graceMs === "number" && Number.isFinite(raw.graceMs) && raw.graceMs > 0 ? Math.floor(raw.graceMs) : DEFAULT_SUBAGENT_FINISH_GRACE_MS;
+  return { graceMs };
+}
+function buildSubagentFinishNotice(input) {
+  const localTime = new Date(input.deadlineMs).toISOString();
+  const seconds = Math.max(1, Math.round(input.graceMs / 1e3));
+  const timeLeft = input.graceMs > 0 ? `You have roughly ${seconds} seconds (until ${localTime}) of legitimate working time left.` : `Your working-time window is already spent (deadline was ${localTime}) \u2014 finish now.`;
+  return [
+    "[SUBAGENT FINISH] The leader agent has finished its work.",
+    `Reason: ${input.reason}`,
+    timeLeft,
+    "Finish your task now, in this turn: complete the thought you are working on, stop",
+    "starting new tool calls unless one is strictly required to finish, and write your",
+    "final answer or report as your final output, then end your turn.",
+    "Do not restart the task and do not begin new work."
+  ].join("\n");
+}
+
 // src/coordination/subagent-budget.ts
 var TIMEOUT_PREEMPT_FRACTION = 0.85;
 var DECISION_TIMEOUT_MS = 6e4;
@@ -19822,6 +19881,82 @@ var SubagentBudget = class _SubagentBudget {
       this.limits.idleTimeoutMs = ext.idleTimeoutMs;
     }
   }
+  /**
+   * Graceful-finish state (see coordination/subagent-finish.ts).
+   * `_finishNotified` guards the single in-band emission; `_grace` records a
+   * granted working-time extension past the original wall-clock deadline.
+   * They are separate because the two callers want different semantics:
+   * the watchdog grants grace at the deadline crossing (notify + extend),
+   * while an explicit leader-finished request only notifies — a subagent
+   * well inside its budget keeps its full legitimate working time and simply
+   * accelerates.
+   */
+  _finishNotified = false;
+  _grace = null;
+  /** True once the in-band finish notification has been emitted. */
+  get finishNotified() {
+    return this._finishNotified;
+  }
+  /** True once a grace window has been granted past the original deadline. */
+  get graceGranted() {
+    return this._grace !== null;
+  }
+  /**
+   * Notify the subagent in-band to finish its task in its own turn:
+   * `subagent.finish_requested` is emitted on the wired EventBus and the
+   * agent loop folds the notice into the conversation between tool batches.
+   * Nothing aborts — this is a notification, never an interrupt.
+   *
+   * `opts.graceMs` additionally extends the wall-clock ceiling by that window
+   * (used by the watchdog at a deadline crossing, so the model gets working
+   * time instead of a kill). Omit it to notify without touching the budget —
+   * the subagent keeps its existing time budget and just accelerates.
+   *
+   * Returns `true` when this call did something (emitted the notification
+   * and/or granted grace); `false` when there was nothing to do (already
+   * notified, grace already granted, no EventBus wired, budget not started).
+   */
+  notifyFinish(reason, opts, now = Date.now) {
+    if (!this._events) return false;
+    if (this.startTime === null) return false;
+    const shouldEmit = !this._finishNotified;
+    const rawGrace = opts?.graceMs;
+    const shouldGrant = rawGrace !== void 0 && this._grace === null;
+    if (!shouldEmit && !shouldGrant) return false;
+    let grantedGraceMs = 0;
+    let graceDeadlineMs;
+    if (shouldGrant && rawGrace !== void 0) {
+      grantedGraceMs = Number.isFinite(rawGrace) && rawGrace > 0 ? Math.floor(rawGrace) : DEFAULT_SUBAGENT_FINISH_GRACE_MS;
+      graceDeadlineMs = now() + grantedGraceMs;
+      this._grace = { deadlineMs: graceDeadlineMs, graceMs: grantedGraceMs };
+      this.patchLimits({ timeoutMs: graceDeadlineMs - this.startTime });
+    }
+    if (shouldEmit) {
+      this._finishNotified = true;
+      const effectiveDeadlineMs = graceDeadlineMs ?? (this.limits.timeoutMs !== void 0 ? this.startTime + this.limits.timeoutMs : now() + DEFAULT_SUBAGENT_FINISH_GRACE_MS);
+      const effectiveGraceMs = Math.max(0, effectiveDeadlineMs - now());
+      const subagentId = this._subagentId;
+      this._events.emit(SUBAGENT_FINISH_REQUESTED_EVENT, {
+        // Omitted entirely when the budget was built without an id — an
+        // empty string is an address that matches nothing.
+        ...subagentId !== void 0 ? { subagentId } : {},
+        reason,
+        deadlineMs: effectiveDeadlineMs,
+        graceMs: effectiveGraceMs,
+        notice: buildSubagentFinishNotice({
+          reason,
+          deadlineMs: effectiveDeadlineMs,
+          graceMs: effectiveGraceMs
+        })
+      });
+    }
+    return true;
+  }
+  /** Epoch ms by which the subagent should have produced its final output,
+   *  once a grace window was granted. Undefined before that. */
+  get finishDeadlineMs() {
+    return this._grace?.deadlineMs;
+  }
   iterations = 0;
   toolCalls = 0;
   tokenInput = 0;
@@ -19837,6 +19972,10 @@ var SubagentBudget = class _SubagentBudget {
   lastActivityTime = null;
   _onThreshold;
   _sessionId;
+  /** Owning subagent id — used to address the graceful-finish event. */
+  _subagentId;
+  /** True when only the coordinator watchdog may enforce wall-clock limits. */
+  _wallClockWatchdogOwned;
   /**
    * Hard cap on how long `_negotiateExtension` waits for the coordinator to
    * respond before defaulting to 'stop'. Without this fallback an absent
@@ -19908,6 +20047,8 @@ var SubagentBudget = class _SubagentBudget {
   constructor(limits = {}, mode = "auto", options = {}) {
     this._mode = mode;
     this._sessionId = options.sessionId;
+    this._subagentId = options.subagentId;
+    this._wallClockWatchdogOwned = options.wallClockWatchdogOwned === true;
     this.limits = { ...limits };
   }
   currentSessionId() {
@@ -19986,7 +20127,7 @@ var SubagentBudget = class _SubagentBudget {
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
         exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
       }
-      const wallOwnedByWatchdog = this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
+      const wallOwnedByWatchdog = this._wallClockWatchdogOwned || this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
       if (this.limits.timeoutMs !== void 0 && elapsedMs2 > this.limits.timeoutMs && !wallOwnedByWatchdog) {
         exceeded.push({ kind: "timeout", used: elapsedMs2, limit: this.limits.timeoutMs });
       }
@@ -20185,7 +20326,7 @@ var SubagentBudget = class _SubagentBudget {
     if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed2 = Date.now() - this.startTime;
     const wallSkipped = this._onThreshold !== void 0 && this._watchdogActive !== void 0 && timeoutMs !== void 0 && this._watchdogActive === timeoutMs;
-    const wallTripped = wallSkipped ? false : timeoutMs !== void 0 && elapsed2 > timeoutMs;
+    const wallTripped = this._wallClockWatchdogOwned || wallSkipped ? false : timeoutMs !== void 0 && elapsed2 > timeoutMs;
     const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
     if (!wallTripped && !idleTripped) return;
     void this.checkLimits(elapsed2);
@@ -20666,6 +20807,14 @@ function makeAgentSubagentRunner(opts) {
     );
     const onParentAbort = () => aborter.abort();
     ctx.signal.addEventListener("abort", onParentAbort);
+    if (resolveGracefulFinish(ctx.config)) {
+      unsub.push(
+        events.on("subagent.finish_requested", (e) => {
+          if (e.subagentId && e.subagentId !== ctx.subagentId) return;
+          setBtwNote(agent.ctx, e.notice);
+        })
+      );
+    }
     let result;
     try {
       result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
@@ -21958,6 +22107,7 @@ function createProjectAgent(input, projectRoot) {
 var skillSet = (...names) => names;
 var ROLE_SKILL_SETS = {
   explore: skillSet("research-web", "node-modern", "typescript-strict"),
+  "explore-companion": skillSet("node-modern", "typescript-strict"),
   search: skillSet("bug-hunter", "typescript-strict", "research-web"),
   research: skillSet("research-web", "tech-stack", "security-scanner", "api-design"),
   analyst: skillSet("sdd", "api-design", "testing", "security-scanner"),
@@ -29006,7 +29156,7 @@ function attachDepWatcherBridge(opts) {
 }
 
 // src/coordination/director.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import * as fsp30 from "node:fs/promises";
 
 // src/storage/director-state.ts
@@ -30901,7 +31051,7 @@ ${JSON.stringify(result.result, null, 2)}
 };
 
 // src/coordination/director-tools.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import {
   completeKanbanDispatch,
   failKanbanDispatch,
@@ -30996,7 +31146,7 @@ function buildKanbanFleetTaskPrompt(board, task, lease) {
   const dependencyLines = (task.dependsOn ?? []).map((depId) => board.tasks.find((candidate) => candidate.id === depId)).filter((dep) => Boolean(dep)).map((dep) => `- ${dep.title} [${dep.status}] (${dep.id})`);
   const checks = task.successCriteria?.map((check) => `- ${check.description}`).join("\n");
   const metrics = task.goalMetrics?.map(
-    (metric) => `- ${metric.name}: ${metric.current ?? "n/a"}${metric.target !== void 0 ? ` / ${metric.target}` : ""}${metric.unit ? ` ${metric.unit}` : ""} [${metric.status}]`
+    (metric) => `- ${metric.name}: ${metric.current ?? "n/a"}${metric.target !== void 0 ? ` / ${metric.direction === "at_most" ? "\u2264" : "\u2265"} ${metric.target}` : ""}${metric.unit ? ` ${metric.unit}` : ""} [${metric.status}]`
   ).join("\n");
   const chain = task.chain ? [
     `chainId: ${task.chain.chainId}`,
@@ -32135,6 +32285,413 @@ function excerpt(text2, max) {
 ...(truncated)`;
 }
 
+// src/coordination/director-mutation-test-tool.ts
+import { randomUUID as randomUUID14 } from "node:crypto";
+import { readFileSync as readFileSync19 } from "node:fs";
+import { isAbsolute as isAbsolute9, join as join40 } from "node:path";
+
+// src/coordination/mutation-engine.ts
+var TOKEN_PATTERNS = [
+  {
+    kind: "relax-boundary",
+    // `>` not followed by `=` and not part of `=>` or `>>`; require code-ish
+    // context on both sides so generic text (JSX, strings) is not touched.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>>(?!=|>))/g,
+    replace: () => ">="
+  },
+  {
+    kind: "tighten-boundary",
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>>=)/g,
+    replace: () => ">"
+  },
+  {
+    kind: "arith-plus-to-minus",
+    // `+` between operands (binary), not `++`, unary `+x`, or `+=`.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>\+(?!\+|=))/g,
+    replace: () => "-"
+  },
+  {
+    kind: "arith-minus-to-plus",
+    // Binary `-` between operands, not `--`, `-=` or negative-number literal.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>-(?!-|=))/g,
+    replace: () => "+"
+  },
+  {
+    kind: "negate-boolean",
+    // Standalone boolean literals used as values, not property names.
+    regex: /(?<![.\w$])(?<op>true|false)(?![\w$])/g,
+    replace: (m) => m === "true" ? "false" : "true"
+  },
+  {
+    kind: "return-null",
+    // `return <expr>;` where expr is not already null/undefined/void.
+    regex: /(?<indent>\breturn\b)(?<expr>\s+[^;{}\n]+?)\s*;/g,
+    replace: () => "return null;"
+  }
+];
+function planMutations(file, source, opts = {}) {
+  const maxPerFile = opts.maxPerFile ?? 25;
+  const out = [];
+  const lines = source.split("\n");
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const line = lines[lineIdx];
+    const t2 = line.trim();
+    if (t2.startsWith("//") || t2.startsWith("*") || t2.startsWith("/*")) continue;
+    for (const pattern of TOKEN_PATTERNS) {
+      pattern.regex.lastIndex = 0;
+      let m;
+      while ((m = pattern.regex.exec(line)) !== null) {
+        const token = m.groups?.["op"] ?? m[0];
+        const tokenStart = m.index + m[0].indexOf(token);
+        if (isMasked(line, tokenStart, token.length)) continue;
+        const original = line.slice(tokenStart, tokenStart + token.length);
+        const replacement = pattern.replace(token);
+        if (replacement === original) continue;
+        out.push({
+          id: `${pattern.kind}#${lineIdx + 1}#${tokenStart + 1}`,
+          kind: pattern.kind,
+          file,
+          line: lineIdx + 1,
+          column: tokenStart + 1,
+          original,
+          replacement
+        });
+      }
+    }
+    if (out.length >= maxPerFile) break;
+  }
+  return out.slice(0, maxPerFile);
+}
+function isMasked(line, start, len) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < start; i++) {
+    const c = line[i];
+    const prev = i > 0 ? line[i - 1] : void 0;
+    if (c === "'" && prev !== "\\") inSingle = !inSingle;
+    else if (c === '"' && prev !== "\\") inDouble = !inDouble;
+    if (!inSingle && !inDouble && c === "/" && prev === "/") return true;
+  }
+  if (inSingle || inDouble) return true;
+  const window = line.slice(start, start + len);
+  return /['"]/.test(window);
+}
+function parseMutationReport(text2) {
+  const candidates = [];
+  const fence = text2.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fence?.[1]) candidates.push(fence[1].trim());
+  const firstBrace = text2.indexOf("{");
+  if (firstBrace >= 0) candidates.push(extractBalancedObject(text2, firstBrace));
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      const parsed = JSON.parse(candidate);
+      if (!Array.isArray(parsed.mutants)) continue;
+      return {
+        mutants: parsed.mutants.map(normalizeMutantEntry).filter((x) => Boolean(x)),
+        summary: typeof parsed.summary === "string" ? parsed.summary : void 0
+      };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function extractBalancedObject(text2, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text2.length; i++) {
+    const c = text2[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (c === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (c === '"') inString = !inString;
+    if (inString) continue;
+    if (c === "{") depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) return text2.slice(start, i + 1);
+    }
+  }
+  return text2.slice(start);
+}
+function normalizeMutantEntry(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const rec = value;
+  const id = typeof rec["id"] === "string" ? rec["id"] : void 0;
+  const status = rec["status"];
+  if (!id || status !== "killed" && status !== "survived" && status !== "skipped") {
+    return void 0;
+  }
+  return {
+    id,
+    file: typeof rec["file"] === "string" ? rec["file"] : "",
+    line: typeof rec["line"] === "number" ? rec["line"] : 0,
+    kind: typeof rec["kind"] === "string" ? rec["kind"] : "",
+    status,
+    evidence: typeof rec["evidence"] === "string" ? rec["evidence"] : void 0
+  };
+}
+
+// src/coordination/director-mutation-test-tool.ts
+var DEFAULT_MAX_PER_FILE = 10;
+var DEFAULT_MAX_STRENGTHEN_ATTEMPTS = 2;
+var CHAOS_ROLE = "chaos-monkey";
+function makeMutationTestTool(director, roster, opts = {}) {
+  return {
+    name: "mutation_test",
+    description: "Chaos Monkey mutation testing: deterministically sabotage boundary conditions in the target code (> to >=, + to -, boolean flips, return null), re-run the tests per mutant, and report which mutants were killed. Surviving mutants mean the tests are weak \u2014 optionally loop a strengthen-tests repair until they die.",
+    usageHint: "Use after writing new code AND its tests, before delivering. Pass targets (files) and testCommand. Provide repairSubagentId to auto-strengthen weak tests. Survivors that persist are reported as suspected-equivalent.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema: {
+      type: "object",
+      properties: {
+        targets: {
+          type: "array",
+          items: { type: "string" },
+          description: "Project-relative (or absolute) source files to mutate. Keep to files changed by the current task."
+        },
+        testCommand: {
+          type: "string",
+          description: 'Exact command that runs the relevant tests, e.g. "pnpm exec vitest run packages/core/tests/coordination/mutation-engine.test.ts".'
+        },
+        cwd: { type: "string", description: "Working directory for the test command." },
+        maxPerFile: {
+          type: "number",
+          minimum: 1,
+          maximum: 25,
+          description: "Mutant cap per file per pass. Default 10."
+        },
+        maxStrengthenAttempts: {
+          type: "number",
+          minimum: 0,
+          maximum: 5,
+          description: "Strengthen\u2192re-verify rounds. Default 2 when repairSubagentId is set, else 0."
+        },
+        repairSubagentId: {
+          type: "string",
+          description: "Subagent that owns the tests. When set and mutants survive, it receives a strengthen-tests task and the survivors are re-verified."
+        },
+        chaosWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Worktree override for the chaos agent. Use 'off' when targets are uncommitted \u2014 a worktree from HEAD would not contain them."
+        },
+        timeoutMs: { type: "number", minimum: 1, description: "Per-task timeout for chaos/strengthen/rerun tasks." },
+        reportOnly: {
+          type: "boolean",
+          description: "Skip the strengthen loop even when survivors exist. Default false."
+        }
+      },
+      required: ["targets", "testCommand"],
+      additionalProperties: false
+    },
+    async execute(input, ctx) {
+      const i = normalizeMutationTestInput(input);
+      const root = opts.projectRoot ?? ctx.projectRoot;
+      const plan = buildPlan(i, root);
+      if (plan.length === 0) {
+        return {
+          verdict: "inconclusive",
+          passed: false,
+          error: "No mutable sites found in the given targets (after comment/string filtering)."
+        };
+      }
+      const chaosSubagentId = await director.spawn(
+        makeChaosConfig(roster, i.chaosWorktree ?? "off")
+      );
+      const chaosTaskId = await director.assign({
+        id: randomUUID14(),
+        subagentId: chaosSubagentId,
+        description: buildChaosTask(plan, i, 1, []),
+        timeoutMs: i.timeoutMs
+      });
+      const [chaosResult] = await director.awaitTasks([chaosTaskId]);
+      const pass1 = collectOutcomes(chaosResult, plan);
+      const survivors = pass1.filter((m) => m.status === "survived");
+      const maxAttempts = clamp(
+        i.maxStrengthenAttempts ?? (i.repairSubagentId && !i.reportOnly ? DEFAULT_MAX_STRENGTHEN_ATTEMPTS : 0),
+        0,
+        5
+      );
+      const attempts = [];
+      let current = survivors;
+      while (current.length > 0 && attempts.length < maxAttempts && i.repairSubagentId) {
+        const attemptNo = attempts.length + 1;
+        const strengthenTaskId = await director.assign({
+          id: randomUUID14(),
+          subagentId: i.repairSubagentId,
+          description: buildStrengthenTask(current, i, attemptNo),
+          timeoutMs: i.timeoutMs
+        });
+        const [strengthenResult] = await director.awaitTasks([strengthenTaskId]);
+        if (strengthenResult?.status !== "success") {
+          attempts.push({
+            attempt: attemptNo,
+            survivorsBefore: current,
+            strengthenResult: strengthenResult ? { taskId: strengthenResult.taskId, status: strengthenResult.status } : void 0,
+            survivorsAfter: current,
+            suspectedEquivalent: []
+          });
+          break;
+        }
+        const survivorPlan = plan.filter((p) => current.some((s) => s.id === p.id));
+        const rerunSubagentId = await director.spawn(
+          makeChaosConfig(roster, i.chaosWorktree ?? "off")
+        );
+        const rerunTaskId = await director.assign({
+          id: randomUUID14(),
+          subagentId: rerunSubagentId,
+          description: buildChaosTask(survivorPlan, i, attemptNo + 1, current),
+          timeoutMs: i.timeoutMs
+        });
+        const [rerunResult] = await director.awaitTasks([rerunTaskId]);
+        const passN = collectOutcomes(rerunResult, survivorPlan);
+        const stillSurviving = passN.filter((m) => m.status === "survived" || m.status === "skipped");
+        attempts.push({
+          attempt: attemptNo,
+          survivorsBefore: current,
+          strengthenResult: { taskId: strengthenResult.taskId, status: strengthenResult.status },
+          rerunResult: { taskId: rerunTaskId, status: rerunResult?.status ?? "unknown" },
+          survivorsAfter: stillSurviving,
+          suspectedEquivalent: stillSurviving.filter((m) => current.some((c) => c.id === m.id)).map((m) => m.id)
+        });
+        current = stillSurviving.filter((m) => m.status === "survived");
+        if (passN.every((m) => m.status === "skipped")) break;
+      }
+      const finalSurvivors = current;
+      const verifiedCount = pass1.filter((m) => m.status !== "skipped").length;
+      const skippedCount = pass1.filter((m) => m.status === "skipped").length;
+      const score = plan.length === 0 ? 0 : pass1.filter((m) => m.status === "killed").length / plan.length;
+      const verdict = verifiedCount === 0 ? "inconclusive" : finalSurvivors.length === 0 ? skippedCount > 0 ? "partial" : "pass" : score >= 0.8 ? "partial" : "fail";
+      return {
+        verdict,
+        passed: verdict === "pass",
+        mutationScore: Number.parseFloat(score.toFixed(3)),
+        planned: plan.length,
+        killed: pass1.filter((m) => m.status === "killed").length,
+        survived: pass1.filter((m) => m.status === "survived").length,
+        skipped: pass1.filter((m) => m.status === "skipped").length,
+        finalSurvivors: finalSurvivors.map((m) => ({ id: m.id, file: m.file, kind: m.kind })),
+        suspectedEquivalent: attempts.flatMap((a) => a.suspectedEquivalent),
+        strengthenAttempts: attempts.length,
+        attempts,
+        chaosTaskId,
+        nextAction: finalSurvivors.length === 0 ? "accept" : attempts.length >= maxAttempts && i.repairSubagentId ? "manual_review_survivors" : "strengthen_tests"
+      };
+    }
+  };
+}
+function normalizeMutationTestInput(input) {
+  const raw = input ?? {};
+  const targets = stringArray2(raw["targets"]) ?? [];
+  const testCommand = typeof raw["testCommand"] === "string" ? raw["testCommand"].trim() : "";
+  return {
+    targets: targets.filter(Boolean),
+    testCommand,
+    cwd: typeof raw["cwd"] === "string" && raw["cwd"].trim() ? raw["cwd"].trim() : void 0,
+    maxPerFile: typeof raw["maxPerFile"] === "number" ? raw["maxPerFile"] : void 0,
+    maxStrengthenAttempts: typeof raw["maxStrengthenAttempts"] === "number" ? raw["maxStrengthenAttempts"] : void 0,
+    repairSubagentId: typeof raw["repairSubagentId"] === "string" && raw["repairSubagentId"].trim() ? raw["repairSubagentId"].trim() : void 0,
+    chaosWorktree: raw["chaosWorktree"] ?? void 0,
+    timeoutMs: typeof raw["timeoutMs"] === "number" ? raw["timeoutMs"] : void 0,
+    reportOnly: raw["reportOnly"] === true
+  };
+}
+function clamp(n, lo, hi) {
+  return Math.min(hi, Math.max(lo, n));
+}
+function buildPlan(i, projectRoot) {
+  const plan = [];
+  for (const target of i.targets) {
+    const abs = isAbsolute9(target) ? target : join40(projectRoot ?? process.cwd(), target);
+    let source;
+    try {
+      source = readFileSync19(abs, "utf8");
+    } catch {
+      continue;
+    }
+    plan.push(...planMutations(target, source, { maxPerFile: i.maxPerFile ?? DEFAULT_MAX_PER_FILE }));
+  }
+  return plan;
+}
+function makeChaosConfig(roster, worktree) {
+  const base = roster?.[CHAOS_ROLE] ?? getAgentDefinition(CHAOS_ROLE)?.config ?? { name: "Chaos Monkey", role: CHAOS_ROLE };
+  return { ...instantiateRosterConfig(CHAOS_ROLE, base), worktree };
+}
+function buildChaosTask(plan, i, pass, priorSurvivors) {
+  const mutants = plan.map(
+    (m) => `- ${m.id} | ${m.file}:${m.line}:${m.column} | ${m.kind} | "${m.original}" -> "${m.replacement}"`
+  ).join("\n");
+  const prior = priorSurvivors.length > 0 ? `
+These mutants survived a previous pass (pass ${pass - 1}) \u2014 re-verify them against the STRENGTHENED tests:
+${priorSurvivors.map((s) => `- ${s.id} (${s.kind} @ ${s.file}:${s.line})`).join("\n")}` : "";
+  return [
+    "Execute this deterministic mutation plan against the current checkout.",
+    "",
+    "For each mutant, in order:",
+    "1. Apply ONLY that mutation at its exact (file, line, column).",
+    `2. Run the test command: ${i.testCommand}${i.cwd ? ` (cwd: ${i.cwd})` : ""}`,
+    "3. Record killed (tests failed \u2014 quote first failing assertion) or survived (suite green).",
+    "4. Restore the file byte-for-byte before the next mutant.",
+    "",
+    "Mutants:",
+    mutants,
+    prior,
+    "",
+    "Rules: one mutation at a time; never stack; if the anchored token no longer matches, mark skipped with the drift as evidence; do not fix or refactor anything; stay inside the plan.",
+    "Finish with submit_result, then repeat the same JSON as your final text."
+  ].join("\n");
+}
+function buildStrengthenTask(survivors, i, attempt) {
+  return [
+    `Strengthen the tests so these SURVIVING mutants die (attempt ${attempt}).`,
+    "",
+    "Each survivor below was a deliberate sabotage of production code that the current suite did NOT catch:",
+    ...survivors.map((s) => `- ${s.id} | ${s.file}:${s.line} | ${s.kind}${s.evidence ? ` | ${s.evidence}` : ""}`),
+    "",
+    `Test command that must fail under each mutant: ${i.testCommand}`,
+    "",
+    "For each survivor add or tighten exactly one assertion that pins the sabotaged boundary/behavior. Do not change production code. Do not weaken other tests. Run the suite green on clean code before finishing."
+  ].join("\n");
+}
+function collectOutcomes(result, plan) {
+  const fromText = parseTextOutcomes(result);
+  if (fromText.length > 0) {
+    const planned = new Set(plan.map((p) => p.id));
+    const matched = fromText.filter((m) => planned.has(m.id));
+    if (matched.length > 0) return matched;
+  }
+  return plan.map((p) => ({
+    id: p.id,
+    file: p.file,
+    line: p.line,
+    kind: p.kind,
+    status: "skipped",
+    evidence: result ? `chaos task ended ${result.status}` : "chaos task produced no result"
+  }));
+}
+function parseTextOutcomes(result) {
+  const text2 = typeof result?.result === "string" ? result.result : void 0;
+  if (!text2) return [];
+  const parsed = parseMutationReport(text2);
+  if (!parsed) return [];
+  return parsed.mutants.map((m) => ({
+    id: m.id,
+    file: m.file,
+    line: m.line,
+    kind: m.kind,
+    status: m.status,
+    evidence: m.evidence
+  }));
+}
+
 // src/coordination/director-tools.ts
 function makeSpawnTool(director, roster) {
   const dispatchCatalog = () => {
@@ -32427,7 +32984,7 @@ function makeKanbanQueueTool(director, roster) {
         try {
           const config = buildKanbanSubagentConfig(claim.task, i, roster, instantiateRosterConfig);
           subagentId = await director.spawn(config);
-          const dispatchTaskId = randomUUID14();
+          const dispatchTaskId = randomUUID15();
           const taskSpec = {
             id: dispatchTaskId,
             subagentId,
@@ -32703,6 +33260,7 @@ function buildDirectorToolset(director, roster) {
     makeAskResultTool(director),
     makeRollUpTool(director),
     makeQualityGateTool(director, roster),
+    makeMutationTestTool(director, roster),
     makeTerminateTool(director),
     makeTerminateAllTool(director),
     makeFleetTool(director),
@@ -32789,7 +33347,7 @@ import * as fsp29 from "node:fs/promises";
 import * as path63 from "node:path";
 
 // src/storage/session-store.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 import * as fsp28 from "node:fs/promises";
 import * as path62 from "node:path";
 init_client();
@@ -33960,7 +34518,7 @@ var FileSessionWriter = class _FileSessionWriter {
 // src/storage/session-checkpoint-cas.ts
 init_atomic_write();
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash18, randomUUID as randomUUID15 } from "node:crypto";
+import { createHash as createHash18, randomUUID as randomUUID16 } from "node:crypto";
 import * as fsp15 from "node:fs/promises";
 import * as path54 from "node:path";
 init_error();
@@ -34198,7 +34756,7 @@ var SessionCheckpointCas = class {
     }
     const temp = path54.join(
       path54.dirname(target),
-      `.${path54.basename(target)}.${process.pid}.${randomUUID15()}.tmp`
+      `.${path54.basename(target)}.${process.pid}.${randomUUID16()}.tmp`
     );
     let handle;
     try {
@@ -36006,7 +36564,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   onAppend;
   onAppendBatch;
   catalogClient;
-  maintenanceHolderId = randomUUID16();
+  maintenanceHolderId = randomUUID17();
   _loadCache = /* @__PURE__ */ new Map();
   loadCache = new SessionLoadCache(this._loadCache);
   _indexCache = null;
@@ -36698,7 +37256,7 @@ async function readDirectorSubagentSession(args) {
 }
 
 // src/core/fallback-model.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 
 // src/types/provider.ts
 init_errors();
@@ -36708,6 +37266,18 @@ var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not eno
 var ROUTE_SCOPED_QUOTA_RE = /\b(?:for|on)\s+(?:(?:this|the)\s+)?(?:route|model)\b|\b(?:route|model)(?:[-_\s]+[\w.-]+)?[-_\s]*(?:quota|limit)\b|\b(?:quota|limit).{0,24}\b(?:for|on)\s+(?:(?:this|the)\s+)?(?:route|model)\b/i;
 
 // src/types/provider.ts
+var REASONING_EFFORT_LEVELS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function isReasoningEffort(value) {
+  return typeof value === "string" && REASONING_EFFORT_LEVELS.includes(value);
+}
 function effectiveInputTokens(usage) {
   return usage.input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
 }
@@ -37730,7 +38300,7 @@ function createFallbackModelExtension(deps) {
         let gateRequestId;
         const configuredGateSeconds = cfg.fallbackGateSeconds ?? deps.fallbackGateSeconds;
         if (configuredGateSeconds !== 0 && deps.fallbackGate && usableChain.length > 0) {
-          gateRequestId = randomUUID17();
+          gateRequestId = randomUUID18();
           const autoSwitchSeconds = Math.max(1, configuredGateSeconds ?? 7);
           const gateCandidates = usableChain.map((e) => ({
             providerId: e.providerId,
@@ -38702,7 +39272,7 @@ function hashStr(s) {
 }
 
 // src/coordination/multi-agent-coordinator.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 import { EventEmitter as EventEmitter2 } from "node:events";
 
 // src/coordination/coordinator/error-classifier.ts
@@ -38805,6 +39375,42 @@ var SHADOW_AGENT = {
   ...defineAgent("shadow-agent", "Shadow"),
   skillNames: [...SHADOW_AGENT_SKILLS]
 };
+var EXPLORE_COMPANION_AGENT = {
+  ...defineAgent("explore-companion", "Explore Companion"),
+  tools: [...TOOLS.read, ...TOOLS.index],
+  // Read-only, triple-enforced: allowlist has no write/bash, and the
+  // disabled list blocks the escape hatches explicitly.
+  disabledTools: [
+    "write",
+    "edit",
+    "replace",
+    "patch",
+    "bash",
+    "exec",
+    "delegate",
+    "spawn_subagent",
+    "assign_task"
+  ],
+  skillNames: [...ROLE_SKILL_SETS["explore-companion"]],
+  spawnBudgetExempt: true,
+  // Findings travel via mailbox + submit_result, not the leader's stream.
+  textStream: "silent",
+  toolStream: "silent"
+};
+var CHAOS_MONKEY_AGENT = {
+  ...defineAgent("chaos-monkey", "Chaos Monkey"),
+  tools: [...TOOLS.build],
+  skillNames: ["testing", "typescript-strict"],
+  spawnBudgetExempt: true,
+  // Follow fleet worktree policy (NOT 'required'): mutation targets are
+  // often freshly written and uncommitted — a worktree spawned from HEAD
+  // would not contain them and every mutant would drift. Callers pass
+  // `worktree: 'off'` in the mutation_test input for uncommitted targets.
+  worktree: "auto",
+  // Report travels via submit_result + final text, not the leader's stream.
+  textStream: "silent",
+  toolStream: "silent"
+};
 var CRITIC_AGENT = defineAgent("critic", "Critic");
 var GENERIC_AGENT = defineAgent("generic", "Generic Project Agent");
 function withDispatchMetadata(definition) {
@@ -38823,6 +39429,8 @@ var FLEET_ROSTER = {
   critic: CRITIC_AGENT,
   generic: GENERIC_AGENT,
   "shadow-agent": SHADOW_AGENT,
+  "explore-companion": EXPLORE_COMPANION_AGENT,
+  "chaos-monkey": CHAOS_MONKEY_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, withDispatchMetadata(d)])
   )
@@ -38846,6 +39454,23 @@ var FLEET_ROSTER_BUDGETS = {
     maxTokens: 96e3,
     maxCostUsd: 0.5
   },
+  "explore-companion": {
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: 3e3,
+    maxToolCalls: 8e3,
+    maxTokens: 96e3,
+    maxCostUsd: 0.5
+  },
+  "chaos-monkey": {
+    // A mutation pass is many short apply/run/restore cycles — per-mutant
+    // work is tiny, but a large plan (25 mutants/file × N files) needs
+    // headroom. Idle-based reaping covers a stalled pass.
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: 2e3,
+    maxToolCalls: 6e3,
+    maxTokens: 96e3,
+    maxCostUsd: 0.5
+  },
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
   )
@@ -38908,7 +39533,8 @@ async function executeSubagentWithTimeout({
   budget,
   preemptFraction = TIMEOUT_PREEMPT_FRACTION,
   abortSubagent,
-  currentSessionId
+  currentSessionId,
+  gracefulFinish
 }) {
   const initialTimeoutMs = budget.limits.timeoutMs;
   const idleLimitMs = budget.limits.idleTimeoutMs;
@@ -38939,9 +39565,17 @@ async function executeSubagentWithTimeout({
     const scheduleNext = () => {
       const wallLimit = budget.limits.timeoutMs ?? initialTimeoutMs;
       const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : wallLimit - (Date.now() - start);
-      const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
-      const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
-      armFor(Math.max(25, Math.min(wallRemaining, idleRemaining, preemptRemaining)));
+      const idleRemaining = idleLimitMs === void 0 || gracefulFinish !== void 0 && initialTimeoutMs !== void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
+      const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit || gracefulFinish !== void 0 ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
+      const next = Math.min(wallRemaining, idleRemaining, preemptRemaining);
+      if (!Number.isFinite(next)) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        return;
+      }
+      armFor(Math.max(25, next));
     };
     const negotiateTimeout = async (used, limit) => {
       const handler = budget.onThreshold;
@@ -38990,6 +39624,10 @@ async function executeSubagentWithTimeout({
       const wallExceeded = wallLimit !== void 0 && elapsed2 >= wallLimit;
       const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
       if (idleExceeded && !wallExceeded) {
+        if (gracefulFinish !== void 0 && initialTimeoutMs !== void 0) {
+          scheduleNext();
+          return;
+        }
         const sessionId = currentSessionId();
         budget._events?.emit("budget.threshold_reached", {
           ...sessionId ? { sessionId } : {},
@@ -39006,7 +39644,7 @@ async function executeSubagentWithTimeout({
         reject(new BudgetExceededError("idle_timeout", idleLimit ?? 0, budget.idleMs()));
         return;
       }
-      if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed2 >= wallLimit * preemptFraction) {
+      if (wallLimit !== void 0 && !wallExceeded && gracefulFinish === void 0 && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed2 >= wallLimit * preemptFraction) {
         const activityTs = Date.now() - budget.idleMs();
         if (activityTs <= lastGrantActivityTs) {
           preemptState = "locked" /* LOCKED */;
@@ -39040,6 +39678,22 @@ async function executeSubagentWithTimeout({
         return;
       }
       const limit = wallLimit ?? 0;
+      if (gracefulFinish !== void 0) {
+        if (!budget.graceGranted) {
+          const reason = `wall-clock budget of ${Math.round(limit / 1e3)}s reached`;
+          if (budget.notifyFinish(reason, { graceMs: gracefulFinish.graceMs })) {
+            scheduleNext();
+            return;
+          }
+          abortSubagent(ctx.subagentId);
+          reject(new BudgetExceededError("timeout", limit, elapsed2));
+          return;
+        } else {
+          abortSubagent(ctx.subagentId);
+          reject(new BudgetExceededError("timeout", limit, elapsed2));
+          return;
+        }
+      }
       if (!budget.onThreshold) {
         abortSubagent(ctx.subagentId);
         reject(new BudgetExceededError("timeout", limit, elapsed2));
@@ -39187,7 +39841,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     return { ...subagent, name: display };
   }
   async spawn(subagent) {
-    const id = subagent.id || randomUUID18();
+    const id = subagent.id || randomUUID19();
     const cfg = this.withNickname(subagent, id);
     if (this.subagents.has(id)) {
       throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
@@ -39424,6 +40078,32 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   completeTask(result) {
     this.recordCompletion(result);
   }
+  /**
+   * Ask every RUNNING subagent that opted into `gracefulFinish` to finish its
+   * task in its own turn (see coordination/subagent-finish.ts). This is the
+   * leader-side entry point for "the leader agent has finished": it delivers
+   * an in-band notification between tool batches — never an interrupt, never
+   * an abort. Each notified subagent keeps its existing time budget and
+   * accelerates; the watchdog still bounds the maximum lifetime.
+   *
+   * Subagents without the policy opted in are deliberately untouched — their
+   * lifecycle remains the legacy watchdog contract.
+   *
+   * Returns the number of subagents actually notified.
+   */
+  requestFinish(reason) {
+    let notified = 0;
+    for (const subagent of this.subagents.values()) {
+      if (subagent.status !== "running") continue;
+      if (!resolveGracefulFinish(subagent.config)) continue;
+      const budget = subagent.activeBudget;
+      if (!budget) continue;
+      const usage = budget.usage();
+      if (usage.iterations === 0 && usage.toolCalls === 0) continue;
+      if (budget.notifyFinish(reason)) notified++;
+    }
+    return notified;
+  }
   // --- internal dispatching ---------------------------------------------
   tryDispatchNext() {
     while (this.canDispatch()) {
@@ -39597,7 +40277,14 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         idleTimeoutMs: rawIdleTimeoutMs ?? this.config.defaultBudget?.idleTimeoutMs ?? configWithRosterDefaults.idleTimeoutMs
       },
       "auto",
-      { sessionId: () => this.currentSessionId() }
+      {
+        sessionId: () => this.currentSessionId(),
+        subagentId,
+        // Graceful-finish runs own wall-clock enforcement to the watchdog so
+        // the notify-then-bound lifecycle cannot be raced by tool.progress
+        // heartbeats calling checkTimeout() (see subagent-budget.ts).
+        ...resolveGracefulFinish(subagent.config) ? { wallClockWatchdogOwned: true } : {}
+      }
     );
     subagent.activeBudget = budget;
     if (!this.runner) {
@@ -39630,7 +40317,8 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         task,
         runCtx,
         budget,
-        subagent.config.preemptFraction
+        subagent.config.preemptFraction,
+        resolveGracefulFinish(subagent.config)
       );
       result = {
         subagentId,
@@ -39660,13 +40348,14 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     this.recordCompletion(result);
   }
-  async executeWithTimeout(runner, task, ctx, budget, preemptFraction) {
+  async executeWithTimeout(runner, task, ctx, budget, preemptFraction, gracefulFinish) {
     return executeSubagentWithTimeout({
       runner,
       task,
       ctx,
       budget,
       preemptFraction,
+      gracefulFinish,
       abortSubagent: (subagentId) => this.subagents.get(subagentId)?.abortController.abort(),
       currentSessionId: () => this.currentSessionId()
     });
@@ -40073,7 +40762,7 @@ var Director = class _Director {
   sessionProvider;
   sessionModel;
   constructor(opts) {
-    this.id = opts.config.coordinatorId || randomUUID19();
+    this.id = opts.config.coordinatorId || randomUUID20();
     this.manifestPath = opts.manifestPath;
     this.roster = opts.roster;
     this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
@@ -40280,6 +40969,17 @@ var Director = class _Director {
   isWorkComplete() {
     return this.workCompleteFlag;
   }
+  /**
+   * Ask every running background subagent that opted into `gracefulFinish`
+   * to finish its task in its own turn. In-band notification between tool
+   * batches — no interrupt, no abort; each subagent keeps its time budget and
+   * accelerates. Session shutdown calls this before draining Chimera work so
+   * the post-session reviewer is nudged to complete rather than killed.
+   * Returns the number of subagents notified.
+   */
+  requestFinish(reason) {
+    return this.coordinator.requestFinish(reason);
+  }
   setLeaderBtwNote(note) {
     return this.btwNotes.add(note);
   }
@@ -40356,7 +41056,7 @@ var Director = class _Director {
       );
     }
     const msg = {
-      id: randomUUID19(),
+      id: randomUUID20(),
       type: "task",
       from: this.id,
       to: subagentId,
@@ -40610,7 +41310,7 @@ var Director = class _Director {
 };
 
 // src/coordination/fleet-manager.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 import * as fsp31 from "node:fs/promises";
 import * as path64 from "node:path";
 init_atomic_write();
@@ -40678,7 +41378,7 @@ var FleetManager = class {
   maxContext;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
-    this.directorRunId = opts.directorRunId ?? randomUUID20();
+    this.directorRunId = opts.directorRunId ?? randomUUID21();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = resolveMaxSpawnDepth(opts.maxSpawnDepth);
     this.spawnDepth = opts.spawnDepth ?? 0;
@@ -42730,7 +43430,7 @@ function makeFleetStatusTool(opts = {}) {
 }
 
 // src/coordination/fleet-supervisor.ts
-import { randomUUID as randomUUID21 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 var COLLAB_ID_PREFIXES2 = ["bug-hunter-", "refactor-planner-", "critic-"];
 var DEFAULTS = {
   intervalMs: 2e4,
@@ -43008,7 +43708,7 @@ var FleetSupervisor = class {
    */
   async decide(question, context, options, risk) {
     const request = {
-      id: `fleetsup-${randomUUID21()}`,
+      id: `fleetsup-${randomUUID22()}`,
       sessionId: this.opts.sessionId?.(),
       source: "system",
       question,
@@ -43404,7 +44104,7 @@ function attachAutoExtend(events, policy = {}) {
 }
 
 // src/coordination/delegate-tool.ts
-import { randomUUID as randomUUID22 } from "node:crypto";
+import { randomUUID as randomUUID23 } from "node:crypto";
 import * as fsp32 from "node:fs/promises";
 import * as path69 from "node:path";
 init_error();
@@ -43611,7 +44311,7 @@ function createDelegateTool(opts) {
           }
           const description = delegatedTask;
           const taskId = await dir.assign({
-            id: randomUUID22(),
+            id: randomUUID23(),
             description,
             subagentId
           });
@@ -43832,7 +44532,7 @@ async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abo
 function freshHandoffConfig(cfg, role, handoffCount) {
   return {
     ...cfg,
-    id: role ? `${role}-${randomUUID22().slice(0, 8)}` : `${cfg.name.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "subagent"}-handoff-${handoffCount}-${randomUUID22().slice(0, 6)}`
+    id: role ? `${role}-${randomUUID23().slice(0, 8)}` : `${cfg.name.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "subagent"}-handoff-${handoffCount}-${randomUUID23().slice(0, 6)}`
   };
 }
 function continuationFor(result, partial, config) {
@@ -43892,7 +44592,7 @@ function instantiateRosterConfig2(role, base, requestedTimeoutMs, defaultTimeout
     timeoutMs: requestedTimeoutMs === void 0 ? rosterTimeoutMs ?? defaultTimeoutMs : void 0,
     // Give each spawn a fresh id so parallel or repeated delegates
     // can use the same role safely.
-    id: `${role}-${randomUUID22().slice(0, 8)}`
+    id: `${role}-${randomUUID23().slice(0, 8)}`
   };
 }
 function hintForKind(kind, retryable, backoffMs, partial) {
@@ -44017,6 +44717,334 @@ async function readSubagentPartial(opts, subagentId) {
   return void 0;
 }
 
+// src/coordination/explore-companion.ts
+import { randomUUID as randomUUID24 } from "node:crypto";
+var DEFAULT_EXPLORE_COMPANION_AGENT_ID = "explore-companion";
+var DEFAULT_PROBE_COOLDOWN_MS = 12e4;
+var DEFAULT_MAX_PENDING_PROBES = 8;
+var DEFAULT_MAILBOX_POLL_INTERVAL_MS = 5e3;
+var DEFAULT_EXPLORE_EDIT_TOOLS = [
+  "edit",
+  "write",
+  "patch",
+  "multi_edit",
+  "multiedit",
+  "str_replace"
+];
+var DEFAULT_EXPLORE_SEARCH_TOOLS = [
+  "search",
+  "grep",
+  "codebase-search"
+];
+function buildProbeTaskText(probe2) {
+  const payload = { probe: probe2.probe };
+  if (probe2.hint) payload.hint = probe2.hint;
+  if (probe2.context) payload.context = probe2.context;
+  return JSON.stringify(payload, null, 2);
+}
+function extractedPath(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const rec = input;
+  const candidate = typeof rec["path"] === "string" ? rec["path"] : typeof rec["file"] === "string" ? rec["file"] : void 0;
+  return candidate && candidate.length > 0 ? candidate : void 0;
+}
+function looksEmpty(e) {
+  if (typeof e.outputLines === "number" && e.outputLines === 0) return true;
+  const out = e.output ?? "";
+  return /(?:^|\n)(?:no |0 )(?:matches|results|files? found|occurrences)/i.test(out) || /total\s*:\s*0\b/i.test(out);
+}
+function extractSubjectTokens(text2) {
+  const out = [];
+  const fileRe = /([\w@./-]+\.(?:[cm]?[jt]sx?|json|md|py|go|rs|ya?ml))\b/g;
+  for (const m of text2.matchAll(fileRe)) {
+    const value = m[1];
+    if (value) out.push({ kind: "file", value });
+  }
+  const symRe = /\b[A-Z][A-Za-z0-9_]{2,}\b/g;
+  for (const m of text2.matchAll(symRe)) {
+    out.push({ kind: "symbol", value: m[0] });
+  }
+  return out;
+}
+var ExploreCompanion = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.cfg = this.resolveConfig(opts);
+  }
+  opts;
+  unsubscribers = [];
+  /** Paths the leader has read (readSet) — feeds edit-unread + unfamiliar-read. */
+  readSet = /* @__PURE__ */ new Set();
+  /** subject → last probe time; cooldown gate. Survives detach/reconfigure. */
+  probedAt = /* @__PURE__ */ new Map();
+  /** todo id → last observed status, per leader agent. */
+  todoSeen = /* @__PURE__ */ new Map();
+  pending = [];
+  inFlight = false;
+  pollTimer;
+  running = false;
+  hostStarted = false;
+  cfg;
+  resolveConfig(opts) {
+    const signals = opts.signals ?? {};
+    return {
+      enabled: opts.enabled ?? true,
+      cooldownMs: opts.cooldownMs ?? DEFAULT_PROBE_COOLDOWN_MS,
+      maxPending: opts.maxPending ?? DEFAULT_MAX_PENDING_PROBES,
+      pollIntervalMs: opts.pollIntervalMs ?? DEFAULT_MAILBOX_POLL_INTERVAL_MS,
+      companionAgentId: opts.companionAgentId ?? DEFAULT_EXPLORE_COMPANION_AGENT_ID,
+      signals: {
+        editUnreadFile: signals.editUnreadFile ?? true,
+        searchZeroHits: signals.searchZeroHits ?? true,
+        unfamiliarRead: signals.unfamiliarRead ?? true,
+        todoInProgress: signals.todoInProgress ?? true,
+        errorSymbol: signals.errorSymbol ?? true,
+        mailboxAsk: signals.mailboxAsk ?? true
+      },
+      fileEditTools: new Set(
+        (opts.fileEditTools ?? DEFAULT_EXPLORE_EDIT_TOOLS).map((t2) => t2.toLowerCase())
+      ),
+      searchTools: new Set(
+        (opts.searchTools ?? DEFAULT_EXPLORE_SEARCH_TOOLS).map((t2) => t2.toLowerCase())
+      )
+    };
+  }
+  /** Resolve the leader's own session id for event filtering. */
+  resolveLeaderSessionId() {
+    const sid = this.opts.leaderSessionId;
+    return typeof sid === "function" ? sid() : sid;
+  }
+  /** Resolve the leader's agent id for todo diffing (optional signal). */
+  resolveLeaderAgentId() {
+    const aid = this.opts.leaderAgentId;
+    if (!aid) return void 0;
+    return typeof aid === "function" ? aid() : aid;
+  }
+  /** Re-apply tunables to a (possibly running) companion. */
+  reconfigure(next) {
+    const merged = { ...this.opts, ...next };
+    const nextCfg = this.resolveConfig(merged);
+    const changed = nextCfg.enabled !== this.cfg.enabled || nextCfg.cooldownMs !== this.cfg.cooldownMs || nextCfg.maxPending !== this.cfg.maxPending || nextCfg.pollIntervalMs !== this.cfg.pollIntervalMs || nextCfg.companionAgentId !== this.cfg.companionAgentId || Object.keys(nextCfg.signals).some(
+      (k) => nextCfg.signals[k] !== this.cfg.signals[k]
+    );
+    this.cfg = nextCfg;
+    if (!changed) return false;
+    if (this.hostStarted) {
+      this.detach();
+      this.attach();
+    }
+    return true;
+  }
+  /** Begin watching. Idempotent; a disabled companion records intent only. */
+  start() {
+    this.hostStarted = true;
+    this.attach();
+  }
+  /** Stop watching and drop the host's intent to watch. */
+  stop() {
+    this.hostStarted = false;
+    this.detach();
+  }
+  /** True while the watchers are attached. */
+  isRunning() {
+    return this.running;
+  }
+  /** Number of probes queued but not yet dispatched (for status surfaces). */
+  pendingCount() {
+    return this.pending.length;
+  }
+  attach() {
+    if (!this.cfg.enabled || this.running) return;
+    this.running = true;
+    this.unsubscribers.push(
+      this.opts.events.on("tool.executed", (e) => {
+        const lsid = this.resolveLeaderSessionId();
+        if (lsid && e.sessionId && e.sessionId !== lsid) return;
+        this.trackToolExecuted(e);
+      })
+    );
+    if (this.cfg.signals.todoInProgress && this.resolveLeaderAgentId()) {
+      this.unsubscribers.push(
+        this.opts.events.on("session.agents_updated", (e) => {
+          const lsid = this.resolveLeaderSessionId();
+          if (lsid && e.sessionId && e.sessionId !== lsid) return;
+          this.trackAgentTodos(e.agents);
+        })
+      );
+    }
+    if (this.cfg.signals.errorSymbol) {
+      this.unsubscribers.push(
+        this.opts.events.on("error", (e) => {
+          const lsid = this.resolveLeaderSessionId();
+          if (lsid && e.sessionId && e.sessionId !== lsid) return;
+          this.trackError(e.err);
+        })
+      );
+    }
+    if (this.cfg.signals.mailboxAsk) {
+      this.pollTimer = setInterval(() => {
+        void this.pollMailbox();
+      }, this.cfg.pollIntervalMs);
+      this.pollTimer.unref?.();
+    }
+  }
+  /** Tear down watchers without touching host intent. Cooldowns survive. */
+  detach() {
+    for (const unsub of this.unsubscribers.splice(0)) unsub();
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = void 0;
+    }
+    this.running = false;
+  }
+  // ── signal handlers ──────────────────────────────────────────────────────
+  trackToolExecuted(e) {
+    const tool = e.name.toLowerCase();
+    const path131 = extractedPath(e.input);
+    if (e.ok && this.cfg.signals.editUnreadFile && this.cfg.fileEditTools.has(tool) && path131) {
+      if (!this.readSet.has(path131)) {
+        this.engage({
+          id: randomUUID24(),
+          probe: `Map file ${path131}: role, exports, dependencies, and callers \u2014 the leader is about to edit it.`,
+          hint: { file: path131 },
+          context: `Leader edited ${path131} without reading it first.`,
+          source: "edit_unread_file",
+          subject: `file:${path131}`,
+          createdAt: this.now()
+        });
+      }
+      return;
+    }
+    if (e.ok && this.cfg.signals.unfamiliarRead && tool === "read" && path131) {
+      if (!this.readSet.has(path131)) {
+        this.readSet.add(path131);
+        this.engage({
+          id: randomUUID24(),
+          probe: `Skeleton + callers + dependents of ${path131}: what it exports, who imports it, and how it fits the feature flow.`,
+          hint: { file: path131 },
+          context: `Leader read unfamiliar file ${path131}.`,
+          source: "unfamiliar_read",
+          subject: `file:${path131}`,
+          createdAt: this.now()
+        });
+      }
+      return;
+    }
+    if (e.ok && this.cfg.signals.searchZeroHits && this.cfg.searchTools.has(tool) && looksEmpty(e)) {
+      const input = e.input ?? {};
+      const query = typeof input["query"] === "string" ? input["query"] : typeof input["pattern"] === "string" ? input["pattern"] : "";
+      this.engage({
+        id: randomUUID24(),
+        probe: query ? `Locate "${query}" \u2014 the leader's ${e.name} returned no hits. Try synonyms, a refreshed index, and lexical fallbacks.` : `The leader's ${e.name} returned no results. Find where the concept actually lives.`,
+        hint: query ? { symbol: query } : void 0,
+        context: `${e.name} for "${query}" returned zero results.`,
+        source: "search_zero_hits",
+        subject: `search:${query}`,
+        createdAt: this.now()
+      });
+    }
+  }
+  trackAgentTodos(agents) {
+    const leaderId = this.resolveLeaderAgentId();
+    if (!leaderId) return;
+    const leader = agents.find((a) => a.id === leaderId);
+    if (!leader?.todos) return;
+    for (const todo of leader.todos) {
+      const prev = this.todoSeen.get(todo.id);
+      if (prev !== "in_progress" && todo.status === "in_progress") {
+        const mentions = extractSubjectTokens(todo.content);
+        const first = mentions[0];
+        this.engage({
+          id: randomUUID24(),
+          probe: `Pre-map the files/symbols behind this in-progress todo: "${todo.content.slice(0, 160)}".`,
+          hint: first ? { [first.kind]: first.value } : void 0,
+          context: `Todo "${todo.content.slice(0, 120)}" flipped to in_progress.`,
+          source: "todo_in_progress",
+          subject: `todo:${todo.id}`,
+          createdAt: this.now()
+        });
+      }
+      this.todoSeen.set(todo.id, todo.status);
+    }
+  }
+  trackError(err) {
+    const tokens = extractSubjectTokens(err.message);
+    for (const token of tokens.slice(0, 2)) {
+      this.engage({
+        id: randomUUID24(),
+        probe: `What is ${token.value}, where does it live, and who uses it? The leader hit an error naming it.`,
+        hint: { [token.kind]: token.value },
+        context: `Error: ${err.message.slice(0, 300)}`,
+        source: "error_symbol",
+        subject: `token:${token.value}`,
+        createdAt: this.now()
+      });
+    }
+  }
+  async pollMailbox() {
+    if (!this.cfg.enabled || !this.cfg.signals.mailboxAsk) return;
+    try {
+      const messages = await this.opts.mailbox.query({
+        unreadBy: this.cfg.companionAgentId,
+        limit: 20
+      });
+      const lsid = this.resolveLeaderSessionId();
+      for (const msg of messages) {
+        if (msg.type !== "ask" && msg.type !== "assign") continue;
+        const fromLeader = isMailboxLeader(msg.from) || lsid != null && msg.senderSessionId === lsid;
+        if (!fromLeader) continue;
+        this.engage({
+          id: randomUUID24(),
+          probe: msg.body.trim().slice(0, 2e3) || msg.subject,
+          context: `Direct ask from ${msg.from}: ${msg.subject}`,
+          source: "mailbox_ask",
+          subject: `mail:${msg.id}`,
+          createdAt: this.now()
+        });
+        await this.opts.mailbox.ack({
+          messageId: msg.id,
+          readerId: this.cfg.companionAgentId,
+          read: true,
+          completed: true
+        }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  // ── engagement ───────────────────────────────────────────────────────────
+  cooldownOk(subject2) {
+    const last = this.probedAt.get(subject2);
+    return last === void 0 || this.now() - last >= this.cfg.cooldownMs;
+  }
+  now() {
+    return this.opts.now ? this.opts.now() : Date.now();
+  }
+  engage(probe2) {
+    if (!this.cfg.enabled) return;
+    if (!this.cooldownOk(probe2.subject)) return;
+    this.probedAt.set(probe2.subject, this.now());
+    if (this.pending.length >= this.cfg.maxPending) {
+      this.pending.shift();
+    }
+    this.pending.push(probe2);
+    void this.drain();
+  }
+  async drain() {
+    if (this.inFlight) return;
+    const probe2 = this.pending.shift();
+    if (!probe2) return;
+    this.inFlight = true;
+    try {
+      await this.opts.onProbe(probe2);
+    } catch {
+    } finally {
+      this.inFlight = false;
+      if (this.pending.length > 0) void this.drain();
+    }
+  }
+};
+
 // src/coordination/mailbox-codecs.ts
 var MailboxValidationError = class extends Error {
   code;
@@ -44048,6 +45076,22 @@ var SEND_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
   // receiver trusts the sender-asserted `sessionId`; the boundary must
   // refuse the field entirely.
 ]);
+var SEND_FORBIDDEN_FIELDS = /* @__PURE__ */ new Set([
+  "from",
+  "sessionAffinity"
+]);
+function filterMailboxSendPayload(input) {
+  const payload = {};
+  const stripped = [];
+  for (const key of Object.keys(input)) {
+    if (SEND_ALLOWED_FIELDS.has(key) || SEND_FORBIDDEN_FIELDS.has(key)) {
+      payload[key] = input[key];
+    } else {
+      stripped.push(key);
+    }
+  }
+  return { payload, stripped };
+}
 var ACK_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
   "messageId",
   "read",
@@ -44285,7 +45329,9 @@ function makeMailSendTool(opts = {}) {
       required: ["to", "subject", "body"]
     },
     async execute(input, ctx) {
-      const i = input ?? {};
+      const { payload: i, stripped } = filterMailboxSendPayload(
+        input ?? {}
+      );
       const rawTo = i.to;
       const subject2 = i.subject;
       const body = i.body;
@@ -44308,15 +45354,13 @@ function makeMailSendTool(opts = {}) {
         recipientAliases: /* @__PURE__ */ new Set([codecIdentity.baseId]),
         sessionId: codecIdentity.sessionId
       };
+      let parsed;
       try {
-        parseMailboxSendInput(i, codecActor);
+        parsed = parseMailboxSendInput(i, codecActor);
       } catch (err) {
         return { ok: false, error: err instanceof Error ? err.message : String(err) };
       }
-      const audience = i.audience;
-      if (audience !== void 0 && audience !== "all" && audience !== "leaders") {
-        return { ok: false, error: '"audience" must be "all" or "leaders".' };
-      }
+      const audience = parsed.audience;
       const mb = resolveMailbox(ctx);
       const identity2 = await register(mb, ctx);
       const requestedTo = normalizeRecipient(rawTo, identity2.sessionId);
@@ -44330,10 +45374,10 @@ function makeMailSendTool(opts = {}) {
         to: delivery.to,
         type: resolvedType,
         audience: delivery.audience,
-        subject: subject2,
-        body,
-        priority: i.priority ?? "normal",
-        replyTo: i.replyTo,
+        subject: parsed.subject,
+        body: parsed.body,
+        priority: parsed.priority,
+        replyTo: parsed.replyTo,
         senderSessionId: identity2.sessionId
       });
       return {
@@ -44341,7 +45385,9 @@ function makeMailSendTool(opts = {}) {
         messageId: msg.id,
         from: identity2.callerId,
         to: msg.to,
-        summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity2.callerId}.`
+        // Surfacing what was stripped keeps the send auditable without
+        // re-introducing the clutter into the payload itself.
+        ...stripped.length > 0 ? { strippedFields: stripped, summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity2.callerId}. Ignored ${stripped.length} unrecognized field(s): ${stripped.join(", ")}.` } : { summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity2.callerId}.` }
       };
     }
   };
@@ -47867,7 +48913,7 @@ function createAgentMonitorService(opts) {
 }
 
 // src/coordination/autonomous-brain.ts
-import { randomUUID as randomUUID23 } from "node:crypto";
+import { randomUUID as randomUUID25 } from "node:crypto";
 var AutonomousBrain = class {
   graph;
   // Fleet bus for emitting decisions — null-safe, no-op if not provided
@@ -47973,7 +49019,7 @@ var AutonomousBrain = class {
       consequence: i === 0 ? `Spawn the most appropriate agent for: ${taskDescription.slice(0, 80)}` : `Spawn an alternative agent for the same task`
     }));
     return this.decideAuto({
-      id: randomUUID23(),
+      id: randomUUID25(),
       source,
       decisionType: "spawn",
       question: `Should we spawn a subagent for this task?`,
@@ -48016,7 +49062,7 @@ var AutonomousBrain = class {
       }
     ];
     return this.decideAuto({
-      id: randomUUID23(),
+      id: randomUUID25(),
       source,
       decisionType: "approve_change",
       question: `Should we approve the change "${change.title}"?`,
@@ -48075,7 +49121,7 @@ var AutonomousBrain = class {
       consequence: "Break the task into smaller sub-tasks"
     });
     return this.decideAuto({
-      id: randomUUID23(),
+      id: randomUUID25(),
       source,
       decisionType: "escalate_task",
       question: `Task failed: ${error2.slice(0, 100)}. How should we proceed?`,
@@ -48209,12 +49255,12 @@ ${ctx.error}`);
 };
 
 // src/coordination/autonomous-coordinator.ts
-import { randomUUID as randomUUID26 } from "node:crypto";
+import { randomUUID as randomUUID28 } from "node:crypto";
 
 // src/coordination/knowledge-graph.ts
 init_file_permissions();
 init_atomic_write();
-import { randomUUID as randomUUID24 } from "node:crypto";
+import { randomUUID as randomUUID26 } from "node:crypto";
 import * as fsp34 from "node:fs/promises";
 import * as path73 from "node:path";
 var DEFAULT_MAX_NODES = 2e3;
@@ -48262,7 +49308,7 @@ var KnowledgeGraph = class _KnowledgeGraph {
    * Returns the node with its assigned id.
    */
   async add(node) {
-    const full = { id: randomUUID24(), ...node };
+    const full = { id: randomUUID26(), ...node };
     this.nodes.set(full.id, full);
     this._trackSeq(full.id);
     this._addToIndex(full, this._indexKeys(full));
@@ -48391,8 +49437,8 @@ var KnowledgeGraph = class _KnowledgeGraph {
     if (this.subs.size >= MAX_SUBSCRIPTIONS) {
       throw new Error(`Knowledge graph subscription limit reached (${MAX_SUBSCRIPTIONS})`);
     }
-    const channel2 = randomUUID24();
-    const sub = { id: randomUUID24(), agentId, filter, channel: channel2 };
+    const channel2 = randomUUID26();
+    const sub = { id: randomUUID26(), agentId, filter, channel: channel2 };
     this.subs.set(channel2, sub);
     this.pendingDeliveries.set(channel2, []);
     return channel2;
@@ -48873,7 +49919,7 @@ var TaskDAG = class {
 };
 
 // src/coordination/task-auctioneer.ts
-import { randomUUID as randomUUID25 } from "node:crypto";
+import { randomUUID as randomUUID27 } from "node:crypto";
 function isTerminalGoalStatus(status) {
   return status === "done" || status === "failed";
 }
@@ -48996,7 +50042,7 @@ var TaskAuctioneer = class {
     const score = dispatchResult.confidence * (dispatchResult.role === agent.agentRole ? 1.2 : 1);
     if (score < this.minConfidence) return false;
     const bid = {
-      id: randomUUID25(),
+      id: randomUUID27(),
       taskId,
       agentId: agent.agentId,
       agentName: agent.agentName,
@@ -49933,7 +50979,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
           break;
         }
         const decision = await this.brain.decideAuto({
-          id: randomUUID26(),
+          id: randomUUID28(),
           source: "system",
           decisionType: "prioritize_goals",
           question: `What should we work on next? Open goals: ${dispatchable.map((g) => g.title).join(", ")}`,
@@ -50848,7 +51894,7 @@ var TOKENS = {
 init_errors();
 
 // src/hq/factory.ts
-import { createHash as createHash24, randomUUID as randomUUID29 } from "node:crypto";
+import { createHash as createHash24, randomUUID as randomUUID31 } from "node:crypto";
 import * as fs30 from "node:fs";
 import { hostname as hostname3 } from "node:os";
 import { basename as basename15 } from "node:path";
@@ -50856,13 +51902,13 @@ import { basename as basename15 } from "node:path";
 // src/hq/auth-store.ts
 init_file_permissions();
 init_atomic_write();
-import { createHash as createHash23, randomBytes as randomBytes4, randomUUID as randomUUID27, scrypt, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createHash as createHash23, randomBytes as randomBytes4, randomUUID as randomUUID29, scrypt, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import * as syncFs from "node:fs";
 import * as fs29 from "node:fs/promises";
 import * as path75 from "node:path";
 
 // src/hq/auth-audit.ts
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync20, mkdirSync as mkdirSync9 } from "node:fs";
+import { appendFileSync as appendFileSync2, readFileSync as readFileSync21, mkdirSync as mkdirSync9 } from "node:fs";
 import * as path74 from "node:path";
 function hqAuthAuditPath(dataDir) {
   return path74.join(dataDir, "auth-audit.jsonl");
@@ -50871,7 +51917,7 @@ function readHqAuthAuditTail(dataDir, maxEntries = 50) {
   const filePath = hqAuthAuditPath(dataDir);
   let content;
   try {
-    content = readFileSync20(filePath, "utf8");
+    content = readFileSync21(filePath, "utf8");
   } catch {
     return [];
   }
@@ -51183,8 +52229,8 @@ function mintHqToken(labelOrOptions) {
   const at = opts.now ?? Date.now();
   const createdAtIso = new Date(at).toISOString();
   return {
-    id: randomUUID27(),
-    token: randomUUID27().replace(/-/g, "") + randomUUID27().replace(/-/g, ""),
+    id: randomUUID29(),
+    token: randomUUID29().replace(/-/g, "") + randomUUID29().replace(/-/g, ""),
     createdAt: createdAtIso,
     ...opts.label ? { label: opts.label } : {},
     ...opts.ttlMs !== void 0 && Number.isFinite(opts.ttlMs) && opts.ttlMs > 0 ? { expiresAt: new Date(at + opts.ttlMs).toISOString() } : {}
@@ -51244,7 +52290,7 @@ function watchHqAuthFile(dataDir, onChange, opts = {}) {
 }
 
 // src/hq/publisher.ts
-import { randomUUID as randomUUID28 } from "node:crypto";
+import { randomUUID as randomUUID30 } from "node:crypto";
 import * as v82 from "node:v8";
 
 // src/hq/protocol/governance.ts
@@ -52318,7 +53364,7 @@ var HqPublisher = class {
     this.options = options;
     this.socketFactory = options.socketFactory ?? defaultSocketFactory;
     this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-    this.idFactory = options.idFactory ?? randomUUID28;
+    this.idFactory = options.idFactory ?? randomUUID30;
     this.capabilities = options.capabilities ?? [
       "telemetry.publish",
       "mailbox.summary",
@@ -52902,7 +53948,7 @@ function createHqPublisherFromEnv(options) {
   const projectAlias = config.projectAlias?.trim() || void 0;
   const projectName = projectAlias ?? options.projectName ?? (basename15(options.projectRoot) || "unknown");
   const client = {
-    clientId: `${machineId}:${options.clientKind}:${process.pid}:${randomUUID29().slice(0, 8)}`,
+    clientId: `${machineId}:${options.clientKind}:${process.pid}:${randomUUID31().slice(0, 8)}`,
     kind: options.clientKind,
     machineId,
     ...host ? { hostname: host } : {},
@@ -53171,40 +54217,6 @@ async function injectPendingMailboxMessages(checkMailbox2, foldFn, a, deliveryMo
   return interruptMsg ? { interrupt: true, interruptReason: interruptMsg.body || interruptMsg.subject || "operator interrupt" } : { interrupt: false };
 }
 
-// src/core/btw.ts
-var META_KEY2 = "_btwNotes";
-var MAX_PENDING = 20;
-function readQueue(ctx) {
-  const raw = ctx.meta[META_KEY2];
-  return Array.isArray(raw) ? raw : [];
-}
-function setBtwNote(ctx, text2) {
-  const trimmed = text2.trim();
-  if (!trimmed) return readQueue(ctx).length;
-  const next = [...readQueue(ctx), trimmed].slice(-MAX_PENDING);
-  ctx.meta[META_KEY2] = next;
-  return next.length;
-}
-function pendingBtwCount(ctx) {
-  return readQueue(ctx).length;
-}
-function consumeBtwNotes(ctx) {
-  const notes = readQueue(ctx);
-  if (notes.length > 0) delete ctx.meta[META_KEY2];
-  return notes;
-}
-function buildBtwBlock(notes) {
-  const body = notes.map((n) => `- ${n}`).join("\n");
-  return [
-    "[BY THE WAY \u2014 the user added this while you were working. Fold it into",
-    "your current task; do not restart from scratch unless it contradicts the",
-    "goal:",
-    "",
-    body,
-    "]"
-  ].join("\n");
-}
-
 // src/core/fleet-pulse.ts
 var DEFAULT_MAX_AGENTS = 15;
 var DEFAULT_MAX_CHARS = 900;
@@ -53212,9 +54224,17 @@ var TASK_SNIPPET_CHARS2 = 60;
 function fleetPulseSignature(statuses) {
   return statuses.map((s) => `${s.agentId}|${s.status}|${s.currentTask ?? ""}`).sort().join("\n");
 }
-function peerLine(s) {
+function visibleLineKey(s) {
+  const role = s.role && s.role !== s.name ? s.role : "";
+  const task = s.currentTask && s.currentTask.length > TASK_SNIPPET_CHARS2 ? `${s.currentTask.slice(0, TASK_SNIPPET_CHARS2)}\u2026` : s.currentTask ?? "";
+  const tool = s.currentTool || "";
+  const toolCalls = s.toolCalls > 0 ? String(s.toolCalls) : "";
+  return [s.name, role, s.status, task, tool, toolCalls].join("\0");
+}
+function peerLine(s, count = 1) {
   const role = s.role && s.role !== s.name ? ` (${s.role})` : "";
-  const parts = [`\u2022 ${s.name}${role} \u2014 ${s.status}`];
+  const grouped = count > 1 ? ` \xD7${count}` : "";
+  const parts = [`\u2022 ${s.name}${role}${grouped} \u2014 ${s.status}`];
   if (s.currentTask) {
     const task = s.currentTask.length > TASK_SNIPPET_CHARS2 ? `${s.currentTask.slice(0, TASK_SNIPPET_CHARS2)}\u2026` : s.currentTask;
     parts.push(`"${task}"`);
@@ -53230,13 +54250,20 @@ function buildFleetPulseBlock(statuses, opts) {
   if (peers.length === 0) return null;
   const order = { running: 0, streaming: 0, waiting_user: 1, idle: 2, error: 3, offline: 4 };
   const sorted = [...peers].sort(
-    (x, y) => (order[x.status] ?? 5) - (order[y.status] ?? 5) || x.name.localeCompare(y.name)
+    (x, y) => (order[x.status] ?? 5) - (order[y.status] ?? 5) || visibleLineKey(x).localeCompare(visibleLineKey(y))
   );
   const shown = sorted.slice(0, maxAgents);
   const hidden = sorted.length - shown.length;
   const parts = [];
   parts.push(`[FLEET PULSE] ${peers.length} peer${peers.length === 1 ? "" : "s"} online:`);
-  for (const s of shown) parts.push(peerLine(s));
+  for (let i = 0; i < shown.length; ) {
+    let run = 1;
+    while (i + run < shown.length && visibleLineKey(shown[i]) === visibleLineKey(shown[i + run])) {
+      run++;
+    }
+    parts.push(peerLine(shown[i], run));
+    i += run;
+  }
   if (hidden > 0) parts.push(`\u2026 +${hidden} more`);
   parts.push(
     "[END FLEET PULSE] (FYI \u2014 coordinate via mail_send; avoid duplicating peers' work)"
@@ -54187,7 +55214,7 @@ async function getPromptJournalEntries(projectRoot, filter = {}) {
 init_errors();
 
 // src/core/streaming-response-builder.ts
-import { randomUUID as randomUUID31 } from "node:crypto";
+import { randomUUID as randomUUID33 } from "node:crypto";
 var STREAM_DRAIN_TIMEOUT_MS = 500;
 function buildResponse(state) {
   const content = [];
@@ -54247,7 +55274,7 @@ function handleContentBlockStart(state, ev) {
     state.textBuffers.push("");
     state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
   } else if (kind === "tool_use") {
-    const id = ev.id ?? randomUUID31();
+    const id = ev.id ?? randomUUID33();
     state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
     state.blockOrder.push({ kind: "tool", id });
     state.currentTextIndex = -1;
@@ -54482,7 +55509,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
 
 // src/observability/network-telemetry.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createHash as createHash25, randomUUID as randomUUID32 } from "node:crypto";
+import { createHash as createHash25, randomUUID as randomUUID34 } from "node:crypto";
 import { channel } from "node:diagnostics_channel";
 var storage = new AsyncLocalStorage();
 var requests = /* @__PURE__ */ new WeakMap();
@@ -54519,7 +55546,7 @@ function subscribe() {
     const requestBytes = numberField2(request, "contentLength");
     const state = {
       ...context,
-      requestId: randomUUID32(),
+      requestId: randomUUID34(),
       ...target,
       ...requestBytes !== void 0 ? { requestBytes } : {},
       startedAt,
@@ -54654,7 +55681,7 @@ function hash3(value) {
 }
 
 // src/core/provider-runner.ts
-import { randomUUID as randomUUID33 } from "node:crypto";
+import { randomUUID as randomUUID35 } from "node:crypto";
 function scrubProviderBody(body) {
   if (!body) return void 0;
   return {
@@ -54676,11 +55703,11 @@ function providerLogCtx(p, r) {
 }
 async function runProviderWithRetry(opts) {
   const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
-  const logicalRequestId = randomUUID33();
+  const logicalRequestId = randomUUID35();
   const promptManifest = createChroniclePromptManifest(request);
   let attempt = 0;
   for (; ; ) {
-    const attemptId = randomUUID33();
+    const attemptId = randomUUID35();
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startedNs = process.hrtime.bigint();
     const correlation = {
@@ -59349,7 +60376,7 @@ function _resetDesignRulesCache() {
 }
 
 // src/execution/design-color.ts
-function clamp(n, lo, hi) {
+function clamp2(n, lo, hi) {
   return n < lo ? lo : n > hi ? hi : n;
 }
 function parseOklch(value) {
@@ -59365,9 +60392,9 @@ function parseOklch(value) {
   let a = 1;
   if (alphaPart !== void 0) {
     const av = parseComponent(alphaPart.trim(), true);
-    if (av !== null) a = clamp(av, 0, 1);
+    if (av !== null) a = clamp2(av, 0, 1);
   }
-  return [clamp(L, 0, 1), Math.max(0, C), H, a];
+  return [clamp2(L, 0, 1), Math.max(0, C), H, a];
 }
 function parseComponent(s, percentIsFraction) {
   s = s.trim();
@@ -59386,7 +60413,7 @@ function parseAngle(s) {
 }
 function linearToSrgb(c) {
   const v = c <= 31308e-7 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
-  return clamp(v, 0, 1);
+  return clamp2(v, 0, 1);
 }
 function toHex2(n) {
   return Math.round(n * 255).toString(16).padStart(2, "0");
@@ -62133,7 +63160,7 @@ ${summaryText}` : summaryText;
 
 // src/execution/parallel-eternal-engine.ts
 init_error();
-import { randomUUID as randomUUID34 } from "node:crypto";
+import { randomUUID as randomUUID36 } from "node:crypto";
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
@@ -62210,7 +63237,7 @@ var ParallelEternalEngine = class {
     this.state = "running";
     await this.persistState("running");
     const config = {
-      coordinatorId: `parallel-${randomUUID34().slice(0, 8)}`,
+      coordinatorId: `parallel-${randomUUID36().slice(0, 8)}`,
       maxConcurrent: this.slots,
       doneCondition: { type: "all_tasks_done" }
     };
@@ -62264,7 +63291,7 @@ var ParallelEternalEngine = class {
     }
     if (!this.coordinator) {
       const config = {
-        coordinatorId: `parallel-${randomUUID34().slice(0, 8)}`,
+        coordinatorId: `parallel-${randomUUID36().slice(0, 8)}`,
         maxConcurrent: this.slots,
         doneCondition: { type: "all_tasks_done" }
       };
@@ -62350,7 +63377,7 @@ ${recentJournal}` : "No prior iterations.",
       const task = expectDefined(tasks[i]);
       const route = routes[i] ?? null;
       const subagentId = `parallel-${this.iterations}-${i}`;
-      const taskId = randomUUID34();
+      const taskId = randomUUID36();
       const personaLine = route ? `Acting agent: ${route.definition.config.name} \u2014 ${route.definition.capability.summary}
 ` : "";
       const spec = {
@@ -63978,7 +65005,7 @@ function readPolicy(ctx) {
 }
 
 // src/execution/tool-executor.ts
-import { randomUUID as randomUUID37 } from "node:crypto";
+import { randomUUID as randomUUID39 } from "node:crypto";
 import * as fs38 from "node:fs/promises";
 import * as path85 from "node:path";
 init_errors();
@@ -64000,7 +65027,7 @@ var ToolErrorCategory = /* @__PURE__ */ ((ToolErrorCategory2) => {
 })(ToolErrorCategory || {});
 
 // src/execution/tool-executor-support.ts
-import { createHash as createHash29, randomUUID as randomUUID35 } from "node:crypto";
+import { createHash as createHash29, randomUUID as randomUUID37 } from "node:crypto";
 import * as fs37 from "node:fs/promises";
 import * as path83 from "node:path";
 init_errors();
@@ -64132,7 +65159,7 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     await fs37.mkdir(dir, { recursive: true });
     const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const filePath = path83.join(dir, `${stamp}-${safeTool}-${randomUUID35()}.log`);
+    const filePath = path83.join(dir, `${stamp}-${safeTool}-${randomUUID37()}.log`);
     await fs37.writeFile(filePath, content, "utf8");
     const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
     const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
@@ -64682,7 +65709,7 @@ ${errorDetails}`,
 }
 
 // src/execution/tool-executor-runner.ts
-import { randomUUID as randomUUID36 } from "node:crypto";
+import { randomUUID as randomUUID38 } from "node:crypto";
 
 // src/observability/process-telemetry.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
@@ -64906,7 +65933,7 @@ async function runToolWithTimeout(tool, input, parentSignal, ctx, opts, config,
     progressTailChars: config.progressTailChars,
     progressHeadChars: config.progressHeadChars
   }) : (async () => tool.execute(input, ctx, { signal: combined }))();
-  const telemetryToolCallId = toolUseId ?? `nested-${randomUUID36()}`;
+  const telemetryToolCallId = toolUseId ?? `nested-${randomUUID38()}`;
   const toolPromise = opts.events ? runWithNetworkTelemetry(
     {
       events: opts.events,
@@ -65299,7 +66326,7 @@ ${post.additionalContext}`;
     const bridge = async (toolName, input) => {
       const nestedUse = {
         type: "tool_use",
-        id: `nested-${randomUUID37()}`,
+        id: `nested-${randomUUID39()}`,
         name: toolName,
         input
       };
@@ -65904,13 +66931,13 @@ import * as fs39 from "node:fs/promises";
 import * as path87 from "node:path";
 
 // src/types/mode-prompts.ts
-import { readFileSync as readFileSync23, statSync as statSync9 } from "node:fs";
+import { readFileSync as readFileSync24, statSync as statSync9 } from "node:fs";
 import * as path86 from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function modePrompt(id) {
   for (const dir of modePromptDirCandidates()) {
     try {
-      return readFileSync23(path86.join(dir, `${id}.md`), "utf8").trimEnd();
+      return readFileSync24(path86.join(dir, `${id}.md`), "utf8").trimEnd();
     } catch {
     }
   }
@@ -66591,7 +67618,17 @@ function normalizeModelsDevModel(model) {
   const reasoningConfig = {
     default: disableSupported ? "enabled" : "always_on",
     disableSupported,
-    effortSupported: effortLevels.length > 0,
+    // Tri-state (see ReasoningConfig.effortSupported):
+    //   options present  → documented answer (true when effort values exist;
+    //                      an explicitly EMPTY array is a documented "no
+    //                      effort control", not an absent field).
+    //   field ABSENT     → the model is known to reason but its vocabulary is
+    //                      undocumented → `undefined`, so the resolver forwards
+    //                      the request and each wire adapter applies its own
+    //                      transport gating. Sending `false` here would make
+    //                      the resolver claim "does not support effort" — an
+    //                      assertion the catalog never made.
+    ...raw === void 0 ? {} : { effortSupported: effortLevels.length > 0 },
     effortLevels,
     preserveThinking: model.interleaved ? "always_on" : "unsupported"
   };
@@ -67180,9 +68217,9 @@ async function startMetricsServer(opts) {
   let server;
   if (useHttps && tls) {
     const { createServer } = await import("node:https");
-    const { readFileSync: readFileSync25 } = await import("node:fs");
+    const { readFileSync: readFileSync26 } = await import("node:fs");
     server = createServer(
-      { cert: readFileSync25(tls.cert), key: readFileSync25(tls.key) },
+      { cert: readFileSync26(tls.cert), key: readFileSync26(tls.key) },
       listener
     );
   } else {
@@ -69148,7 +70185,7 @@ function deepFreeze(obj) {
 init_errors();
 init_atomic_write();
 init_error();
-import { randomUUID as randomUUID38 } from "node:crypto";
+import { randomUUID as randomUUID40 } from "node:crypto";
 import * as fsp38 from "node:fs/promises";
 function assertPlanMutationInvariants(previous, updated) {
   const ids = updated.items.map((item) => item.id);
@@ -69270,7 +70307,7 @@ function emptyPlan(sessionId, title) {
 function addPlanItem(plan, title, details) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const item = {
-    id: `plan_${Date.now()}_${randomUUID38().slice(0, 6)}`,
+    id: `plan_${Date.now()}_${randomUUID40().slice(0, 6)}`,
     title,
     details,
     status: "open",
@@ -69342,7 +70379,7 @@ function deriveTodosFromPlanItem(plan, idOrIndex, subtasks) {
   if (subtasks && subtasks.length > 0) {
     for (const st of subtasks) {
       todos.push({
-        id: `todo_${Date.now()}_${randomUUID38().slice(0, 6)}`,
+        id: `todo_${Date.now()}_${randomUUID40().slice(0, 6)}`,
         content: st,
         status: "pending",
         promotedFromPlan: item.id
@@ -73339,7 +74376,7 @@ function resolveReasoningForRequest(settings, rc, warnings) {
   const cfg = settings.reasoning;
   if (!cfg) return void 0;
   const capKnown = rc !== void 0;
-  const supportsReasoning = rc ? rc.default !== "disabled" || rc.disableSupported || rc.effortSupported : false;
+  const supportsReasoning = rc ? rc.default !== "disabled" || rc.disableSupported || rc.effortSupported !== false : false;
   const out = {};
   if (cfg.mode === "off") {
     if (capKnown && rc?.disableSupported) {
@@ -73361,14 +74398,17 @@ function resolveReasoningForRequest(settings, rc, warnings) {
   }
   const effort = cfg.effort;
   if (effort !== void 0) {
-    if (capKnown && rc?.effortSupported && rc.effortLevels.includes(effort)) {
-      out.effort = effort;
-    } else if (capKnown && rc?.effortSupported) {
+    if (!capKnown) {
+    } else if (rc?.effortSupported === false) {
+      warnings.push(
+        `reasoning effort "${effort}" requested, but this model does not support effort control; the setting was omitted.`
+      );
+    } else if (rc?.effortSupported === true && rc.effortLevels.length > 0 && !rc.effortLevels.includes(effort)) {
       warnings.push(
         `reasoning effort "${effort}" not supported by this model (supported: ${rc.effortLevels.join(", ")}); the setting was omitted.`
       );
-    } else if (capKnown) {
-      warnings.push(`reasoning effort "${effort}" requested, but this model does not support effort; the setting was omitted.`);
+    } else {
+      out.effort = effort;
     }
   }
   if (cfg.preserve !== void 0) {
@@ -75244,6 +76284,13 @@ var PhaseOrchestrator = class {
   events;
   stopped = false;
   paused = false;
+  /**
+   * Run-wide abort source. stop() aborts it; every in-flight
+   * ctx.executeTask call observes the abort through its per-task signal
+   * (composed from this controller and the task's own timeout controller).
+   * Recreated by start() so a stopped orchestrator can be reused.
+   */
+  stopController = new AbortController();
   runningPhases = /* @__PURE__ */ new Set();
   tickInterval = null;
   trackerCache = /* @__PURE__ */ new Map();
@@ -75286,6 +76333,7 @@ var PhaseOrchestrator = class {
   async start() {
     this.stopped = false;
     this.paused = false;
+    this.stopController = new AbortController();
     this.normalizeForResume();
     this.graph.startedAt = Date.now();
     this.graph.updatedAt = Date.now();
@@ -75345,6 +76393,7 @@ var PhaseOrchestrator = class {
   /** Stop completely, including active phases. */
   stop() {
     this.stopped = true;
+    this.stopController.abort();
     if (this.tickInterval) {
       clearInterval(this.tickInterval);
       this.tickInterval = null;
@@ -75421,6 +76470,7 @@ var PhaseOrchestrator = class {
         return;
       }
       await this.executePhaseTasks(phase);
+      if (this.stopped) return;
       const failedTasks = this.getFailedTaskCount(phase);
       const completedTasks = this.getCompletedTaskCount(phase);
       this.emit("phase.allTasksDone", {
@@ -75580,34 +76630,47 @@ var PhaseOrchestrator = class {
       agentName: task.assignee
     });
     const handle = this.phaseWorktrees.get(phase.id);
-    const taskPromise = this.ctx.executeTask(task, phase.id, {
-      cwd: handle?.dir,
-      branch: handle?.branch
-    });
-    if (this.opts.taskTimeoutMs > 0) {
-      const timeoutMs = this.opts.taskTimeoutMs;
-      const timedOut = /* @__PURE__ */ Symbol("timed_out");
-      const result = await Promise.race([
-        taskPromise,
-        new Promise((resolve57) => {
-          const timer = setTimeout(() => resolve57(timedOut), timeoutMs);
-          taskPromise.then(() => clearTimeout(timer)).catch(() => clearTimeout(timer));
-        })
-      ]);
-      if (result === timedOut) {
-        this.emit("phase.taskTimedOut", {
-          phaseId: phase.id,
-          taskId: task.id,
-          taskTitle: task.title,
-          timeoutMs
-        });
-        throw new Error(
-          `Task "${task.title}" (${task.id}) exceeded timeout of ${timeoutMs} ms`
-        );
-      }
-      return result;
-    }
-    return taskPromise;
+    const timeoutController = this.opts.taskTimeoutMs > 0 ? new AbortController() : void 0;
+    const signal = timeoutController ? AbortSignal.any([this.stopController.signal, timeoutController.signal]) : this.stopController.signal;
+    const taskPromise = this.ctx.executeTask(
+      task,
+      phase.id,
+      { cwd: handle?.dir, branch: handle?.branch },
+      signal
+    );
+    if (!timeoutController) return taskPromise;
+    const timeoutMs = this.opts.taskTimeoutMs;
+    const timedOut = /* @__PURE__ */ Symbol("timed_out");
+    const result = await Promise.race([
+      taskPromise,
+      new Promise((resolve57) => {
+        const timer = setTimeout(() => {
+          timeoutController.abort();
+          resolve57(timedOut);
+        }, timeoutMs);
+        taskPromise.then(() => clearTimeout(timer)).catch(() => clearTimeout(timer));
+      })
+    ]);
+    if (result !== timedOut) return result;
+    this.emit("phase.taskTimedOut", {
+      phaseId: phase.id,
+      taskId: task.id,
+      taskTitle: task.title,
+      timeoutMs
+    });
+    const settled = taskPromise.then(
+      () => void 0,
+      () => void 0
+    );
+    const grace = new Promise((resolve57) => {
+      const timer = setTimeout(resolve57, 5e3);
+      timer.unref?.();
+      void settled.then(() => clearTimeout(timer));
+    });
+    await Promise.race([settled, grace]);
+    throw new Error(
+      `Task "${task.title}" (${task.id}) exceeded timeout of ${timeoutMs} ms`
+    );
   }
   markTaskCompleted(phase, task) {
     const tracker = this.getTrackerForPhase(phase);
@@ -75622,6 +76685,10 @@ var PhaseOrchestrator = class {
     const tracker = this.getTrackerForPhase(phase);
     const taskKey = `${phase.id}:${task.id}`;
     const currentRetries = this.taskRetryCounts.get(taskKey) ?? 0;
+    if (this.stopped) {
+      tracker.updateNodeStatus(task.id, "pending", "Stopped before completion");
+      return;
+    }
     if (currentRetries < this.opts.maxRetries) {
       this.taskRetryCounts.set(taskKey, currentRetries + 1);
       tracker.updateNodeStatus(
@@ -80934,7 +82001,8 @@ async function loadPlugins(plugins, opts) {
         plugin,
         resolution.options
       );
-      const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log, opts.enforceCapabilities) : rawApi;
+      const enforceForPlugin = typeof opts.enforceCapabilities === "function" ? opts.enforceCapabilities(plugin) : opts.enforceCapabilities ?? false;
+      const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log, enforceForPlugin) : rawApi;
       registration = {
         plugin,
         api,
@@ -81765,7 +82833,7 @@ async function snapshotChangedFiles(cwd) {
 }
 
 // src/plugins/review-claim-registry.ts
-import { createHash as createHash33, randomUUID as randomUUID39 } from "node:crypto";
+import { createHash as createHash33, randomUUID as randomUUID41 } from "node:crypto";
 import * as fsp46 from "node:fs/promises";
 import { hostname as hostname5 } from "node:os";
 import * as path103 from "node:path";
@@ -81828,7 +82896,7 @@ async function breakStaleLock(lockPath) {
   return false;
 }
 async function breakLockAtomically(lockPath) {
-  const tombstone = `${lockPath}.stale-${randomUUID39()}.tmp`;
+  const tombstone = `${lockPath}.stale-${randomUUID41()}.tmp`;
   try {
     await fsp46.rename(lockPath, tombstone);
   } catch {
@@ -81888,7 +82956,7 @@ async function withStoreLock(storeDir, fn, waitMs = LOCK_WAIT_MS) {
   }
 }
 var MAX_LEDGER_LINES = 1e4;
-var HOST_SID = randomUUID39();
+var HOST_SID = randomUUID41();
 var claimsByEventBus = /* @__PURE__ */ new WeakMap();
 var startedReviews = /* @__PURE__ */ new WeakMap();
 var pendingStartedReviews = /* @__PURE__ */ new WeakMap();
@@ -81969,7 +83037,7 @@ async function compactLedger(storeDir, active) {
       );
     }
   }
-  const tmp = `${claimsFilePath(storeDir)}.tmp-${randomUUID39()}`;
+  const tmp = `${claimsFilePath(storeDir)}.tmp-${randomUUID41()}`;
   await fsp46.writeFile(tmp, lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf8");
   let replaced = false;
@@ -82898,7 +83966,7 @@ init_review_finding_store();
 
 // src/plugins/review-finding-parser.ts
 init_review_finding_types();
-import { randomUUID as randomUUID41 } from "node:crypto";
+import { randomUUID as randomUUID43 } from "node:crypto";
 var SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low"]);
 var CATEGORIES = /* @__PURE__ */ new Set([
   "bug",
@@ -82970,7 +84038,7 @@ function parseChimeraReviewReport(reportText, context = {}) {
   }
   const structured = extractStructuredFindingsBlock(reportText);
   if (structured) {
-    const reportId2 = context.reportId ?? randomUUID41();
+    const reportId2 = context.reportId ?? randomUUID43();
     const findings2 = structured.findings.map(
       (item) => buildFindingFromStructuredItem(item, { ...context, reportId: reportId2 })
     );
@@ -82982,7 +84050,7 @@ function parseChimeraReviewReport(reportText, context = {}) {
     };
   }
   const findings = [];
-  const reportId = context.reportId ?? randomUUID41();
+  const reportId = context.reportId ?? randomUUID43();
   let unparseableCount = 0;
   let durationSeconds;
   let currentSeverity = null;
@@ -83083,7 +84151,7 @@ function parseFindingSegment(segment, severity, context) {
   const fullDesc = suggestions.length > 0 ? cleanDesc + "\n" + suggestions.map((s) => "  \u2192 " + s).join("\n") : cleanDesc;
   const suggestedFix = suggestions.length > 0 ? suggestions.join("\n") : void 0;
   return {
-    id: randomUUID41(),
+    id: randomUUID43(),
     fingerprint: computeFindingFingerprint(file ?? "", line ?? null, title),
     severity,
     source: normalizeFindingSource(context.reviewType),
@@ -83094,7 +84162,7 @@ function parseFindingSegment(segment, severity, context) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     status: "active",
     originReport: {
-      reportId: context.reportId ?? randomUUID41(),
+      reportId: context.reportId ?? randomUUID43(),
       sessionId: context.sessionId ?? "",
       agentId: context.agentId ?? "",
       reviewerModel: context.reviewerModel ?? ""
@@ -83118,7 +84186,7 @@ function buildFindingFromStructuredItem(item, context) {
   const title = item.title;
   const description = item.description ?? title;
   return {
-    id: randomUUID41(),
+    id: randomUUID43(),
     fingerprint: computeFindingFingerprint(file ?? "", line ?? null, title),
     severity: item.severity,
     source: normalizeFindingSource(context.reviewType),
@@ -83131,7 +84199,7 @@ function buildFindingFromStructuredItem(item, context) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     status: "active",
     originReport: {
-      reportId: context.reportId ?? randomUUID41(),
+      reportId: context.reportId ?? randomUUID43(),
       sessionId: context.sessionId ?? "",
       agentId: context.agentId ?? "",
       reviewerModel: context.reviewerModel ?? ""
@@ -88782,7 +89850,7 @@ var ReplayProviderRunner = class {
 };
 
 // src/session-catalog/store.ts
-import { randomBytes as randomBytes8, randomUUID as randomUUID42 } from "node:crypto";
+import { randomBytes as randomBytes8, randomUUID as randomUUID44 } from "node:crypto";
 import * as fs59 from "node:fs";
 import * as path119 from "node:path";
 init_atomic_write();
@@ -89133,7 +90201,7 @@ var SessionCatalogStore = class {
     if (!Number.isSafeInteger(entry.pid) || entry.pid <= 0)
       throw new TypeError("Invalid owner pid");
     const now = Date.now();
-    const leaseId = randomUUID42();
+    const leaseId = randomUUID44();
     const leaseSecret = randomBytes8(32).toString("hex");
     const expiresAt = now + boundedMs(leaseMs, SESSION_CATALOG_DEFAULT_LEASE_MS, MAX_LEASE_MS);
     this.db.prepare(`INSERT INTO session_leases(
@@ -89205,7 +90273,7 @@ var SessionCatalogStore = class {
       const catalog = this.db.prepare("SELECT 1 AS yes FROM sessions WHERE session_id=?").get(targetSessionId);
       if (!catalog && !fs59.existsSync(this.containedPath(`${targetSessionId}.jsonl`)))
         throw new Error(`Session not found: ${targetSessionId}`);
-      const reservationId = randomUUID42();
+      const reservationId = randomUUID44();
       const now = Date.now();
       const expiresAt = now + boundedMs(reservationMs, SESSION_CATALOG_DEFAULT_RESERVATION_MS, MAX_RESERVATION_MS);
       try {
@@ -89501,7 +90569,7 @@ var SessionCatalogStore = class {
         "SELECT 1 AS yes FROM resume_reservations WHERE target_session_id=? AND expires_at>?"
       ).get(sessionId, Date.now());
       if (reservation) throw conflict(`Session ${sessionId} is reserved for resume`);
-      const leaseId = randomUUID42();
+      const leaseId = randomUUID44();
       const now = Date.now();
       const expiresAt = now + boundedMs(leaseMs, 6e4, MAX_MAINTENANCE_MS);
       try {
@@ -90459,7 +91527,7 @@ import * as fs62 from "node:fs/promises";
 import * as path122 from "node:path";
 
 // src/session-registry-atomic-file.ts
-import { randomUUID as randomUUID43 } from "node:crypto";
+import { randomUUID as randomUUID45 } from "node:crypto";
 import * as fs61 from "node:fs/promises";
 import { hostname as hostname6 } from "node:os";
 import * as path121 from "node:path";
@@ -90532,7 +91600,7 @@ async function breakStaleLockVerified2(lockPath, verify) {
   return await breakLockAtomically2(lockPath) === true;
 }
 async function breakLockAtomically2(lockPath) {
-  const tombstone = `${lockPath}.stale-${randomUUID43()}.tmp`;
+  const tombstone = `${lockPath}.stale-${randomUUID45()}.tmp`;
   try {
     await fs61.rename(lockPath, tombstone);
   } catch {
@@ -90544,7 +91612,7 @@ async function breakLockAtomically2(lockPath) {
 async function writeAtomicFile(filePath, registry2) {
   const tmp = path121.join(
     path121.dirname(filePath),
-    `.${path121.basename(filePath)}.${randomUUID43().slice(0, 8)}.tmp`
+    `.${path121.basename(filePath)}.${randomUUID45().slice(0, 8)}.tmp`
   );
   let tmpPersisted = false;
   try {
@@ -91107,7 +92175,7 @@ var SessionRegistry = class {
 init_errors();
 init_atomic_write();
 init_error();
-import { randomUUID as randomUUID44 } from "node:crypto";
+import { randomUUID as randomUUID46 } from "node:crypto";
 import * as fs63 from "node:fs/promises";
 var FILE_VERSION = 1;
 var MAX_TEXT_LENGTH = 2e3;
@@ -91205,7 +92273,7 @@ var AnnotationsStore = class {
       });
     }
     const annotation = {
-      id: randomUUID44(),
+      id: randomUUID46(),
       sessionId: input.sessionId,
       atEventIndex: input.atEventIndex,
       authorId: input.authorId,
@@ -91558,7 +92626,7 @@ var InputHistoryStore = class {
 
 // src/storage/memory-backend.ts
 init_file_permissions();
-import { randomUUID as randomUUID45 } from "node:crypto";
+import { randomUUID as randomUUID47 } from "node:crypto";
 import * as fs65 from "node:fs/promises";
 import * as path124 from "node:path";
 
@@ -91786,7 +92854,7 @@ var FileMemoryBackend = class {
   }
   async remember(scope, entry, filePath) {
     const file = this.resolveFile(filePath, scope);
-    const id = `mem_${Date.now()}_${randomUUID45().slice(0, 8)}`;
+    const id = `mem_${Date.now()}_${randomUUID47().slice(0, 8)}`;
     const meta = formatMetadata(entry);
     const line = `- [${entry.ts}] ${id}${meta} ${entry.text.replace(/\n/g, " ")}
 `;
@@ -93800,7 +94868,7 @@ async function mutateTasks(filePath, sessionId, fn, events, traceId) {
 init_file_permissions();
 init_atomic_write();
 init_error();
-import { createHash as createHash39, randomUUID as randomUUID46 } from "node:crypto";
+import { createHash as createHash39, randomUUID as randomUUID48 } from "node:crypto";
 import * as fs70 from "node:fs/promises";
 var GENESIS_PREV = "0".repeat(64);
 var DEFAULT_FSYNC_EVERY = 100;
@@ -93845,7 +94913,7 @@ var ToolAuditLog = class {
           const tip = await this._resolveChainTip(input.sessionId, fp);
           const prevHash = tip.prevHash;
           const index = tip.nextIndex;
-          const id = randomUUID46();
+          const id = randomUUID48();
           const ts = (/* @__PURE__ */ new Date()).toISOString();
           const content = {
             id,
@@ -96386,7 +97454,7 @@ var DEFAULT_SPEC_TEMPLATE = {
 // src/worktree/worktree-manager.ts
 init_error();
 import { mkdir as mkdir35, readFile as readFile73 } from "node:fs/promises";
-import { join as join102, resolve as resolve56, sep as sep9 } from "node:path";
+import { join as join103, resolve as resolve56, sep as sep9 } from "node:path";
 
 // src/worktree/worktree-git.ts
 import { spawn as spawn13 } from "node:child_process";
@@ -96618,7 +97686,7 @@ var WorktreeManager = class {
     }
     const slug = this.makeSlug(opts.slugHint ?? ownerId);
     const branch = `wstack/ap/${slug}`;
-    const dir = join102(this.worktreesRoot(), slug);
+    const dir = join103(this.worktreesRoot(), slug);
     const absDir = resolve56(dir);
     const absRoot = resolve56(this.projectRoot);
     if (!absDir.startsWith(absRoot + sep9)) {
@@ -97009,7 +98077,7 @@ ${merged.stderr}`);
     const startMarker = /^(?:<{7,}(?: |$)|\|{7,}(?: |$))/m;
     for (const rel of paths) {
       try {
-        const content = (await readFile73(join102(this.projectRoot, rel), "utf8")).replace(/\r/g, "");
+        const content = (await readFile73(join103(this.projectRoot, rel), "utf8")).replace(/\r/g, "");
         const lines = content.split("\n");
         let seenStart = false;
         for (const line of lines) {
@@ -97053,7 +98121,7 @@ ${merged.stderr}`);
   }
   // ── internals ────────────────────────────────────────────────────────────
   worktreesRoot() {
-    return join102(this.projectRoot, ".wrongstack", "worktrees");
+    return join103(this.projectRoot, ".wrongstack", "worktrees");
   }
   async detectBaseBranch() {
     const head = await this.runGit(["rev-parse", "--abbrev-ref", "HEAD"], this.projectRoot);
@@ -97240,11 +98308,17 @@ export {
   DEFAULT_DIRECTOR_PREAMBLE,
   DEFAULT_DISPATCH_ROLE,
   DEFAULT_EAGER_SKILL_LIMIT,
+  DEFAULT_EXPLORE_COMPANION_AGENT_ID,
+  DEFAULT_EXPLORE_EDIT_TOOLS,
+  DEFAULT_EXPLORE_SEARCH_TOOLS,
   DEFAULT_FILE_EDIT_TOOLS,
   DEFAULT_HQ_REDACTION_POLICY,
+  DEFAULT_MAILBOX_POLL_INTERVAL_MS,
   DEFAULT_MAX_FLEET_SPAWNS,
   DEFAULT_MAX_ITERATIONS,
+  DEFAULT_MAX_PENDING_PROBES,
   DEFAULT_MODES,
+  DEFAULT_PROBE_COOLDOWN_MS,
   DEFAULT_QUALITY_CHECKS,
   DEFAULT_REFINER_RETRY_FEEDBACK,
   DEFAULT_SESSION_LOGGING_CONFIG,
@@ -97304,6 +98378,7 @@ export {
   EscalationRoutingBrainArbiter,
   EternalAutonomyEngine,
   EventBus,
+  ExploreCompanion,
   ExtensionRegistry,
   FALLBACK_CHAIN_MANAGE_TOOL_NAME,
   FALLBACK_PROFILE_MANAGE_TOOL_NAME,
@@ -97464,6 +98539,7 @@ export {
   QUEUE_MAX_ITEMS,
   QUEUE_MAX_ITEM_BYTES,
   QueueStore,
+  REASONING_EFFORT_LEVELS,
   REFACTOR_PLANNER_AGENT,
   REPORT_STORE_FILE,
   REVIEW_AGENTS,
@@ -97604,6 +98680,7 @@ export {
   buildNamespacePayloads,
   buildOtlpMetricsRequest,
   buildOtlpTracesRequest,
+  buildProbeTaskText,
   buildProjectContextualizedPrompt,
   buildQueuedMessagesBlock,
   buildRecoveryAlert,
@@ -97926,6 +99003,7 @@ export {
   isPrivateIPv6,
   isProjectId,
   isProvenDirective,
+  isReasoningEffort,
   isRetryableKind,
   isSafePathSegment,
   isSddError,
@@ -98000,6 +99078,7 @@ export {
   makeMailInboxTool,
   makeMailSendTool,
   makeMailboxTool,
+  makeMutationTestTool,
   makeQualityGateTool,
   makeRollUpTool,
   makeSpawnTool,