@wrongstack/core 0.313.1 → 0.316.1

package/dist/{chunk-FW5LDDMJ.js → chunk-45WI72ZB.js}

@@ -1,11 +1,15 @@
 import {
   DefaultSessionStore,
   DirectorStateCheckpoint
-} from "./chunk-UIWONWVG.js";
+} from "./chunk-NSOFPKGT.js";
 import {
+  applyTierToSubagentConfig,
+  classifyTier,
+  listTierIds,
   resolveModelMatrixResolution,
+  resolveTier,
   roleNeedsIndependentReviewModel
-} from "./chunk-2BUUIMQB.js";
+} from "./chunk-RTOTNK3P.js";
 import {
   DefaultMultiAgentCoordinator,
   FLEET_ROSTER_BUDGETS,
@@ -14,23 +18,34 @@ import {
   dispatchAgent,
   formatSubagentStructuredReport,
   nicknameKeyFromDisplay
-} from "./chunk-T3KGZBU5.js";
+} from "./chunk-S45JPKQN.js";
 import {
   getAgentDefinition
-} from "./chunk-FHAMQS7Q.js";
+} from "./chunk-FCBTO76Z.js";
+import {
+  expandGlob
+} from "./chunk-J2WRWR37.js";
+import {
+  safeParse,
+  safeStringify
+} from "./chunk-W5VITDM2.js";
+import {
+  readBundledInstructionText
+} from "./chunk-5S437PRC.js";
 import {
   applyMailboxSendPolicy,
   defaultResolveProjectDir,
   getSharedProjectMailbox,
+  postSessionNote,
   resolveMailboxIdentity
-} from "./chunk-RD6DEE36.js";
+} from "./chunk-JO4MGB6Z.js";
 import {
   MAILBOX_MAX_ACK_BATCH,
   MAILBOX_MAX_QUERY_LIMIT,
   UNREAD_CHECK_MIN_INTERVAL_MS,
   resolveSendType,
   resolveSendTypeSafe
-} from "./chunk-GM54GJBU.js";
+} from "./chunk-IRUTEHCE.js";
 import {
   MAILBOX_TYPE_PROPERTIES,
   hasMailboxCapability,
@@ -41,57 +56,51 @@ import {
   mailboxIdentityBase,
   normalizeRecipient,
   sessionRecipient
-} from "./chunk-W4A6QA3D.js";
+} from "./chunk-FWNLEZYG.js";
 import {
   scrubErrorText
-} from "./chunk-PAAWLLZX.js";
-import {
-  ToolCapabilities
-} from "./chunk-A455ATZB.js";
+} from "./chunk-Y5YXDM7D.js";
 import {
   SECRET_FILE_MODE
-} from "./chunk-H5E77KUJ.js";
-import {
-  QUOTA_EXHAUSTED_RE,
-  ROUTE_SCOPED_QUOTA_RE,
-  parseResetHintMs
-} from "./chunk-NFAYHPRH.js";
-import {
-  expandGlob
-} from "./chunk-TYW2GI5I.js";
+} from "./chunk-6FHWXLPT.js";
 import {
-  safeParse,
-  safeStringify
-} from "./chunk-RPOA7IAE.js";
-import {
-  readBundledInstructionText
-} from "./chunk-5S437PRC.js";
+  ToolCapabilities
+} from "./chunk-UBGDX6FI.js";
 import {
   renderInstructionLayer
-} from "./chunk-WZO23AWO.js";
+} from "./chunk-M27LIEKV.js";
 import {
   buildChildEnv
-} from "./chunk-VB3H5WWB.js";
+} from "./chunk-6NWEVFEL.js";
+import {
+  resolveOwningSessionId
+} from "./chunk-ZHZ2Y2DH.js";
 import {
   isPidAlive
 } from "./chunk-TRT2HRWZ.js";
 import {
   atomicWrite,
   withFileLock
-} from "./chunk-7ZHZE5EO.js";
+} from "./chunk-OSGLYW5J.js";
 import {
   resolveWstackPaths
-} from "./chunk-YNCVSFGF.js";
+} from "./chunk-SAFHACFA.js";
+import {
+  MAX_RESET_HINT_MS,
+  QUOTA_EXHAUSTED_RE,
+  ROUTE_SCOPED_QUOTA_RE,
+  parseResetHintMs
+} from "./chunk-3ECENVHL.js";
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
 import {
   AgentError,
   ERROR_CODES
-} from "./chunk-WOEZV3Q4.js";
+} from "./chunk-25LSLC3G.js";
 import {
   toErrorMessage
 } from "./chunk-TBRL2RCC.js";
-import {
-  expectDefined
-} from "./chunk-PFZO3C6H.js";
 
 // src/coordination/agent-bridge.ts
 import { randomUUID } from "node:crypto";
@@ -302,6 +311,10 @@ function attachAutoExtend(events, policy = {}) {
             Math.ceil(limit * (1 + factor)),
             ceiling.timeoutMs ?? DEFAULT_CEILING.timeoutMs
           );
+          if (next2 <= limit) {
+            deny();
+            return;
+          }
           extend({ timeoutMs: next2 });
         } else {
           deny();
@@ -317,6 +330,10 @@ function attachAutoExtend(events, policy = {}) {
       const field = FIELD_BY_KIND[kind];
       const cap = ceiling[field] ?? DEFAULT_CEILING[field];
       const next = Math.min(Math.ceil(limit * (1 + factor)), cap);
+      if (next <= limit) {
+        deny();
+        return;
+      }
       extend({ [field]: next });
     })
   ];
@@ -341,20 +358,16 @@ function editedPath(input) {
   const candidate = r["file_path"] ?? r["path"] ?? r["filePath"] ?? r["file"];
   return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
 }
+var UNATTRIBUTED_SESSION = "";
+var MAX_TRACKED_SESSIONS = 16;
 var BrainMonitor = class {
   constructor(opts) {
     this.opts = opts;
     this.applyTunables(opts);
   }
   opts;
-  failStreaks = /* @__PURE__ */ new Map();
-  errorTimestamps = [];
-  editTimestamps = /* @__PURE__ */ new Map();
-  lastEngagedAt = /* @__PURE__ */ new Map();
+  bySession = /* @__PURE__ */ new Map();
   unsubscribers = [];
-  engaging = false;
-  activeRuns = 0;
-  lastProgressAt = 0;
   stallTimer;
   // Mutable, not readonly: `reconfigure()` re-applies these live. Every knob
   // on the Brain except these used to be live-editable, so `/brain monitor …`
@@ -385,6 +398,69 @@ var BrainMonitor = class {
     const id = this.opts.leaderSessionId;
     return typeof id === "function" ? id() : id;
   }
+  /**
+   * The signal state for one session, created on first sight.
+   *
+   * A host that pins `leaderSessionId` (the CLI, one session per process) only
+   * ever reaches one bucket. A host that does not (the WebUI, four tabs on one
+   * runtime) gets one bucket per tab, which is the point.
+   */
+  stateFor(sessionId) {
+    const key = sessionId || UNATTRIBUTED_SESSION;
+    let state = this.bySession.get(key);
+    if (!state) {
+      this.pruneIdleSessions();
+      state = {
+        failStreaks: /* @__PURE__ */ new Map(),
+        errorTimestamps: [],
+        editTimestamps: /* @__PURE__ */ new Map(),
+        lastEngagedAt: /* @__PURE__ */ new Map(),
+        engaging: false,
+        activeRuns: 0,
+        lastProgressAt: 0,
+        touchedAt: Date.now()
+      };
+      this.bySession.set(key, state);
+    }
+    state.touchedAt = Date.now();
+    return state;
+  }
+  /**
+   * Drop buckets for sessions that have been quiet longer than any signal
+   * window. Without this a long-lived host accumulates one bucket per session
+   * it has ever seen — cheap individually, unbounded in aggregate.
+   *
+   * Cooldowns are the one thing worth losing sleep over here: pruning a bucket
+   * resets its rate limit. That is acceptable only because the prune horizon is
+   * strictly longer than the cooldown, so a pruned session could have engaged
+   * again anyway.
+   */
+  pruneIdleSessions() {
+    if (this.bySession.size < MAX_TRACKED_SESSIONS) return;
+    const now = Date.now();
+    const horizon = Math.max(
+      this.fileChurnWindowMs,
+      this.errorStormWindowMs,
+      this.stallMs,
+      this.cooldownMs
+    );
+    for (const [key, state] of this.bySession) {
+      if (state.engaging) continue;
+      if (now - state.touchedAt > horizon) this.bySession.delete(key);
+    }
+    if (this.bySession.size >= MAX_TRACKED_SESSIONS) {
+      let oldestKey;
+      let oldestAt = Number.POSITIVE_INFINITY;
+      for (const [key, state] of this.bySession) {
+        if (state.engaging) continue;
+        if (state.touchedAt < oldestAt) {
+          oldestAt = state.touchedAt;
+          oldestKey = key;
+        }
+      }
+      if (oldestKey !== void 0) this.bySession.delete(oldestKey);
+    }
+  }
   /** Resolve the live-tunable subset onto the instance. Shared by the constructor and `reconfigure`. */
   applyTunables(next) {
     this.toolFailureStreak = next.toolFailureStreak ?? 3;
@@ -469,18 +545,19 @@ var BrainMonitor = class {
       this.opts.events.on("tool.executed", (e) => {
         const leaderSid = this.resolveLeaderSessionId();
         if (leaderSid && e.sessionId && e.sessionId !== leaderSid) return;
-        this.lastProgressAt = Date.now();
-        this.trackFileChurn(e.name, e.ok, e.input);
+        const state = this.stateFor(e.sessionId);
+        state.lastProgressAt = Date.now();
+        this.trackFileChurn(state, e.sessionId, e.name, e.ok, e.input);
         if (!this.signals.toolFailureStreak) return;
         if (e.ok) {
-          this.failStreaks.delete(e.name);
+          state.failStreaks.delete(e.name);
           return;
         }
-        const streak = (this.failStreaks.get(e.name) ?? 0) + 1;
-        this.failStreaks.set(e.name, streak);
+        const streak = (state.failStreaks.get(e.name) ?? 0) + 1;
+        state.failStreaks.set(e.name, streak);
         if (streak >= this.toolFailureStreak) {
-          this.failStreaks.delete(e.name);
-          void this.engage("tool_failure_streak", {
+          state.failStreaks.delete(e.name);
+          void this.engage("tool_failure_streak", e.sessionId, {
             question: `The tool "${e.name}" has failed ${streak} times in a row. Should the agent be steered to a different approach?`,
             context: [
               `Tool: ${e.name}`,
@@ -496,8 +573,9 @@ var BrainMonitor = class {
         this.opts.events.on("agent.run.started", (e) => {
           const lsid = this.resolveLeaderSessionId();
           if (lsid && e.sessionId && e.sessionId !== lsid) return;
-          this.activeRuns += 1;
-          this.lastProgressAt = Date.now();
+          const state = this.stateFor(e.sessionId);
+          state.activeRuns += 1;
+          state.lastProgressAt = Date.now();
         }),
         // `agent.run.completed` is the only terminator. `Agent.run` emits it on
         // every exit path — the success path and, unconditionally, the catch
@@ -512,27 +590,30 @@ var BrainMonitor = class {
         this.opts.events.on("agent.run.completed", (e) => {
           const lsid = this.resolveLeaderSessionId();
           if (lsid && e.sessionId && e.sessionId !== lsid) return;
-          this.activeRuns = Math.max(0, this.activeRuns - 1);
+          const state = this.stateFor(e.sessionId);
+          state.activeRuns = Math.max(0, state.activeRuns - 1);
         }),
         this.opts.events.on("iteration.started", (e) => {
           const lsid = this.resolveLeaderSessionId();
           if (lsid && e.sessionId && e.sessionId !== lsid) return;
-          this.lastProgressAt = Date.now();
+          this.stateFor(e.sessionId).lastProgressAt = Date.now();
         })
       );
       this.stallTimer = setInterval(() => {
-        if (this.activeRuns === 0 || this.lastProgressAt === 0) return;
-        const idleMs = Date.now() - this.lastProgressAt;
-        if (idleMs < this.stallMs) return;
-        this.lastProgressAt = Date.now();
-        void this.engage("agent_stall", {
-          question: `An active run has made no observable progress (no tool call or iteration) for ${Math.round(idleMs / 6e4)} minute(s). Should the agent be steered before more time is wasted?`,
-          context: [
-            `Active runs: ${this.activeRuns}`,
-            `Idle for: ${Math.round(idleMs / 1e3)}s`,
-            `Stall threshold: ${Math.round(this.stallMs / 1e3)}s`
-          ].join("\n")
-        });
+        for (const [key, state] of this.bySession) {
+          if (state.activeRuns === 0 || state.lastProgressAt === 0) continue;
+          const idleMs = Date.now() - state.lastProgressAt;
+          if (idleMs < this.stallMs) continue;
+          state.lastProgressAt = Date.now();
+          void this.engage("agent_stall", key || void 0, {
+            question: `An active run has made no observable progress (no tool call or iteration) for ${Math.round(idleMs / 6e4)} minute(s). Should the agent be steered before more time is wasted?`,
+            context: [
+              `Active runs: ${state.activeRuns}`,
+              `Idle for: ${Math.round(idleMs / 1e3)}s`,
+              `Stall threshold: ${Math.round(this.stallMs / 1e3)}s`
+            ].join("\n")
+          });
+        }
       }, this.stallCheckIntervalMs);
       this.stallTimer.unref?.();
     }
@@ -542,15 +623,16 @@ var BrainMonitor = class {
         const lsid = this.resolveLeaderSessionId();
         if (lsid && e.sessionId && e.sessionId !== lsid) return;
         const now = Date.now();
-        this.errorTimestamps.push(now);
-        this.errorTimestamps = this.errorTimestamps.filter(
+        const state = this.stateFor(e.sessionId);
+        state.errorTimestamps.push(now);
+        state.errorTimestamps = state.errorTimestamps.filter(
           (t) => now - t <= this.errorStormWindowMs
         );
-        if (this.errorTimestamps.length >= this.errorStormCount) {
-          const count = this.errorTimestamps.length;
-          this.errorTimestamps = [];
+        if (state.errorTimestamps.length >= this.errorStormCount) {
+          const count = state.errorTimestamps.length;
+          state.errorTimestamps = [];
           const message = e.err instanceof Error ? e.err.message : String(e.err);
-          void this.engage("error_storm", {
+          void this.engage("error_storm", e.sessionId, {
             question: `${count} errors occurred within ${Math.round(this.errorStormWindowMs / 1e3)}s (phase: ${e.phase}). Should the agent be steered before more work is wasted?`,
             context: `Latest error: ${message.slice(0, 400)}`
           });
@@ -572,30 +654,32 @@ var BrainMonitor = class {
     this.running = false;
     for (const off of this.unsubscribers) off();
     this.unsubscribers.length = 0;
-    this.failStreaks.clear();
-    this.errorTimestamps = [];
-    this.editTimestamps.clear();
+    for (const state of this.bySession.values()) {
+      state.failStreaks.clear();
+      state.errorTimestamps = [];
+      state.editTimestamps.clear();
+      state.activeRuns = 0;
+      state.lastProgressAt = 0;
+    }
     if (this.stallTimer) {
       clearInterval(this.stallTimer);
       this.stallTimer = void 0;
     }
-    this.activeRuns = 0;
-    this.lastProgressAt = 0;
   }
   /** Sliding-window count of successful edits per file → churn signal. */
-  trackFileChurn(toolName, ok, input) {
+  trackFileChurn(state, sessionId, toolName, ok, input) {
     if (!this.signals.fileChurn) return;
     if (!ok || !this.fileEditTools.has(toolName.toLowerCase())) return;
     const path12 = editedPath(input);
     if (!path12) return;
     const now = Date.now();
-    const stamps = (this.editTimestamps.get(path12) ?? []).filter(
+    const stamps = (state.editTimestamps.get(path12) ?? []).filter(
       (t) => now - t <= this.fileChurnWindowMs
     );
     stamps.push(now);
     if (stamps.length >= this.fileChurnThreshold) {
-      this.editTimestamps.delete(path12);
-      void this.engage("file_churn", {
+      state.editTimestamps.delete(path12);
+      void this.engage("file_churn", sessionId, {
         question: `The file "${path12}" has been edited ${stamps.length} times within ${Math.round(this.fileChurnWindowMs / 6e4)} minutes \u2014 the agent may be oscillating (edit/revert loop) instead of converging. Should it be steered?`,
         context: [
           `File: ${path12}`,
@@ -605,28 +689,32 @@ var BrainMonitor = class {
       });
       return;
     }
-    if (this.editTimestamps.size >= 500 && !this.editTimestamps.has(path12)) {
-      for (const [p, times] of this.editTimestamps) {
+    if (state.editTimestamps.size >= 500 && !state.editTimestamps.has(path12)) {
+      for (const [p, times] of state.editTimestamps) {
         if (times.every((t) => now - t > this.fileChurnWindowMs)) {
-          this.editTimestamps.delete(p);
+          state.editTimestamps.delete(p);
         }
       }
-      if (this.editTimestamps.size >= 500) {
-        const oldest = this.editTimestamps.keys().next().value;
-        if (oldest !== void 0) this.editTimestamps.delete(oldest);
+      if (state.editTimestamps.size >= 500) {
+        const oldest = state.editTimestamps.keys().next().value;
+        if (oldest !== void 0) state.editTimestamps.delete(oldest);
       }
     }
-    this.editTimestamps.set(path12, stamps);
+    state.editTimestamps.set(path12, stamps);
   }
-  async engage(kind, input) {
-    const last = this.lastEngagedAt.get(kind) ?? 0;
-    if (this.engaging || Date.now() - last < this.cooldownMs) return;
-    this.engaging = true;
-    this.lastEngagedAt.set(kind, Date.now());
+  async engage(kind, sessionId, input) {
+    const state = this.stateFor(sessionId);
+    const last = state.lastEngagedAt.get(kind) ?? 0;
+    if (state.engaging || Date.now() - last < this.cooldownMs) return;
+    state.engaging = true;
+    state.lastEngagedAt.set(kind, Date.now());
     try {
       const request = {
         id: `brainmon-${randomUUID2()}`,
-        sessionId: this.opts.sessionId?.(),
+        // The session whose evidence triggered this — NOT the host's current
+        // one. They differ the moment two sessions run under one host, and
+        // taking the host's sent the steer to the wrong leader.
+        sessionId: sessionId ?? this.opts.sessionId?.(),
         source: "system",
         question: input.question,
         context: input.context,
@@ -684,7 +772,7 @@ var BrainMonitor = class {
       });
     } catch {
     } finally {
-      this.engaging = false;
+      state.engaging = false;
     }
   }
   async maybeIntervene(kind, request, decision) {
@@ -695,6 +783,7 @@ var BrainMonitor = class {
     const guidance = decision.rationale?.trim() || decision.text.trim();
     try {
       await this.opts.intervene({
+        sessionId: request.sessionId,
         subject: `Brain intervention: ${kind.replace(/_/g, " ")}`,
         body: [
           `The Brain engaged after detecting: ${request.question}`,
@@ -1846,10 +1935,10 @@ async function compactLog(opts, keepCount = 2e3) {
   const archived = log.entries.slice(0, log.entries.length - keepCount);
   const kept = log.entries.slice(-keepCount);
   const archivePath = path.join(opts.storageDir, `file-authors-archive-${Date.now()}.json`);
-  await fs.writeFile(
+  await atomicWrite(
     archivePath,
-    JSON.stringify({ projectRoot: opts.projectRoot, entries: archived }, null, 2) + "\n",
-    "utf-8"
+    `${JSON.stringify({ projectRoot: opts.projectRoot, entries: archived }, null, 2)}
+`
   );
   log.entries = kept;
   log.lastCompactedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -2034,6 +2123,16 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 import * as fsp2 from "node:fs/promises";
 import * as path3 from "node:path";
 
+// src/coordination/origin-session.ts
+function callerSessionId(ctx, fallback) {
+  const c = ctx;
+  const pinned = c?.activeRunSessionId;
+  if (typeof pinned === "string" && pinned.length > 0) return pinned;
+  const live = c?.session?.id;
+  if (typeof live === "string" && live.length > 0) return live;
+  return fallback;
+}
+
 // src/coordination/task-boundary.ts
 var PLACEHOLDER_VALUES = /* @__PURE__ */ new Set([
   "n/a",
@@ -2112,6 +2211,14 @@ var taskBoundarySchemaProperties = {
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
   const rosterIds = opts.roster ? Object.keys(opts.roster) : [];
+  const emitDelegateCompleted = (payload) => {
+    opts.events?.emit("delegate.completed", payload);
+    opts.events?.emit("subagent.done", {
+      sessionId: payload.sessionId,
+      summary: payload.summary,
+      ok: payload.ok
+    });
+  };
   const inputSchema = {
     type: "object",
     properties: {
@@ -2136,6 +2243,10 @@ function createDelegateTool(opts) {
         type: "string",
         description: "Model id within the provider. Defaults to host model."
       },
+      tier: {
+        type: "string",
+        description: "Cost/capability level for this worker: 'budget' (cheap + fast, for mechanical or well-specified work), 'standard' (the default), or 'premium' (expensive + most capable, for work where being wrong is costly). Resolved deterministically into a model, a failover chain, and a spend budget from `modelTiers` config, so you do NOT need to know any model id. Omit to let the routing table decide by role. An explicit `model` always wins over the tier.\n\nA CHEAPER TIER DOES NOT MAKE `delegate` CHEAPER FOR YOU. The leader stays fully blocked for the entire run either way \u2014 a cheap model is usually a SLOWER one, so `tier: 'budget'` on `delegate` can cost more of your wall-clock than it saves in dollars. Tier is about the worker's spend; `delegate` vs `spawn_subagent` is about your own time, and they are separate decisions. If the job is anything but short, pass the tier to `spawn_subagent` instead and keep working."
+      },
       systemPromptOverride: {
         type: "string",
         description: "Extra prompt text appended to the role baseline."
@@ -2181,7 +2292,7 @@ function createDelegateTool(opts) {
   };
   return {
     name: "delegate",
-    description: "Hand a piece of work to a subagent and block until it returns. This call is synchronous: the leader's iteration pauses for the full duration of the subagent's run. (Multiple `delegate` calls fired in the same assistant turn still parallelize through the provider's parallel-tool-call surface, but each one eats wall-clock time \u2014 so for fan-out you actually control, reach for the async path below.) Use `delegate` when your next step genuinely needs the subagent's verdict \u2014 a review, a fact-check, a sign-off. Has own context, own LLM call, auto-extending budget, and a partial-completion handoff path (maxHandoffs, default 1). Workers cannot recursively spawn.\n\n**Do NOT use `delegate` for long-running work.** While `delegate` is in flight, the leader is fully blocked \u2014 it cannot act on other tools, read mail, or react to the user. If the work might run for tens of minutes or hours (multi-file refactor, monorepo audit, long-running build/test, sweeping migration), the blocking call wastes the leader's time. Use the async tool family instead: `spawn_subagent` to create each worker (returns a `subagentId` immediately), `assign_task` to queue work on it (returns a `taskId` immediately), then `await_tasks` to retrieve results later. The leader keeps doing other work while the worker churns, and a worker that realizes its task will run long can mail the leader (type `steer` or `ask` via `mail_send`) saying *\"my task is going to run long, please spawn a subagent instead\"* so the leader re-dispatches asynchronously instead of waiting.\n\n**Do NOT use `delegate` for fan-out you control.** Multiple sequential `delegate` calls each block the leader, wasting wall-clock time. For independent investigations you want to run in parallel \u2014 security scan + bug hunt + perf review on the same PR \u2014 use the async tool family: `spawn_subagent` to create each worker (returns a `subagentId` immediately), `assign_task` to queue work on it (returns a `taskId` immediately), then the `await_tasks` tool with `{mode: 'any'}` to fold the first useful result into the next decision while the rest keep churning. Reach for `delegate` only when the result gates your next move AND the work is short enough that blocking the leader is acceptable.",
+    description: "Hand a piece of work to a subagent and block until it returns. This call is synchronous: the leader's iteration pauses for the full duration of the subagent's run. (Multiple `delegate` calls fired in the same assistant turn still parallelize through the provider's parallel-tool-call surface, but each one eats wall-clock time \u2014 so for fan-out you actually control, reach for the async path below.) Use `delegate` when your next step genuinely needs the subagent's verdict \u2014 a review, a fact-check, a sign-off. Has own context, own LLM call, auto-extending budget, and a partial-completion handoff path (maxHandoffs, default 1). Workers cannot recursively spawn.\n\n**Do NOT use `delegate` for long-running work.** While `delegate` is in flight, the leader is fully blocked \u2014 it cannot act on other tools, read mail, or react to the user. If the work might run for tens of minutes or hours (multi-file refactor, monorepo audit, long-running build/test, sweeping migration), the blocking call wastes the leader's time. Use the async tool family instead: `spawn_subagent` to create each worker (returns a `subagentId` immediately), `assign_task` to queue work on it (returns a `taskId` immediately), then `await_tasks` to retrieve results later. The leader keeps doing other work while the worker churns, and a worker that realizes its task will run long can tell the leader (type `steer` or `ask` via `session_note`, otherwise `mail_send`) saying *\"my task is going to run long, please spawn a subagent instead\"* so the leader re-dispatches asynchronously instead of waiting.\n\n**Do NOT use `delegate` for fan-out you control.** Multiple sequential `delegate` calls each block the leader, wasting wall-clock time. For independent investigations you want to run in parallel \u2014 security scan + bug hunt + perf review on the same PR \u2014 use the async tool family: `spawn_subagent` to create each worker (returns a `subagentId` immediately), `assign_task` to queue work on it (returns a `taskId` immediately), then the `await_tasks` tool with `{mode: 'any'}` to fold the first useful result into the next decision while the rest keep churning. Reach for `delegate` only when the result gates your next move AND the work is short enough that blocking the leader is acceptable.",
     usageHint: "Set `task` to the objective, then make the edges explicit: `scope` (what the work covers) and `outOfScope` (at least one concrete non-goal) are REQUIRED \u2014 the call is rejected without them, and the worker treats the rendered boundary block as a hard contract. Pick `role` from roster or pass `name` for free-form. Reach for `delegate` only when the result gates your next move AND the work is short enough that blocking the leader is acceptable (minutes, not hours). For long-running work or fan-out you control, use `spawn_subagent` + `assign_task` + `await_tasks` instead. Raise `maxHandoffs` (default 1, cap 8) for multi-day or multi-refactor tasks; pass larger `timeoutMs`/`maxIterations`/`maxToolCalls` only when needed.",
     permission: "auto",
     mutating: false,
@@ -2189,7 +2300,7 @@ function createDelegateTool(opts) {
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
     async execute(input, _ctx, execOpts) {
-      const sessionId = opts.directorRunId;
+      const sessionId = callerSessionId(_ctx, opts.directorRunId) ?? opts.directorRunId;
       const abortSignal = execOpts?.signal;
       const i = input ?? {};
       if (typeof i.task !== "string" || !i.task.trim()) {
@@ -2214,7 +2325,7 @@ function createDelegateTool(opts) {
       const launchModePreface = [
         "Launch-mode guidance (delegate): you were launched via the synchronous `delegate` tool, so the leader is blocked on this call for the full duration of your run.",
         "If, after inspecting the task, you judge it will run for tens of minutes or hours (multi-file refactor, monorepo audit, long-running build/test, sweeping migration), do NOT silently grind through it under the blocking call.",
-        'Escalate to the leader using whatever mail-style tool your role exposes \u2014 `mail_send` if available, otherwise `mailbox action=send` (some inspect-only roles expose `mailbox` rather than `mail_send`). Send a `steer` or `ask`, e.g. *"my task is going to run long, please spawn a subagent instead"*, so the leader can re-dispatch asynchronously via `spawn_subagent` + `assign_task`.',
+        'Escalate to the leader with `session_note to="leader"` when that tool is registered (same-session, next iteration). Fall back to `mail_send` or `mailbox action=send` only for cross-session mail. Send a `steer` or `ask`, e.g. *"my task is going to run long, please spawn a subagent instead"*, so the leader can re-dispatch asynchronously via `spawn_subagent` + `assign_task`.',
         'Then return a clean checkpoint with `completion:"partial"` and a concrete `remaining_work`.',
         "If the task is short and bounded, just do it end-to-end \u2014 do not over-trigger the escalation for normal work."
       ].join("\n\n");
@@ -2258,6 +2369,13 @@ function createDelegateTool(opts) {
           };
           cfg = applyRosterBudget({ ...cfg, name: i.name });
         }
+        if (i.tier) cfg.tier = i.tier;
+        const budgetPins = [];
+        if (typeof i.maxIterations === "number") budgetPins.push("maxIterations");
+        if (typeof i.maxToolCalls === "number") budgetPins.push("maxToolCalls");
+        if (typeof i.maxTokens === "number") budgetPins.push("maxTokens");
+        if (typeof i.maxCostUsd === "number") budgetPins.push("maxCostUsd");
+        if (budgetPins.length) cfg.budgetPins = budgetPins;
         if (typeof i.maxIterations === "number") {
           cfg.maxIterations = i.maxIterations;
         }
@@ -2301,7 +2419,7 @@ function createDelegateTool(opts) {
               systemPromptOverride: segments.join("\n\n")
             };
           })();
-          const subagentId = await dir.spawn(attemptConfig);
+          const subagentId = await dir.spawn({ ...attemptConfig, originSessionId: sessionId });
           if (handoffCount === 0) {
             opts.events?.emit("delegate.started", {
               sessionId,
@@ -2329,7 +2447,7 @@ function createDelegateTool(opts) {
             } catch {
             }
             const partial2 = await readSubagentPartial(opts, subagentId);
-            opts.events?.emit("delegate.completed", {
+            emitDelegateCompleted({
               sessionId,
               target,
               task: i.task,
@@ -2357,7 +2475,7 @@ function createDelegateTool(opts) {
             } catch {
             }
             const partial2 = await readSubagentPartial(opts, subagentId);
-            opts.events?.emit("delegate.completed", {
+            emitDelegateCompleted({
               sessionId,
               target,
               task: i.task,
@@ -2382,7 +2500,7 @@ function createDelegateTool(opts) {
           }
           if ("__emptyResult" in result) {
             const partial2 = await readSubagentPartial(opts, subagentId);
-            opts.events?.emit("delegate.completed", {
+            emitDelegateCompleted({
               sessionId,
               target,
               task: i.task,
@@ -2436,7 +2554,7 @@ function createDelegateTool(opts) {
           } catch {
             costUsd = void 0;
           }
-          opts.events?.emit("delegate.completed", {
+          emitDelegateCompleted({
             sessionId,
             target,
             task: i.task,
@@ -2474,7 +2592,7 @@ function createDelegateTool(opts) {
         }
       } catch (err) {
         const message = toErrorMessage(err);
-        opts.events?.emit("delegate.completed", {
+        emitDelegateCompleted({
           sessionId,
           target,
           task: i.task,
@@ -2570,7 +2688,7 @@ function buildHandoffTask(originalTask, continuation, handoffCount, maxHandoffs)
     `Continue an oversized delegated task as fresh worker ${handoffCount} of ${maxHandoffs}.`,
     "Do not blindly repeat completed actions. Inspect the current workspace, git diff, tests, and any files named below before changing anything.",
     'If the remaining work is still too large, stop at a clean checkpoint and call submit_result with completion="partial" plus concrete remaining_work.',
-    "If parallel help would materially improve the outcome and mail_send is available, send the leader an `ask` that names the exact helper task; do not spawn agents yourself.",
+    'If parallel help would materially improve the outcome, `session_note to="leader" kind="ask"` (or `mail_send` if you must reach another session) naming the exact helper task; do not spawn agents yourself.',
     `Original task:
 ${originalTask}`,
     `Prior checkpoint summary:
@@ -2733,12 +2851,16 @@ var DEFAULT_EXPLORE_EDIT_TOOLS = [
   "str_replace"
 ];
 var DEFAULT_EXPLORE_SEARCH_TOOLS = [
-  "search",
   "grep",
   "codebase-search"
 ];
 function buildProbeTaskText(probe) {
-  const payload = { probe: probe.probe };
+  const payload = {
+    probe: probe.probe,
+    // Repeated on every assign so a long-lived resident cannot treat a
+    // later probe as permission to keep mapping the previous subject.
+    scope: "Help the leader, then stop. Answer only this probe with codebase-* tools first. Do not map adjacent files, features, tests, or docs unless named in probe/hint. Do not reindex. Deliver via submit_result only."
+  };
   if (probe.hint) payload.hint = probe.hint;
   if (probe.context) payload.context = probe.context;
   return JSON.stringify(payload, null, 2);
@@ -2903,7 +3025,7 @@ var ExploreCompanion = class {
       if (!this.readSet.has(path12)) {
         this.engage({
           id: randomUUID5(),
-          probe: `Map file ${path12}: role, exports, dependencies, and callers \u2014 the leader is about to edit it.`,
+          probe: `Map file ${path12} for the leader: role, exports, incoming/outgoing calls, and blast radius if they edit it.`,
           hint: { file: path12 },
           context: `Leader edited ${path12} without reading it first.`,
           source: "edit_unread_file",
@@ -2918,7 +3040,7 @@ var ExploreCompanion = class {
         this.readSet.add(path12);
         this.engage({
           id: randomUUID5(),
-          probe: `Skeleton + callers + dependents of ${path12}: what it exports, who imports it, and how it fits the feature flow.`,
+          probe: `Give the leader a skeleton of ${path12} plus callers and dependents \u2014 what it exports, who imports it.`,
           hint: { file: path12 },
           context: `Leader read unfamiliar file ${path12}.`,
           source: "unfamiliar_read",
@@ -2933,7 +3055,7 @@ var ExploreCompanion = class {
       const query = typeof input["query"] === "string" ? input["query"] : typeof input["pattern"] === "string" ? input["pattern"] : "";
       this.engage({
         id: randomUUID5(),
-        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.`,
+        probe: query ? `Locate "${query}" for the leader \u2014 ${e.name} returned no hits. Try codebase-search synonyms, then grep/glob. Do not reindex.` : `The leader's ${e.name} returned no results. Find where the concept actually lives via codebase-search, then grep/glob. Do not reindex.`,
         hint: query ? { symbol: query } : void 0,
         context: `${e.name} for "${query}" returned zero results.`,
         source: "search_zero_hits",
@@ -2954,7 +3076,7 @@ var ExploreCompanion = class {
         const first = mentions[0];
         this.engage({
           id: randomUUID5(),
-          probe: `Pre-map the files/symbols behind this in-progress todo: "${todo.content.slice(0, 160)}".`,
+          probe: `Pre-map files/symbols for the leader's in-progress todo so they can start already oriented: "${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",
@@ -2970,7 +3092,7 @@ var ExploreCompanion = class {
     for (const token of tokens.slice(0, 2)) {
       this.engage({
         id: randomUUID5(),
-        probe: `What is ${token.value}, where does it live, and who uses it? The leader hit an error naming it.`,
+        probe: `What is ${token.value}, where does it live, and who uses it? Answer so the leader can recover from the error that named it.`,
         hint: { [token.kind]: token.value },
         context: `Error: ${err.message.slice(0, 300)}`,
         source: "error_symbol",
@@ -3339,11 +3461,7 @@ var DirectorBudgetPolicy = class {
         }
         const payload = event.payload;
         if (payload.kind === "timeout" || payload.kind === "idle_timeout") {
-          this.handleTimeoutThreshold(
-            event.subagentId,
-            event.taskId,
-            payload
-          );
+          this.handleTimeoutThreshold(event.subagentId, event.taskId, payload);
           return;
         }
         const guardKey = `${event.subagentId}:${payload.kind}`;
@@ -3360,13 +3478,7 @@ var DirectorBudgetPolicy = class {
             return;
           }
         }
-        const grant = () => this.grantBoundedExtension(
-          event.subagentId,
-          event.taskId,
-          payload,
-          guardKey,
-          prior
-        );
+        const grant = () => this.grantBoundedExtension(event.subagentId, event.taskId, payload, guardKey, prior);
         if (payload.kind !== "cost" || !this.deps.brain) {
           grant();
           return;
@@ -3490,12 +3602,18 @@ var DirectorBudgetPolicy = class {
   recordExtension(subagentId, taskId, kind, newLimit) {
     const total = (this.extendTotals.get(subagentId) ?? 0) + 1;
     this.extendTotals.set(subagentId, total);
+    const sessionId = this.deps.currentSessionId?.();
     this.deps.fleet.emit({
       subagentId,
       taskId,
       ts: Date.now(),
       type: "budget.extended",
-      payload: { kind, newLimit, totalExtensions: total }
+      payload: {
+        ...sessionId ? { sessionId } : {},
+        kind,
+        newLimit,
+        totalExtensions: total
+      }
     });
   }
   isCollabAgent(subagentId) {
@@ -3909,21 +4027,6 @@ ${JSON.stringify(result.result, null, 2)}
 // src/coordination/director-tools.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
 
-// src/coordination/kanban-dispatch-port.ts
-var notWired = () => {
-  throw new Error(
-    "Kanban dispatch port is not wired \u2014 register the implementation at the CLI composition root (see setKanbanDispatch)."
-  );
-};
-var port = void 0;
-function setKanbanDispatch(impl) {
-  port = impl;
-}
-function kanbanDispatch() {
-  if (!port) notWired();
-  return port;
-}
-
 // src/coordination/director-input-helpers.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 function stringArray(value) {
@@ -3944,17 +4047,17 @@ function instantiateRosterConfig2(role, base) {
 }
 
 // src/coordination/kanban-ops-port.ts
-var notWired2 = () => {
+var notWired = () => {
   throw new Error(
     "KanbanBoundaryOpsPort is not wired \u2014 register the implementation at the CLI composition root (see setKanbanBoundaryOps)."
   );
 };
-var port2 = void 0;
+var port;
 function setKanbanBoundaryOps(impl) {
-  port2 = impl;
+  port = impl;
 }
 function kanbanBoundaryOps() {
-  return port2 ?? notWired2();
+  return port ?? notWired();
 }
 
 // src/coordination/director-kanban-queue-helpers.ts
@@ -3974,6 +4077,7 @@ function normalizeKanbanQueueInput(input) {
     role: typeof raw.role === "string" ? raw.role : void 0,
     provider: typeof raw.provider === "string" ? raw.provider : void 0,
     model: typeof raw.model === "string" ? raw.model : void 0,
+    tier: typeof raw.tier === "string" ? raw.tier : void 0,
     fallbackModels: stringArray(raw.fallbackModels),
     tools: stringArray(raw.tools),
     allowedCapabilities: stringArray(raw.allowedCapabilities),
@@ -3998,7 +4102,10 @@ function buildKanbanSubagentConfig(task, input, roster, instantiateRosterConfig3
     ...tools ? { tools: ensureKanbanTool(tools) } : {},
     ...input.allowedCapabilities ?? assignment?.allowedCapabilities ? { allowedCapabilities: input.allowedCapabilities ?? assignment?.allowedCapabilities } : {},
     ...input.worktree !== void 0 ? { worktree: input.worktree } : {},
-    ...assignment?.costCeilingUsd !== void 0 ? { maxCostUsd: assignment.costCeilingUsd } : {}
+    ...input.tier ?? assignment?.tier ? { tier: input.tier ?? assignment?.tier } : {},
+    // A board's cost ceiling is an explicit decision by whoever queued the task,
+    // so it is pinned: the tier layer may tighten a roster default, never this.
+    ...assignment?.costCeilingUsd !== void 0 ? { maxCostUsd: assignment.costCeilingUsd, budgetPins: ["maxCostUsd"] } : {}
   };
 }
 function matchesKanbanQueueQuery(task, query) {
@@ -4125,6 +4232,21 @@ function ensureKanbanTool(tools) {
   return tools.includes("kanban") ? [...tools] : [...tools, "kanban"];
 }
 
+// src/coordination/kanban-dispatch-port.ts
+var notWired2 = () => {
+  throw new Error(
+    "Kanban dispatch port is not wired \u2014 register the implementation at the CLI composition root (see setKanbanDispatch)."
+  );
+};
+var port2;
+function setKanbanDispatch(impl) {
+  port2 = impl;
+}
+function kanbanDispatch() {
+  if (!port2) notWired2();
+  return port2;
+}
+
 // src/coordination/director-basic-tools.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
 function makeAssignTool(director) {
@@ -4584,998 +4706,1008 @@ function makeWorkCompleteTool(director) {
   };
 }
 
-// src/coordination/director-quality-gate-tool.ts
+// src/coordination/director-mutation-test-tool.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-function makeQualityGateTool(director, roster) {
-  return {
-    name: "quality_gate",
-    description: "Run a first-class implementation quality gate. It can await implementer task ids, spawn independent verifier/reviewer agents, summarize their verdicts, and optionally send must-fix feedback back to an implementer until the gate passes or the repair-attempt limit is reached.",
-    usageHint: "Use after code-changing work. Provide implementerTaskIds when available. Add repairSubagentId to iterate fixes automatically. Verdict only passes when every enabled reviewer/verifier explicitly passes.",
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
-    inputSchema: {
-      type: "object",
-      properties: {
-        task: {
-          type: "string",
-          description: "Original implementation task or acceptance goal being gated."
-        },
-        implementerTaskIds: {
-          type: "array",
-          items: { type: "string" },
-          description: "Optional completed or in-flight implementer task ids to await and include as implementation evidence."
-        },
-        repairSubagentId: {
-          type: "string",
-          description: "Optional implementer subagent id. When set and the gate fails, quality_gate assigns a repair task with reviewer/verifier feedback and reruns the gate."
-        },
-        maxRepairAttempts: {
-          type: "number",
-          minimum: 0,
-          maximum: 5,
-          description: "Maximum automatic repair iterations. Default: 2 when repairSubagentId is set, otherwise 0."
-        },
-        targets: {
-          type: "array",
-          items: { type: "string" },
-          description: "Files, packages, or paths that reviewer/verifier should focus on."
-        },
-        commands: {
-          type: "array",
-          items: { type: "string" },
-          description: 'Verification commands that should pass, e.g. ["pnpm --filter @wrongstack/core typecheck"].'
-        },
-        expected: {
-          type: "string",
-          description: "Expected behavior or acceptance criteria."
-        },
-        evidence: {
-          type: "string",
-          description: "Known implementation notes, diff summary, or commands already run."
-        },
-        reviewer: {
-          type: "boolean",
-          description: "Whether to run the reviewer lane. Default true."
-        },
-        verifier: {
-          type: "boolean",
-          description: "Whether to run the verifier lane. Default true."
-        },
-        timeoutMs: {
-          type: "number",
-          minimum: 1,
-          description: "Optional per reviewer/verifier/repair task timeout."
-        },
-        reviewerWorktree: {
-          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
-          description: "Reviewer worktree override. Default off because reviewer is read-only."
-        },
-        verifierWorktree: {
-          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
-          description: "Verifier worktree override. Default auto so test artifacts stay isolated when fleet policy wants it."
+import { readFileSync } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join3 } 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;",
+    endpointsInCode: true
+  }
+];
+function planMutations(file, source, opts = {}) {
+  const maxPerFile = opts.maxPerFile ?? 25;
+  const out = [];
+  const lines = source.split("\n");
+  const masks = computeLineMasks(source);
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const line = lines[lineIdx];
+    const t = line.trim();
+    if (t.startsWith("//")) continue;
+    const codeRanges = masks[lineIdx];
+    const inCode = (start) => codeRanges.some(([s, e]) => start >= s && start < e);
+    for (const pattern of TOKEN_PATTERNS) {
+      pattern.regex.lastIndex = 0;
+      let m = pattern.regex.exec(line);
+      while (m !== null) {
+        const token = m.groups?.["op"] ?? m[0];
+        const tokenStart = m.index + m[0].indexOf(token);
+        if (!inCode(tokenStart)) {
+          m = pattern.regex.exec(line);
+          continue;
         }
+        if (pattern.endpointsInCode && !inCode(tokenStart + token.length - 1)) {
+          m = pattern.regex.exec(line);
+          continue;
+        }
+        const original = line.slice(tokenStart, tokenStart + token.length);
+        const replacement = pattern.replace(token);
+        if (replacement === original) {
+          m = pattern.regex.exec(line);
+          continue;
+        }
+        out.push({
+          id: `${pattern.kind}#${lineIdx + 1}#${tokenStart + 1}`,
+          kind: pattern.kind,
+          file,
+          line: lineIdx + 1,
+          column: tokenStart + 1,
+          original,
+          replacement
+        });
+        m = pattern.regex.exec(line);
       }
-    },
-    async execute(input) {
-      const i = normalizeQualityGateInput(input);
-      const runReviewer = i.reviewer !== false;
-      const runVerifier = i.verifier !== false;
-      if (!runReviewer && !runVerifier) {
-        return {
-          verdict: "inconclusive",
-          passed: false,
-          error: "quality_gate requires reviewer, verifier, or both."
-        };
+    }
+    if (out.length >= maxPerFile) break;
+  }
+  return out.slice(0, maxPerFile);
+}
+function computeLineMasks(source) {
+  const lines = source.split("\n");
+  const masks = lines.map(() => []);
+  const stack = [{ kind: "code", depth: 0, parens: [] }];
+  let inBlockComment = false;
+  let lastToken = null;
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const line = lines[lineIdx];
+    const ranges = masks[lineIdx];
+    let runStart = null;
+    const closeRun = (end) => {
+      if (runStart !== null && end > runStart) ranges.push([runStart, end]);
+      runStart = null;
+    };
+    let i = 0;
+    if (inBlockComment) {
+      const close = line.indexOf("*/");
+      if (close === -1) continue;
+      inBlockComment = false;
+      i = close + 2;
+    }
+    while (i < line.length) {
+      const top = stack[stack.length - 1];
+      const c = line[i];
+      if (top.kind === "template") {
+        if (c === "\\") {
+          i += 2;
+          continue;
+        }
+        if (c === "`") {
+          stack.pop();
+          lastToken = "`";
+          i++;
+          continue;
+        }
+        if (c === "$" && line[i + 1] === "{") {
+          stack.push({ kind: "code", depth: 0, parens: [] });
+          lastToken = "${";
+          i += 2;
+          continue;
+        }
+        i++;
+        continue;
       }
-      const implementerResults = i.implementerTaskIds && i.implementerTaskIds.length > 0 ? await director.awaitTasks(i.implementerTaskIds) : [];
-      const maxRepairAttempts = clampRepairAttempts(
-        i.maxRepairAttempts ?? (i.repairSubagentId ? 2 : 0)
-      );
-      const repairResults = [];
-      const attempts = [];
-      for (let attempt = 1; ; attempt++) {
-        const gateTaskIds = [];
-        const taskRoleById = /* @__PURE__ */ new Map();
-        if (runVerifier) {
-          const subagentId = await director.spawn(
-            makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
-          );
-          const taskId = await director.assign({
-            id: randomUUID9(),
-            subagentId,
-            description: buildVerifierTask(i, {
-              attempt,
-              implementerResults,
-              repairResults,
-              priorAttempts: attempts
-            }),
-            timeoutMs: i.timeoutMs
-          });
-          gateTaskIds.push(taskId);
-          taskRoleById.set(taskId, "verifier");
+      if (/[\w$]/.test(c)) {
+        let j = i + 1;
+        while (j < line.length && /[\w$]/.test(line[j])) j++;
+        lastToken = line.slice(i, j);
+        if (runStart === null) runStart = i;
+        i = j;
+        continue;
+      }
+      if (c === "'" || c === '"') {
+        closeRun(i);
+        i++;
+        while (i < line.length && line[i] !== c) {
+          if (line[i] === "\\") i++;
+          i++;
         }
-        if (runReviewer) {
-          const subagentId = await director.spawn(
-            makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
-          );
-          const taskId = await director.assign({
-            id: randomUUID9(),
-            subagentId,
-            description: buildReviewerTask(i, {
-              attempt,
-              implementerResults,
-              repairResults,
-              priorAttempts: attempts
-            }),
-            timeoutMs: i.timeoutMs
-          });
-          gateTaskIds.push(taskId);
-          taskRoleById.set(taskId, "reviewer");
+        i++;
+        lastToken = c;
+        continue;
+      }
+      if (c === "`") {
+        closeRun(i);
+        stack.push({ kind: "template", depth: 0, parens: [] });
+        i++;
+        continue;
+      }
+      if (c === "/" && line[i + 1] === "/") {
+        closeRun(i);
+        break;
+      }
+      if (c === "/" && line[i + 1] === "*") {
+        closeRun(i);
+        const close = line.indexOf("*/", i + 2);
+        if (close === -1) {
+          inBlockComment = true;
+          break;
         }
-        const gateResults = await director.awaitTasks(gateTaskIds);
-        const reports = gateResults.map((r) => assessRoleResult(taskRoleById.get(r.taskId), r));
-        const assessment = assessQualityGate(reports);
-        attempts.push({ attempt, reports, ...assessment });
-        if (assessment.passed || !i.repairSubagentId || attempt > maxRepairAttempts) {
-          return {
-            verdict: assessment.verdict,
-            passed: assessment.passed,
-            attempts,
-            repairAttemptsUsed: repairResults.length,
-            implementerResults: implementerResults.map(summarizeTaskResult),
-            nextAction: assessment.passed ? "accept" : i.repairSubagentId && attempt > maxRepairAttempts ? "manual_intervention_or_raise_repair_limit" : "inspect_failures"
-          };
+        i = close + 2;
+        continue;
+      }
+      if (c === "/") {
+        if (!tokenCanEndOperand(lastToken)) {
+          closeRun(i);
+          const next = skipRegexLiteral(line, i);
+          lastToken = next > i + 1 ? "regex" : "/";
+          i = next;
+          continue;
         }
-        const repairTaskId = await director.assign({
-          id: randomUUID9(),
-          subagentId: i.repairSubagentId,
-          description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
-          timeoutMs: i.timeoutMs
-        });
-        const [repairResult] = await director.awaitTasks([repairTaskId]);
-        if (repairResult) repairResults.push(repairResult);
-        if (repairResult?.status !== "success") {
-          return {
-            verdict: "fail",
-            passed: false,
-            attempts,
-            repairAttemptsUsed: repairResults.length,
-            repairResult: repairResult ? summarizeTaskResult(repairResult) : void 0,
-            implementerResults: implementerResults.map(summarizeTaskResult),
-            nextAction: "repair_failed"
-          };
+      }
+      if (c === "(") {
+        top.parens.push(CONTROL_KEYWORDS.has(lastToken ?? "") ? "control" : "expr");
+        lastToken = c;
+      } else if (c === ")") {
+        const kind = top.parens.pop() ?? "expr";
+        lastToken = kind === "control" ? "control-paren-close" : ")";
+      } else if (c === "{") {
+        top.depth++;
+        lastToken = c;
+      } else if (c === "}") {
+        if (top.depth > 0) {
+          top.depth--;
+          lastToken = c;
+        } else if (stack.length > 1) {
+          closeRun(i);
+          stack.pop();
+          i++;
+          continue;
+        } else {
+          lastToken = c;
         }
+      } else if (c !== " " && c !== "	" && c !== "\r") {
+        lastToken = c;
       }
+      if (runStart === null) runStart = i;
+      i++;
     }
-  };
-}
-function normalizeQualityGateInput(input) {
-  const raw = input ?? {};
-  return {
-    task: typeof raw.task === "string" ? raw.task : void 0,
-    implementerTaskIds: stringArray(raw.implementerTaskIds),
-    repairSubagentId: typeof raw.repairSubagentId === "string" && raw.repairSubagentId.trim() ? raw.repairSubagentId.trim() : void 0,
-    maxRepairAttempts: typeof raw.maxRepairAttempts === "number" ? raw.maxRepairAttempts : void 0,
-    targets: stringArray(raw.targets),
-    commands: stringArray(raw.commands),
-    expected: typeof raw.expected === "string" ? raw.expected : void 0,
-    evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
-    reviewer: typeof raw.reviewer === "boolean" ? raw.reviewer : void 0,
-    verifier: typeof raw.verifier === "boolean" ? raw.verifier : void 0,
-    timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : void 0,
-    reviewerWorktree: normalizeWorktreeOverride(raw.reviewerWorktree),
-    verifierWorktree: normalizeWorktreeOverride(raw.verifierWorktree)
-  };
-}
-function clampRepairAttempts(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(5, Math.floor(value)));
+    closeRun(line.length);
+  }
+  return masks;
 }
-function makeQualityGateSubagentConfig(role, roster, worktree) {
-  const base = roster?.[role] ?? getAgentDefinition(role)?.config ?? { name: role, role };
-  return {
-    ...instantiateRosterConfig2(role, base),
-    worktree
-  };
+var KEYWORDS_BEFORE_REGEX = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+var CONTROL_KEYWORDS = /* @__PURE__ */ new Set(["if", "for", "while", "switch", "catch", "with", "await"]);
+function tokenCanEndOperand(token) {
+  if (token === null) return false;
+  if (/^[\w$]+$/.test(token)) return !KEYWORDS_BEFORE_REGEX.has(token);
+  return token === ")" || token === "]" || token === "." || token === '"' || token === "'" || token === "`";
 }
-function buildVerifierTask(input, state) {
-  return [
-    "Run the independent verification gate for this implementation.",
-    "Return Markdown with `## Verdict` and make the first verdict word exactly `pass`, `fail`, or `blocked`.",
-    "Do not edit code. Run the smallest meaningful command set and include exact failures.",
-    "",
-    `Gate attempt: ${state.attempt}`,
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.commands?.length ? `Required or suggested commands:
-${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    input.evidence ? `Known evidence:
-${input.evidence}` : void 0,
-    taskResultsBlock("Implementer results", state.implementerResults),
-    taskResultsBlock("Repair results so far", state.repairResults),
-    priorAttemptsBlock(state.priorAttempts)
-  ].filter((part) => !!part).join("\n\n");
-}
-function buildReviewerTask(input, state) {
-  return [
-    "Run independent code review for this implementation.",
-    "Return Markdown with `## Verdict` and make the first verdict phrase exactly `approve`, `request changes`, or `needs verification`.",
-    "Do not edit code. Treat missing proof, vague tests, and uncertainty as blocking until verifier evidence exists.",
-    "",
-    `Gate attempt: ${state.attempt}`,
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    input.evidence ? `Known evidence:
-${input.evidence}` : void 0,
-    taskResultsBlock("Implementer results", state.implementerResults),
-    taskResultsBlock("Repair results so far", state.repairResults),
-    priorAttemptsBlock(state.priorAttempts)
-  ].filter((part) => !!part).join("\n\n");
-}
-function buildRepairTask(input, attempt, attemptNumber) {
-  return [
-    `Repair the implementation after quality gate attempt ${attemptNumber} failed.`,
-    "Address every must-fix item. Run relevant checks before returning.",
-    "Do not claim done unless verifier/reviewer feedback is resolved.",
-    "",
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.commands?.length ? `Commands expected to pass:
-${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    attempt.mustFix.length ? `Must fix:
-${attempt.mustFix.map((f) => `- ${f}`).join("\n")}` : void 0,
-    attempt.uncertaintyFlags.length ? `Uncertainty flags to resolve:
-${attempt.uncertaintyFlags.map((f) => `- ${f}`).join("\n")}` : void 0,
-    `Reviewer/verifier reports:
-${attempt.reports.map((r) => `### ${r.role} (${r.verdict})
-${r.summary}`).join("\n\n")}`
-  ].filter((part) => !!part).join("\n\n");
-}
-function taskResultsBlock(title, results) {
-  if (results.length === 0) return void 0;
-  return `${title}:
-${results.map((r) => `### ${r.subagentId}/${r.taskId}
-${summarizeTaskResult(r).summary}`).join("\n\n")}`;
-}
-function priorAttemptsBlock(attempts) {
-  if (attempts.length === 0) return void 0;
-  return `Prior quality gate attempts:
-${attempts.map(
-    (a) => `### Attempt ${a.attempt}
-${a.reports.map((r) => `- ${r.role}: ${r.verdict}${r.error ? ` (${r.error})` : ""}`).join("\n")}`
-  ).join("\n\n")}`;
-}
-function summarizeTaskResult(result) {
-  const text = typeof result.result === "string" ? result.result : result.result !== void 0 ? JSON.stringify(result.result, null, 2) : "";
-  const error = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
-  return {
-    taskId: result.taskId,
-    subagentId: result.subagentId,
-    status: result.status,
-    summary: excerpt(text || error || "(no output)", 4e3),
-    error
-  };
-}
-function assessRoleResult(role, result) {
-  const resolvedRole = role ?? (result.subagentId.includes("review") ? "reviewer" : "verifier");
-  const summary = summarizeTaskResult(result);
-  const text = summary.summary;
-  const uncertaintyFlags = extractSection(text, "Uncertainty Flags");
-  if (result.status !== "success") {
-    return {
-      role: resolvedRole,
-      subagentId: result.subagentId,
-      taskId: result.taskId,
-      status: result.status,
-      verdict: "fail",
-      summary: text,
-      uncertaintyFlags,
-      error: summary.error ?? result.status
-    };
+function skipRegexLiteral(line, start) {
+  let i = start + 1;
+  let inClass = false;
+  while (i < line.length) {
+    const ch = line[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (inClass) {
+      if (ch === "]") inClass = false;
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      inClass = true;
+      i++;
+      continue;
+    }
+    if (ch === "/") {
+      i++;
+      break;
+    }
+    if (ch === "\n" || ch === "\r") return line.length;
+    i++;
   }
-  return {
-    role: resolvedRole,
-    subagentId: result.subagentId,
-    taskId: result.taskId,
-    status: result.status,
-    verdict: parseQualityVerdict(resolvedRole, text),
-    summary: text,
-    uncertaintyFlags
-  };
+  while (i < line.length && /[a-z]/.test(line[i])) i++;
+  return i;
 }
-function assessQualityGate(reports) {
-  const mustFix = [];
-  const uncertaintyFlags = [];
-  let hasFail = false;
-  let hasInconclusive = false;
-  for (const report of reports) {
-    if (report.verdict === "fail") hasFail = true;
-    if (report.verdict === "inconclusive") hasInconclusive = true;
-    const blocking = extractSection(report.summary, "Must Fix") || extractSection(report.summary, "Failures") || extractSection(report.summary, "Verification Gaps");
-    if (blocking) mustFix.push(`${report.role}: ${excerpt(blocking, 1e3)}`);
-    if (report.uncertaintyFlags) {
-      uncertaintyFlags.push(`${report.role}: ${excerpt(report.uncertaintyFlags, 1e3)}`);
+function parseMutationReport(text) {
+  const candidates = [];
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fence?.[1]) candidates.push(fence[1].trim());
+  const firstBrace = text.indexOf("{");
+  if (firstBrace >= 0) candidates.push(extractBalancedObject(text, 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 {
     }
-    if (report.error) mustFix.push(`${report.role}: ${report.error}`);
-  }
-  if (hasFail) return { verdict: "fail", passed: false, mustFix, uncertaintyFlags };
-  if (hasInconclusive || reports.length === 0) {
-    return { verdict: "inconclusive", passed: false, mustFix, uncertaintyFlags };
   }
-  return { verdict: "pass", passed: true, mustFix, uncertaintyFlags };
+  return void 0;
 }
-function parseQualityVerdict(role, text) {
-  const normalized = text.toLowerCase();
-  const verdictBlock = normalized.match(/(?:^|\n)\s*(?:#+\s*)?verdict\b[^\n]*(?:\n|:|-)?([\s\S]{0,500})/)?.[0] ?? normalized.slice(0, 1e3);
-  if (role === "reviewer") {
-    if (/\b(request\s+changes|needs\s+verification|reject|rejected|fail|failed|blocked)\b/.test(
-      verdictBlock
-    )) {
-      return "fail";
+function extractBalancedObject(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const c = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
     }
-    if (/\b(approve|approved|pass|passed)\b/.test(verdictBlock)) return "pass";
-    if (sectionHasBlockingContent(text, "Must Fix") || sectionHasBlockingContent(text, "Verification Gaps")) {
-      return "fail";
+    if (c === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (c === '"') inString = !inString;
+    if (inString) continue;
+    if (c === "{") depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
     }
-    return "inconclusive";
   }
-  if (/\b(fail|failed|blocked|red)\b/.test(verdictBlock)) return "fail";
-  if (/\b(pass|passed|green|approve|approved)\b/.test(verdictBlock)) return "pass";
-  if (sectionHasBlockingContent(text, "Failures")) return "fail";
-  return "inconclusive";
-}
-function sectionHasBlockingContent(text, heading) {
-  const section = extractSection(text, heading);
-  if (!section) return false;
-  return !/^\s*(none|n\/a|no\b|no issues|empty|\(none\))\s*\.?\s*$/i.test(section.trim());
-}
-function extractSection(text, heading) {
-  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(
-    `(?:^|\\n)\\s*#{1,6}\\s*${escaped}\\s*\\n([\\s\\S]*?)(?=\\n\\s*#{1,6}\\s+|$)`,
-    "i"
-  );
-  const match = text.match(pattern);
-  const body = match?.[1]?.trim();
-  return body ? body : void 0;
+  return text.slice(start);
 }
-function excerpt(text, max) {
-  if (text.length <= max) return text;
-  return `${text.slice(0, max - 20).trimEnd()}
-...(truncated)`;
+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" && status !== "killed-by-hang") {
+    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
-import { randomUUID as randomUUID10 } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join3 } 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;",
-    endpointsInCode: true
-  }
-];
-function planMutations(file, source, opts = {}) {
-  const maxPerFile = opts.maxPerFile ?? 25;
-  const out = [];
-  const lines = source.split("\n");
-  const masks = computeLineMasks(source);
-  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-    const line = lines[lineIdx];
-    const t = line.trim();
-    if (t.startsWith("//")) continue;
-    const codeRanges = masks[lineIdx];
-    const inCode = (start) => codeRanges.some(([s, e]) => start >= s && start < e);
-    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 (!inCode(tokenStart)) continue;
-        if (pattern.endpointsInCode && !inCode(tokenStart + token.length - 1)) 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 computeLineMasks(source) {
-  const lines = source.split("\n");
-  const masks = lines.map(() => []);
-  const stack = [{ kind: "code", depth: 0, parens: [] }];
-  let inBlockComment = false;
-  let lastToken = null;
-  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-    const line = lines[lineIdx];
-    const ranges = masks[lineIdx];
-    let runStart = null;
-    const closeRun = (end) => {
-      if (runStart !== null && end > runStart) ranges.push([runStart, end]);
-      runStart = null;
-    };
-    let i = 0;
-    if (inBlockComment) {
-      const close = line.indexOf("*/");
-      if (close === -1) continue;
-      inBlockComment = false;
-      i = close + 2;
-    }
-    while (i < line.length) {
-      const top = stack[stack.length - 1];
-      const c = line[i];
-      if (top.kind === "template") {
-        if (c === "\\") {
-          i += 2;
-          continue;
-        }
-        if (c === "`") {
-          stack.pop();
-          lastToken = "`";
-          i++;
-          continue;
-        }
-        if (c === "$" && line[i + 1] === "{") {
-          stack.push({ kind: "code", depth: 0, parens: [] });
-          lastToken = "${";
-          i += 2;
-          continue;
-        }
-        i++;
-        continue;
-      }
-      if (/[\w$]/.test(c)) {
-        let j = i + 1;
-        while (j < line.length && /[\w$]/.test(line[j])) j++;
-        lastToken = line.slice(i, j);
-        if (runStart === null) runStart = i;
-        i = j;
-        continue;
-      }
-      if (c === "'" || c === '"') {
-        closeRun(i);
-        i++;
-        while (i < line.length && line[i] !== c) {
-          if (line[i] === "\\") i++;
-          i++;
+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. Defaults to the roster policy for chaos-monkey ('off'), because mutation targets are usually freshly written and uncommitted \u2014 a worktree from HEAD would not contain them and every mutant would drift to skipped. Only pass 'auto' or 'required' when the targets are committed."
+        },
+        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."
         }
-        i++;
-        lastToken = c;
-        continue;
-      }
-      if (c === "`") {
-        closeRun(i);
-        stack.push({ kind: "template", depth: 0, parens: [] });
-        i++;
-        continue;
+      },
+      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)."
+        };
       }
-      if (c === "/" && line[i + 1] === "/") {
-        closeRun(i);
-        break;
+      const chaosBase = roster?.[CHAOS_ROLE];
+      if (!chaosBase) {
+        return {
+          verdict: "inconclusive",
+          passed: false,
+          error: "chaos-monkey role missing from the roster \u2014 refusing to spawn a saboteur without its prompt/tools contract. Build the toolset with a roster that includes 'chaos-monkey' (FLEET_ROSTER does)."
+        };
       }
-      if (c === "/" && line[i + 1] === "*") {
-        closeRun(i);
-        const close = line.indexOf("*/", i + 2);
-        if (close === -1) {
-          inBlockComment = true;
+      const chaosSubagentId = await director.spawn(
+        makeChaosConfig(chaosBase, i.chaosWorktree ?? chaosBase.worktree ?? "off")
+      );
+      const chaosTaskId = await director.assign({
+        id: randomUUID9(),
+        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;
+      let rerunUnknowns = [];
+      while (current.length > 0 && attempts.length < maxAttempts && i.repairSubagentId) {
+        const attemptNo = attempts.length + 1;
+        const strengthenTaskId = await director.assign({
+          id: randomUUID9(),
+          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;
         }
-        i = close + 2;
-        continue;
-      }
-      if (c === "/") {
-        if (!tokenCanEndOperand(lastToken)) {
-          closeRun(i);
-          const next = skipRegexLiteral(line, i);
-          lastToken = next > i + 1 ? "regex" : "/";
-          i = next;
-          continue;
-        }
-      }
-      if (c === "(") {
-        top.parens.push(CONTROL_KEYWORDS.has(lastToken ?? "") ? "control" : "expr");
-        lastToken = c;
-      } else if (c === ")") {
-        const kind = top.parens.pop() ?? "expr";
-        lastToken = kind === "control" ? "control-paren-close" : ")";
-      } else if (c === "{") {
-        top.depth++;
-        lastToken = c;
-      } else if (c === "}") {
-        if (top.depth > 0) {
-          top.depth--;
-          lastToken = c;
-        } else if (stack.length > 1) {
-          closeRun(i);
-          stack.pop();
-          i++;
-          continue;
-        } else {
-          lastToken = c;
-        }
-      } else if (c !== " " && c !== "	" && c !== "\r") {
-        lastToken = c;
+        const survivorPlan = plan.filter((p) => current.some((s) => s.id === p.id));
+        const rerunSubagentId = await director.spawn(
+          makeChaosConfig(chaosBase, i.chaosWorktree ?? chaosBase.worktree ?? "off")
+        );
+        const rerunTaskId = await director.assign({
+          id: randomUUID9(),
+          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) => !isKill(m.status));
+        rerunUnknowns = passN.filter((m) => 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) => m.status === "survived" && current.some((c) => c.id === m.id)).map((m) => m.id)
+        });
+        current = stillSurviving;
       }
-      if (runStart === null) runStart = i;
-      i++;
+      const finalSurvivors = current.filter((m) => m.status === "survived");
+      const verifiedCount = pass1.filter((m) => m.status !== "skipped").length;
+      const skippedCount = pass1.filter((m) => m.status === "skipped").length;
+      const rerunUnknownCount = rerunUnknowns.length;
+      const score = plan.length === 0 ? 0 : pass1.filter((m) => isKill(m.status)).length / plan.length;
+      const verdict = verifiedCount === 0 ? "inconclusive" : finalSurvivors.length === 0 ? skippedCount > 0 || rerunUnknownCount > 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) => isKill(m.status)).length,
+        // Breakout of `killed`: how many kills were detected by the test
+        // command hanging rather than by a failing assertion. A subset of
+        // `killed`, surfaced so a director can distinguish a hang-heavy
+        // suite (mutants breaking termination, not assertions) from an
+        // assertion-strong one. hangHeavy = killedByHang === killed.
+        killedByHang: pass1.filter((m) => m.status === "killed-by-hang").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,
+        // Unverified leftovers from the strengthen loop: surfaced so the
+        // caller can see WHICH mutants lack kill evidence, and counted by
+        // the verdict gate above.
+        unverifiedFromRerun: rerunUnknowns.map((m) => ({ id: m.id, file: m.file, kind: m.kind })),
+        nextAction: finalSurvivors.length === 0 && rerunUnknownCount === 0 && skippedCount === 0 ? "accept" : attempts.length >= maxAttempts && i.repairSubagentId ? "manual_review_survivors" : "strengthen_tests"
+      };
     }
-    closeRun(line.length);
-  }
-  return masks;
+  };
 }
-var KEYWORDS_BEFORE_REGEX = /* @__PURE__ */ new Set([
-  "return",
-  "typeof",
-  "instanceof",
-  "in",
-  "of",
-  "new",
-  "delete",
-  "void",
-  "throw",
-  "case",
-  "do",
-  "else",
-  "yield",
-  "await"
-]);
-var CONTROL_KEYWORDS = /* @__PURE__ */ new Set(["if", "for", "while", "switch", "catch", "with", "await"]);
-function tokenCanEndOperand(token) {
-  if (token === null) return false;
-  if (/^[\w$]+$/.test(token)) return !KEYWORDS_BEFORE_REGEX.has(token);
-  return token === ")" || token === "]" || token === "." || token === '"' || token === "'" || token === "`";
+function normalizeMutationTestInput(input) {
+  const raw = input ?? {};
+  const targets = stringArray(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: normalizeWorktreeOverride(raw["chaosWorktree"]),
+    timeoutMs: typeof raw["timeoutMs"] === "number" ? raw["timeoutMs"] : void 0,
+    reportOnly: raw["reportOnly"] === true
+  };
 }
-function skipRegexLiteral(line, start) {
-  let i = start + 1;
-  let inClass = false;
-  while (i < line.length) {
-    const ch = line[i];
-    if (ch === "\\") {
-      i += 2;
-      continue;
-    }
-    if (inClass) {
-      if (ch === "]") inClass = false;
-      i++;
-      continue;
-    }
-    if (ch === "[") {
-      inClass = true;
-      i++;
-      continue;
-    }
-    if (ch === "/") {
-      i++;
-      break;
-    }
-    if (ch === "\n" || ch === "\r") return line.length;
-    i++;
-  }
-  while (i < line.length && /[a-z]/.test(line[i])) i++;
-  return i;
+function clamp(n, lo, hi) {
+  return Math.min(hi, Math.max(lo, n));
 }
-function parseMutationReport(text) {
-  const candidates = [];
-  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-  if (fence?.[1]) candidates.push(fence[1].trim());
-  const firstBrace = text.indexOf("{");
-  if (firstBrace >= 0) candidates.push(extractBalancedObject(text, firstBrace));
-  for (const candidate of candidates) {
-    if (!candidate) continue;
+function buildPlan(i, projectRoot) {
+  const plan = [];
+  for (const target of i.targets) {
+    const abs = isAbsolute2(target) ? target : join3(projectRoot ?? process.cwd(), target);
+    let source;
     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
-      };
+      source = readFileSync(abs, "utf8");
     } catch {
+      continue;
     }
+    plan.push(...planMutations(target, source, { maxPerFile: i.maxPerFile ?? DEFAULT_MAX_PER_FILE }));
   }
-  return void 0;
+  return plan;
 }
-function extractBalancedObject(text, start) {
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = start; i < text.length; i++) {
-    const c = text[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (c === "\\") {
-      escaped = true;
-      continue;
+function makeChaosConfig(base, worktree) {
+  return { ...instantiateRosterConfig2(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), survived (suite green), or killed-by-hang (the test command timed out or was aborted \u2014 the mutation broke the suite by non-termination; record the timeout as evidence, do NOT report it as survived).",
+    "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) {
+  const confirmed = survivors.filter((s) => s.status === "survived");
+  const unverified = survivors.filter((s) => s.status === "skipped");
+  const row = (s) => `- ${s.id} | ${s.file}:${s.line} | ${s.kind}${s.evidence ? ` | ${s.evidence}` : ""}`;
+  return [
+    `Strengthen the tests so the mutants below die (attempt ${attempt}).`,
+    "",
+    ...confirmed.length > 0 ? [
+      "CONFIRMED SURVIVORS \u2014 each was a deliberate sabotage of production code that the current suite did NOT catch:",
+      ...confirmed.map(row),
+      ""
+    ] : [],
+    ...unverified.length > 0 ? [
+      "UNVERIFIED \u2014 these mutations were never actually re-tested (the re-verify pass skipped or did not report them). Do NOT assume the suite misses them: first apply each mutation, run the tests, and confirm it really survives; if the tests already fail, report that instead of writing new assertions.",
+      ...unverified.map(row),
+      ""
+    ] : [],
+    `Test command that must fail under each CONFIRMED mutant: ${i.testCommand}`,
+    "",
+    "For each CONFIRMED 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 remaining = [...plan];
+    const matched = [];
+    for (const m of fromText) {
+      const idx = remaining.findIndex((p) => p.id === m.id);
+      if (idx === -1) continue;
+      remaining.splice(idx, 1);
+      matched.push(m);
     }
-    if (c === '"') inString = !inString;
-    if (inString) continue;
-    if (c === "{") depth++;
-    else if (c === "}") {
-      depth--;
-      if (depth === 0) return text.slice(start, i + 1);
+    if (matched.length > 0) {
+      const missing = remaining.map((p) => ({
+        id: p.id,
+        file: p.file,
+        line: p.line,
+        kind: p.kind,
+        status: "skipped",
+        evidence: "not reported by chaos task"
+      }));
+      return [...matched, ...missing];
     }
   }
-  return text.slice(start);
+  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 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" && status !== "killed-by-hang") {
-    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
-  };
+function isKill(status) {
+  return status === "killed" || status === "killed-by-hang";
+}
+function parseTextOutcomes(result) {
+  const text = typeof result?.result === "string" ? result.result : void 0;
+  if (!text) return [];
+  const parsed = parseMutationReport(text);
+  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-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 = {}) {
+// src/coordination/director-quality-gate-tool.ts
+import { randomUUID as randomUUID10 } from "node:crypto";
+function makeQualityGateTool(director, roster) {
   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.",
+    name: "quality_gate",
+    description: "Run a first-class implementation quality gate. It can await implementer task ids, spawn independent verifier/reviewer agents, summarize their verdicts, and optionally send must-fix feedback back to an implementer until the gate passes or the repair-attempt limit is reached.",
+    usageHint: "Use after code-changing work. Provide implementerTaskIds when available. Add repairSubagentId to iterate fixes automatically. Verdict only passes when every enabled reviewer/verifier explicitly passes.",
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema: {
       type: "object",
       properties: {
+        task: {
+          type: "string",
+          description: "Original implementation task or acceptance goal being gated."
+        },
+        implementerTaskIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional completed or in-flight implementer task ids to await and include as implementation evidence."
+        },
+        repairSubagentId: {
+          type: "string",
+          description: "Optional implementer subagent id. When set and the gate fails, quality_gate assigns a repair task with reviewer/verifier feedback and reruns the gate."
+        },
+        maxRepairAttempts: {
+          type: "number",
+          minimum: 0,
+          maximum: 5,
+          description: "Maximum automatic repair iterations. Default: 2 when repairSubagentId is set, otherwise 0."
+        },
         targets: {
           type: "array",
           items: { type: "string" },
-          description: "Project-relative (or absolute) source files to mutate. Keep to files changed by the current task."
+          description: "Files, packages, or paths that reviewer/verifier should focus on."
         },
-        testCommand: {
+        commands: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Verification commands that should pass, e.g. ["pnpm --filter @wrongstack/core typecheck"].'
+        },
+        expected: {
           type: "string",
-          description: 'Exact command that runs the relevant tests, e.g. "pnpm exec vitest run packages/core/tests/coordination/mutation-engine.test.ts".'
+          description: "Expected behavior or acceptance criteria."
         },
-        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."
+        evidence: {
+          type: "string",
+          description: "Known implementation notes, diff summary, or commands already run."
         },
-        maxStrengthenAttempts: {
-          type: "number",
-          minimum: 0,
-          maximum: 5,
-          description: "Strengthen\u2192re-verify rounds. Default 2 when repairSubagentId is set, else 0."
+        reviewer: {
+          type: "boolean",
+          description: "Whether to run the reviewer lane. Default true."
         },
-        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."
+        verifier: {
+          type: "boolean",
+          description: "Whether to run the verifier lane. Default true."
         },
-        chaosWorktree: {
+        timeoutMs: {
+          type: "number",
+          minimum: 1,
+          description: "Optional per reviewer/verifier/repair task timeout."
+        },
+        reviewerWorktree: {
           anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
-          description: "Worktree override for the chaos agent. Defaults to the roster policy for chaos-monkey ('off'), because mutation targets are usually freshly written and uncommitted \u2014 a worktree from HEAD would not contain them and every mutant would drift to skipped. Only pass 'auto' or 'required' when the targets are committed."
+          description: "Reviewer worktree override. Default off because reviewer is read-only."
         },
-        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."
+        verifierWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Verifier worktree override. Default auto so test artifacts stay isolated when fleet policy wants it."
         }
-      },
-      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 chaosBase = roster?.[CHAOS_ROLE];
-      if (!chaosBase) {
+    },
+    async execute(input) {
+      const i = normalizeQualityGateInput(input);
+      const runReviewer = i.reviewer !== false;
+      const runVerifier = i.verifier !== false;
+      if (!runReviewer && !runVerifier) {
         return {
           verdict: "inconclusive",
           passed: false,
-          error: "chaos-monkey role missing from the roster \u2014 refusing to spawn a saboteur without its prompt/tools contract. Build the toolset with a roster that includes 'chaos-monkey' (FLEET_ROSTER does)."
+          error: "quality_gate requires reviewer, verifier, or both."
         };
       }
-      const chaosSubagentId = await director.spawn(
-        makeChaosConfig(chaosBase, i.chaosWorktree ?? chaosBase.worktree ?? "off")
-      );
-      const chaosTaskId = await director.assign({
-        id: randomUUID10(),
-        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 implementerResults = i.implementerTaskIds && i.implementerTaskIds.length > 0 ? await director.awaitTasks(i.implementerTaskIds) : [];
+      const maxRepairAttempts = clampRepairAttempts(
+        i.maxRepairAttempts ?? (i.repairSubagentId ? 2 : 0)
       );
+      const repairResults = [];
       const attempts = [];
-      let current = survivors;
-      let rerunUnknowns = [];
-      while (current.length > 0 && attempts.length < maxAttempts && i.repairSubagentId) {
-        const attemptNo = attempts.length + 1;
-        const strengthenTaskId = await director.assign({
-          id: randomUUID10(),
-          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: []
+      for (let attempt = 1; ; attempt++) {
+        const gateTaskIds = [];
+        const taskRoleById = /* @__PURE__ */ new Map();
+        if (runVerifier) {
+          const subagentId = await director.spawn(
+            makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
+          );
+          const taskId = await director.assign({
+            id: randomUUID10(),
+            subagentId,
+            description: buildVerifierTask(i, {
+              attempt,
+              implementerResults,
+              repairResults,
+              priorAttempts: attempts
+            }),
+            timeoutMs: i.timeoutMs
           });
-          break;
+          gateTaskIds.push(taskId);
+          taskRoleById.set(taskId, "verifier");
         }
-        const survivorPlan = plan.filter((p) => current.some((s) => s.id === p.id));
-        const rerunSubagentId = await director.spawn(
-          makeChaosConfig(chaosBase, i.chaosWorktree ?? chaosBase.worktree ?? "off")
-        );
-        const rerunTaskId = await director.assign({
+        if (runReviewer) {
+          const subagentId = await director.spawn(
+            makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
+          );
+          const taskId = await director.assign({
+            id: randomUUID10(),
+            subagentId,
+            description: buildReviewerTask(i, {
+              attempt,
+              implementerResults,
+              repairResults,
+              priorAttempts: attempts
+            }),
+            timeoutMs: i.timeoutMs
+          });
+          gateTaskIds.push(taskId);
+          taskRoleById.set(taskId, "reviewer");
+        }
+        const gateResults = await director.awaitTasks(gateTaskIds);
+        const reports = gateResults.map((r) => assessRoleResult(taskRoleById.get(r.taskId), r));
+        const assessment = assessQualityGate(reports);
+        attempts.push({ attempt, reports, ...assessment });
+        if (assessment.passed || !i.repairSubagentId || attempt > maxRepairAttempts) {
+          return {
+            verdict: assessment.verdict,
+            passed: assessment.passed,
+            attempts,
+            repairAttemptsUsed: repairResults.length,
+            implementerResults: implementerResults.map(summarizeTaskResult),
+            nextAction: assessment.passed ? "accept" : i.repairSubagentId && attempt > maxRepairAttempts ? "manual_intervention_or_raise_repair_limit" : "inspect_failures"
+          };
+        }
+        const repairTaskId = await director.assign({
           id: randomUUID10(),
-          subagentId: rerunSubagentId,
-          description: buildChaosTask(survivorPlan, i, attemptNo + 1, current),
+          subagentId: i.repairSubagentId,
+          description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
           timeoutMs: i.timeoutMs
         });
-        const [rerunResult] = await director.awaitTasks([rerunTaskId]);
-        const passN = collectOutcomes(rerunResult, survivorPlan);
-        const stillSurviving = passN.filter((m) => !isKill(m.status));
-        rerunUnknowns = passN.filter((m) => 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) => m.status === "survived" && current.some((c) => c.id === m.id)).map((m) => m.id)
-        });
-        current = stillSurviving;
+        const [repairResult] = await director.awaitTasks([repairTaskId]);
+        if (repairResult) repairResults.push(repairResult);
+        if (repairResult?.status !== "success") {
+          return {
+            verdict: "fail",
+            passed: false,
+            attempts,
+            repairAttemptsUsed: repairResults.length,
+            repairResult: repairResult ? summarizeTaskResult(repairResult) : void 0,
+            implementerResults: implementerResults.map(summarizeTaskResult),
+            nextAction: "repair_failed"
+          };
+        }
       }
-      const finalSurvivors = current.filter((m) => m.status === "survived");
-      const verifiedCount = pass1.filter((m) => m.status !== "skipped").length;
-      const skippedCount = pass1.filter((m) => m.status === "skipped").length;
-      const rerunUnknownCount = rerunUnknowns.length;
-      const score = plan.length === 0 ? 0 : pass1.filter((m) => isKill(m.status)).length / plan.length;
-      const verdict = verifiedCount === 0 ? "inconclusive" : finalSurvivors.length === 0 ? skippedCount > 0 || rerunUnknownCount > 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) => isKill(m.status)).length,
-        // Breakout of `killed`: how many kills were detected by the test
-        // command hanging rather than by a failing assertion. A subset of
-        // `killed`, surfaced so a director can distinguish a hang-heavy
-        // suite (mutants breaking termination, not assertions) from an
-        // assertion-strong one. hangHeavy = killedByHang === killed.
-        killedByHang: pass1.filter((m) => m.status === "killed-by-hang").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,
-        // Unverified leftovers from the strengthen loop: surfaced so the
-        // caller can see WHICH mutants lack kill evidence, and counted by
-        // the verdict gate above.
-        unverifiedFromRerun: rerunUnknowns.map((m) => ({ id: m.id, file: m.file, kind: m.kind })),
-        nextAction: finalSurvivors.length === 0 && rerunUnknownCount === 0 && skippedCount === 0 ? "accept" : attempts.length >= maxAttempts && i.repairSubagentId ? "manual_review_survivors" : "strengthen_tests"
-      };
     }
   };
 }
-function normalizeMutationTestInput(input) {
+function normalizeQualityGateInput(input) {
   const raw = input ?? {};
-  const targets = stringArray(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: normalizeWorktreeOverride(raw["chaosWorktree"]),
-    timeoutMs: typeof raw["timeoutMs"] === "number" ? raw["timeoutMs"] : void 0,
-    reportOnly: raw["reportOnly"] === true
+    task: typeof raw.task === "string" ? raw.task : void 0,
+    implementerTaskIds: stringArray(raw.implementerTaskIds),
+    repairSubagentId: typeof raw.repairSubagentId === "string" && raw.repairSubagentId.trim() ? raw.repairSubagentId.trim() : void 0,
+    maxRepairAttempts: typeof raw.maxRepairAttempts === "number" ? raw.maxRepairAttempts : void 0,
+    targets: stringArray(raw.targets),
+    commands: stringArray(raw.commands),
+    expected: typeof raw.expected === "string" ? raw.expected : void 0,
+    evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
+    reviewer: typeof raw.reviewer === "boolean" ? raw.reviewer : void 0,
+    verifier: typeof raw.verifier === "boolean" ? raw.verifier : void 0,
+    timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : void 0,
+    reviewerWorktree: normalizeWorktreeOverride(raw.reviewerWorktree),
+    verifierWorktree: normalizeWorktreeOverride(raw.verifierWorktree)
   };
 }
-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 = isAbsolute2(target) ? target : join3(projectRoot ?? process.cwd(), target);
-    let source;
-    try {
-      source = readFileSync(abs, "utf8");
-    } catch {
-      continue;
-    }
-    plan.push(...planMutations(target, source, { maxPerFile: i.maxPerFile ?? DEFAULT_MAX_PER_FILE }));
-  }
-  return plan;
+function clampRepairAttempts(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(5, Math.floor(value)));
 }
-function makeChaosConfig(base, worktree) {
-  return { ...instantiateRosterConfig2(CHAOS_ROLE, base), worktree };
+function makeQualityGateSubagentConfig(role, roster, worktree) {
+  const base = roster?.[role] ?? getAgentDefinition(role)?.config ?? { name: role, role };
+  return {
+    ...instantiateRosterConfig2(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")}` : "";
+function buildVerifierTask(input, state) {
   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), survived (suite green), or killed-by-hang (the test command timed out or was aborted \u2014 the mutation broke the suite by non-termination; record the timeout as evidence, do NOT report it as survived).",
-    "4. Restore the file byte-for-byte before the next mutant.",
-    "",
-    "Mutants:",
-    mutants,
-    prior,
+    "Run the independent verification gate for this implementation.",
+    "Return Markdown with `## Verdict` and make the first verdict word exactly `pass`, `fail`, or `blocked`.",
+    "Do not edit code. Run the smallest meaningful command set and include exact failures.",
     "",
-    "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");
+    `Gate attempt: ${state.attempt}`,
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.commands?.length ? `Required or suggested commands:
+${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    input.evidence ? `Known evidence:
+${input.evidence}` : void 0,
+    taskResultsBlock("Implementer results", state.implementerResults),
+    taskResultsBlock("Repair results so far", state.repairResults),
+    priorAttemptsBlock(state.priorAttempts)
+  ].filter((part) => !!part).join("\n\n");
 }
-function buildStrengthenTask(survivors, i, attempt) {
-  const confirmed = survivors.filter((s) => s.status === "survived");
-  const unverified = survivors.filter((s) => s.status === "skipped");
-  const row = (s) => `- ${s.id} | ${s.file}:${s.line} | ${s.kind}${s.evidence ? ` | ${s.evidence}` : ""}`;
+function buildReviewerTask(input, state) {
   return [
-    `Strengthen the tests so the mutants below die (attempt ${attempt}).`,
+    "Run independent code review for this implementation.",
+    "Return Markdown with `## Verdict` and make the first verdict phrase exactly `approve`, `request changes`, or `needs verification`.",
+    "Do not edit code. Treat missing proof, vague tests, and uncertainty as blocking until verifier evidence exists.",
     "",
-    ...confirmed.length > 0 ? [
-      "CONFIRMED SURVIVORS \u2014 each was a deliberate sabotage of production code that the current suite did NOT catch:",
-      ...confirmed.map(row),
-      ""
-    ] : [],
-    ...unverified.length > 0 ? [
-      "UNVERIFIED \u2014 these mutations were never actually re-tested (the re-verify pass skipped or did not report them). Do NOT assume the suite misses them: first apply each mutation, run the tests, and confirm it really survives; if the tests already fail, report that instead of writing new assertions.",
-      ...unverified.map(row),
-      ""
-    ] : [],
-    `Test command that must fail under each CONFIRMED mutant: ${i.testCommand}`,
+    `Gate attempt: ${state.attempt}`,
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    input.evidence ? `Known evidence:
+${input.evidence}` : void 0,
+    taskResultsBlock("Implementer results", state.implementerResults),
+    taskResultsBlock("Repair results so far", state.repairResults),
+    priorAttemptsBlock(state.priorAttempts)
+  ].filter((part) => !!part).join("\n\n");
+}
+function buildRepairTask(input, attempt, attemptNumber) {
+  return [
+    `Repair the implementation after quality gate attempt ${attemptNumber} failed.`,
+    "Address every must-fix item. Run relevant checks before returning.",
+    "Do not claim done unless verifier/reviewer feedback is resolved.",
     "",
-    "For each CONFIRMED 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");
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.commands?.length ? `Commands expected to pass:
+${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    attempt.mustFix.length ? `Must fix:
+${attempt.mustFix.map((f) => `- ${f}`).join("\n")}` : void 0,
+    attempt.uncertaintyFlags.length ? `Uncertainty flags to resolve:
+${attempt.uncertaintyFlags.map((f) => `- ${f}`).join("\n")}` : void 0,
+    `Reviewer/verifier reports:
+${attempt.reports.map((r) => `### ${r.role} (${r.verdict})
+${r.summary}`).join("\n\n")}`
+  ].filter((part) => !!part).join("\n\n");
 }
-function collectOutcomes(result, plan) {
-  const fromText = parseTextOutcomes(result);
-  if (fromText.length > 0) {
-    const remaining = [...plan];
-    const matched = [];
-    for (const m of fromText) {
-      const idx = remaining.findIndex((p) => p.id === m.id);
-      if (idx === -1) continue;
-      remaining.splice(idx, 1);
-      matched.push(m);
+function taskResultsBlock(title, results) {
+  if (results.length === 0) return void 0;
+  return `${title}:
+${results.map((r) => `### ${r.subagentId}/${r.taskId}
+${summarizeTaskResult(r).summary}`).join("\n\n")}`;
+}
+function priorAttemptsBlock(attempts) {
+  if (attempts.length === 0) return void 0;
+  return `Prior quality gate attempts:
+${attempts.map(
+    (a) => `### Attempt ${a.attempt}
+${a.reports.map((r) => `- ${r.role}: ${r.verdict}${r.error ? ` (${r.error})` : ""}`).join("\n")}`
+  ).join("\n\n")}`;
+}
+function summarizeTaskResult(result) {
+  const text = typeof result.result === "string" ? result.result : result.result !== void 0 ? JSON.stringify(result.result, null, 2) : "";
+  const error = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
+  return {
+    taskId: result.taskId,
+    subagentId: result.subagentId,
+    status: result.status,
+    summary: excerpt(text || error || "(no output)", 4e3),
+    error
+  };
+}
+function assessRoleResult(role, result) {
+  const resolvedRole = role ?? (result.subagentId.includes("review") ? "reviewer" : "verifier");
+  const summary = summarizeTaskResult(result);
+  const text = summary.summary;
+  const uncertaintyFlags = extractSection(text, "Uncertainty Flags");
+  if (result.status !== "success") {
+    return {
+      role: resolvedRole,
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      status: result.status,
+      verdict: "fail",
+      summary: text,
+      uncertaintyFlags,
+      error: summary.error ?? result.status
+    };
+  }
+  return {
+    role: resolvedRole,
+    subagentId: result.subagentId,
+    taskId: result.taskId,
+    status: result.status,
+    verdict: parseQualityVerdict(resolvedRole, text),
+    summary: text,
+    uncertaintyFlags
+  };
+}
+function assessQualityGate(reports) {
+  const mustFix = [];
+  const uncertaintyFlags = [];
+  let hasFail = false;
+  let hasInconclusive = false;
+  for (const report of reports) {
+    if (report.verdict === "fail") hasFail = true;
+    if (report.verdict === "inconclusive") hasInconclusive = true;
+    const blocking = extractSection(report.summary, "Must Fix") || extractSection(report.summary, "Failures") || extractSection(report.summary, "Verification Gaps");
+    if (blocking) mustFix.push(`${report.role}: ${excerpt(blocking, 1e3)}`);
+    if (report.uncertaintyFlags) {
+      uncertaintyFlags.push(`${report.role}: ${excerpt(report.uncertaintyFlags, 1e3)}`);
     }
-    if (matched.length > 0) {
-      const missing = remaining.map((p) => ({
-        id: p.id,
-        file: p.file,
-        line: p.line,
-        kind: p.kind,
-        status: "skipped",
-        evidence: "not reported by chaos task"
-      }));
-      return [...matched, ...missing];
+    if (report.error) mustFix.push(`${report.role}: ${report.error}`);
+  }
+  if (hasFail) return { verdict: "fail", passed: false, mustFix, uncertaintyFlags };
+  if (hasInconclusive || reports.length === 0) {
+    return { verdict: "inconclusive", passed: false, mustFix, uncertaintyFlags };
+  }
+  return { verdict: "pass", passed: true, mustFix, uncertaintyFlags };
+}
+function parseQualityVerdict(role, text) {
+  const normalized = text.toLowerCase();
+  const verdictBlock = normalized.match(/(?:^|\n)\s*(?:#+\s*)?verdict\b[^\n]*(?:\n|:|-)?([\s\S]{0,500})/)?.[0] ?? normalized.slice(0, 1e3);
+  if (role === "reviewer") {
+    if (/\b(request\s+changes|needs\s+verification|reject|rejected|fail|failed|blocked)\b/.test(
+      verdictBlock
+    )) {
+      return "fail";
+    }
+    if (/\b(approve|approved|pass|passed)\b/.test(verdictBlock)) return "pass";
+    if (sectionHasBlockingContent(text, "Must Fix") || sectionHasBlockingContent(text, "Verification Gaps")) {
+      return "fail";
     }
+    return "inconclusive";
   }
-  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"
-  }));
+  if (/\b(fail|failed|blocked|red)\b/.test(verdictBlock)) return "fail";
+  if (/\b(pass|passed|green|approve|approved)\b/.test(verdictBlock)) return "pass";
+  if (sectionHasBlockingContent(text, "Failures")) return "fail";
+  return "inconclusive";
 }
-function isKill(status) {
-  return status === "killed" || status === "killed-by-hang";
+function sectionHasBlockingContent(text, heading) {
+  const section = extractSection(text, heading);
+  if (!section) return false;
+  return !/^\s*(none|n\/a|no\b|no issues|empty|\(none\))\s*\.?\s*$/i.test(section.trim());
+}
+function extractSection(text, heading) {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:^|\\n)\\s*#{1,6}\\s*${escaped}\\s*\\n([\\s\\S]*?)(?=\\n\\s*#{1,6}\\s+|$)`,
+    "i"
+  );
+  const match = text.match(pattern);
+  const body = match?.[1]?.trim();
+  return body ? body : void 0;
 }
-function parseTextOutcomes(result) {
-  const text = typeof result?.result === "string" ? result.result : void 0;
-  if (!text) return [];
-  const parsed = parseMutationReport(text);
-  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
-  }));
+function excerpt(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 20).trimEnd()}
+...(truncated)`;
 }
 
 // src/coordination/director-tools.ts
@@ -5630,6 +5762,10 @@ function makeSpawnTool(director, roster) {
         type: "string",
         description: "Model id within the provider. Defaults to the leader model when omitted."
       },
+      tier: {
+        type: "string",
+        description: "Cost/capability level for this worker: 'budget' (cheap + fast, for mechanical or well-specified work), 'standard' (the default), or 'premium' (expensive + most capable, for work where being wrong is costly). Resolved deterministically into a model, a failover chain, and a spend budget from `modelTiers` config, so you do NOT need to know any model id. Omit to let the routing table decide by role. An explicit `model` always wins over the tier.\n\nThis is the RIGHT place to spend a cheap tier. Because this spawn is non-blocking, a budget-tier worker being slower costs you nothing \u2014 you keep working while it runs. The same tier on `delegate` would just make you wait longer."
+      },
       systemPromptOverride: {
         type: "string",
         description: "Extra prompt text appended after the role-base prompt."
@@ -5667,7 +5803,7 @@ function makeSpawnTool(director, roster) {
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
-    async execute(input) {
+    async execute(input, ctx) {
       const i = input ?? {};
       const role = typeof i.role === "string" ? i.role : void 0;
       const description = typeof i.description === "string" ? i.description : void 0;
@@ -5707,11 +5843,20 @@ function makeSpawnTool(director, roster) {
       if (typeof i.timeoutMs === "number") cfg.timeoutMs = i.timeoutMs;
       if (typeof i.idleTimeoutMs === "number") cfg.idleTimeoutMs = i.idleTimeoutMs;
       if (typeof i.maxTokens === "number") cfg.maxTokens = i.maxTokens;
+      if (typeof i.tier === "string" && i.tier) cfg.tier = i.tier;
+      const budgetPins = [];
+      if (typeof i.maxIterations === "number") budgetPins.push("maxIterations");
+      if (typeof i.maxToolCalls === "number") budgetPins.push("maxToolCalls");
+      if (typeof i.maxCostUsd === "number") budgetPins.push("maxCostUsd");
+      if (typeof i.maxTokens === "number") budgetPins.push("maxTokens");
+      if (typeof i.timeoutMs === "number") budgetPins.push("timeoutMs");
+      if (budgetPins.length) cfg.budgetPins = budgetPins;
       if (typeof i.worktree === "boolean" || i.worktree === "auto" || i.worktree === "required" || i.worktree === "off") {
         cfg.worktree = i.worktree;
       }
       try {
-        const subagentId = await director.spawn(cfg);
+        const origin = callerSessionId(ctx);
+        const subagentId = await director.spawn(origin ? { ...cfg, originSessionId: origin } : cfg);
         return {
           subagentId,
           provider: cfg.provider,
@@ -5784,6 +5929,10 @@ function makeKanbanQueueTool(director, roster) {
         role: { type: "string" },
         provider: { type: "string" },
         model: { type: "string" },
+        tier: {
+          type: "string",
+          description: "Cost level for the dispatched workers ('budget' | 'standard' | 'premium'). Resolved from `modelTiers`; an explicit provider/model still wins."
+        },
         fallbackModels: { type: "array", items: { type: "string" } },
         tools: { type: "array", items: { type: "string" } },
         allowedCapabilities: { type: "array", items: { type: "string" } },
@@ -5800,6 +5949,7 @@ function makeKanbanQueueTool(director, roster) {
       }
       const projectRoot = ctx.projectRoot;
       if (!projectRoot) return { error: "kanban_queue requires ctx.projectRoot." };
+      const sessionId = ctx.eventSessionId();
       const maxTasks = Math.max(1, Math.min(20, Math.floor(i.maxTasks ?? 1)));
       const baseLeaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
       const leaseTtlMs = i.awaitCompletion === true && i.timeoutMs !== void 0 ? Math.max(baseLeaseTtlMs, i.timeoutMs + 6e4) : baseLeaseTtlMs;
@@ -5820,6 +5970,7 @@ function makeKanbanQueueTool(director, roster) {
         if (candidateTaskIds && !candidateTaskId) break;
         if (candidateTaskId && budgetRejectedTaskIds.has(candidateTaskId)) continue;
         const reserved = await kanbanDispatch().reserveKanbanDispatch(projectRoot, {
+          sessionId,
           ...i.boardId !== void 0 ? { boardId: i.boardId } : {},
           ...candidateTaskId !== void 0 ? { taskId: candidateTaskId } : {},
           routing: {
@@ -5828,6 +5979,7 @@ function makeKanbanQueueTool(director, roster) {
             ...i.role !== void 0 ? { role: i.role } : {},
             ...i.provider !== void 0 ? { provider: i.provider } : {},
             ...i.model !== void 0 ? { model: i.model } : {},
+            ...i.tier !== void 0 ? { tier: i.tier } : {},
             ...i.fallbackModels !== void 0 ? { fallbackModels: i.fallbackModels } : {},
             ...i.tools !== void 0 ? { tools: i.tools } : {},
             ...i.allowedCapabilities !== void 0 ? { allowedCapabilities: i.allowedCapabilities } : {}
@@ -5858,7 +6010,7 @@ function makeKanbanQueueTool(director, roster) {
                 status: "failed",
                 error: budgetError
               },
-              { expectedLeaseId: ourLeaseId }
+              { sessionId, expectedLeaseId: ourLeaseId }
             );
             errors.push({
               taskId: claim.task.id,
@@ -5901,6 +6053,7 @@ function makeKanbanQueueTool(director, roster) {
             }
           };
           const started = await kanbanDispatch().startKanbanDispatch(projectRoot, {
+            sessionId,
             boardId: claim.board.id,
             taskId: claim.task.id,
             leaseId: ourLeaseId,
@@ -5946,6 +6099,7 @@ function makeKanbanQueueTool(director, roster) {
             }
           }
           await kanbanDispatch().failKanbanDispatch(projectRoot, {
+            sessionId,
             boardId: claim.board.id,
             taskId: claim.task.id,
             leaseId: ourLeaseId,
@@ -5973,6 +6127,7 @@ function makeKanbanQueueTool(director, roster) {
           for (const dispatch of dispatches) {
             if (!disposers.has(dispatch.runTaskId)) continue;
             void renewAndRevokeLease({
+              sessionId,
               projectRoot,
               boardId: dispatch.boardId,
               taskId: dispatch.taskId,
@@ -6027,7 +6182,8 @@ function makeKanbanQueueTool(director, roster) {
                 {
                   leaseExpiresAt: refreshedExpiry,
                   expectedLeaseId: dispatch.leaseId
-                }
+                },
+                { sessionId, expectedLeaseId: dispatch.leaseId }
               );
             } catch {
             }
@@ -6052,6 +6208,7 @@ function makeKanbanQueueTool(director, roster) {
           runTaskIds.delete(dispatch.runTaskId);
           if (result.status === "success") {
             const completed = await kanbanDispatch().completeKanbanDispatch(projectRoot, {
+              sessionId,
               boardId: dispatch.boardId,
               taskId: dispatch.taskId,
               leaseId: dispatch.leaseId,
@@ -6068,6 +6225,7 @@ function makeKanbanQueueTool(director, roster) {
             }
           } else {
             const failed = await kanbanDispatch().failKanbanDispatch(projectRoot, {
+              sessionId,
               boardId: dispatch.boardId,
               taskId: dispatch.taskId,
               leaseId: dispatch.leaseId,
@@ -6114,6 +6272,7 @@ async function renewAndRevokeLease(opts) {
     runTaskId,
     ourLeaseId,
     refreshedExpiry,
+    sessionId,
     director,
     disposers
   } = opts;
@@ -6132,10 +6291,13 @@ async function renewAndRevokeLease(opts) {
   } catch {
   }
   if (!revoked) {
-    await kanbanDispatch().heartbeatTaskAssignment(projectRoot, boardId, taskId, {
-      leaseExpiresAt: refreshedExpiry,
-      expectedLeaseId: ourLeaseId
-    }).catch(() => {
+    await kanbanDispatch().heartbeatTaskAssignment(
+      projectRoot,
+      boardId,
+      taskId,
+      { leaseExpiresAt: refreshedExpiry, expectedLeaseId: ourLeaseId },
+      { sessionId, expectedLeaseId: ourLeaseId }
+    ).catch(() => {
     });
   }
 }
@@ -6320,6 +6482,28 @@ function resolveDirectorSpawnModel(config, opts) {
       if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
     }
   }
+  if (opts.config) {
+    if (opts.tier) {
+      const decision = classifyTier(opts.config, { role: config.role, tier: opts.tier });
+      if (decision && !decision.configured) {
+        const available = listTierIds(opts.config);
+        opts.logger?.warn(
+          `spawn: tier "${opts.tier}" is not a configured level${available.length ? ` (available: ${available.join(", ")})` : " (modelTiers.levels is empty)"} \u2014 falling through to matrix/session resolution.`
+        );
+      }
+    }
+    const resolvedTier = resolveTier(opts.config, {
+      role: config.role,
+      tier: opts.tier
+    });
+    if (resolvedTier) {
+      applyTierToSubagentConfig(config, resolvedTier);
+      opts.onTierResolved?.(resolvedTier);
+      opts.logger?.info(
+        `spawn: tier="${resolvedTier.tier}" (via ${resolvedTier.source}) applied for role "${config.role ?? "?"}"`
+      );
+    }
+  }
   if (!config.provider && opts.sessionProvider) {
     config.provider = opts.sessionProvider;
     opts.logger?.info(
@@ -6447,22 +6631,35 @@ var FleetUsageAggregator = class {
   metaLookup;
   perSubagent = /* @__PURE__ */ new Map();
   total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  retired = {
+    subagents: 0,
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0
+  };
   unsub = [];
   /**
-   * Remove a terminated subagent's data from the aggregator and subtract its
-   * contribution from the running totals. Call this when a subagent is removed
-   * from the fleet so the aggregator doesn't accumulate unbounded data for
-   * entities that will never emit events again.
+   * Drop a terminated subagent's per-agent entry, folding its spend into
+   * {@link FleetUsage.retired} so the run total stays whole.
+   *
+   * The per-agent map is what needed bounding — one entry per spawn, for
+   * entities that will never emit again. Deducting from `total` as well (the
+   * original behavior) also un-spent real tokens: a run that retires each
+   * worker on completion reported a total that shrank as it made progress, and
+   * the director budgets against that number.
    */
   removeSubagent(subagentId) {
     const snap = this.perSubagent.get(subagentId);
     if (!snap) return;
     this.perSubagent.delete(subagentId);
-    this.total.input -= snap.input;
-    this.total.output -= snap.output;
-    this.total.cacheRead -= snap.cacheRead;
-    this.total.cacheWrite -= snap.cacheWrite;
-    this.total.cost -= snap.cost;
+    this.retired.subagents += 1;
+    this.retired.input += snap.input;
+    this.retired.output += snap.output;
+    this.retired.cacheRead += snap.cacheRead;
+    this.retired.cacheWrite += snap.cacheWrite;
+    this.retired.cost += snap.cost;
   }
   /** Disposes all fleet-bus subscriptions. Call when the aggregator is no longer needed. */
   dispose() {
@@ -6475,7 +6672,8 @@ var FleetUsageAggregator = class {
       total: { ...this.total },
       perSubagent: Object.fromEntries(
         Array.from(this.perSubagent.entries()).map(([k, v]) => [k, { ...v }])
-      )
+      ),
+      retired: { ...this.retired }
     };
   }
   ensure(subagentId) {
@@ -6664,11 +6862,15 @@ async function spawn2(host, config, priceLookup) {
   );
   host.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
   host.subagentBridges.set(result.subagentId, subagentBridge);
+  const currentSessionId = typeof host.coordinator.sessionOf === "function" ? host.coordinator.sessionOf(
+    result.subagentId
+  ) : void 0;
   host.fleet.emit({
     subagentId: result.subagentId,
     ts: Date.now(),
     type: "subagent.spawned",
     payload: {
+      ...currentSessionId ? { sessionId: currentSessionId } : {},
       subagentId: result.subagentId,
       taskId: "",
       // taskId will be set when assign() is called
@@ -6740,7 +6942,12 @@ var LargeAnswerStore = class _LargeAnswerStore {
     if (value === void 0 || value === null) {
       return { summary: String(value), inline: true };
     }
-    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    let serialized;
+    try {
+      serialized = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+    } catch {
+      serialized = String(value);
+    }
     const size = serialized.length;
     const bytes = Buffer.byteLength(serialized, "utf8");
     if (size <= this.sizeThreshold) {
@@ -7117,6 +7324,7 @@ var Director = class _Director {
   leaderContextPressure = 0;
   maxLeaderContextLoad;
   maxContext;
+  appConfig;
   modelMatrix;
   workCompleteFlag = false;
   btwNotes = new DirectorBtwNotes();
@@ -7146,6 +7354,7 @@ var Director = class _Director {
     this.maxFleetTokens = opts.directorBudget?.maxTokens ?? Number.POSITIVE_INFINITY;
     this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
     this.maxContext = opts.maxContext ?? 128e3;
+    this.appConfig = opts.appConfig;
     this.modelMatrix = opts.modelMatrix;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
@@ -7412,8 +7621,14 @@ var Director = class _Director {
     return subagentId;
   }
   resolveSpawnModel(config) {
+    const appConfig = typeof this.appConfig === "function" ? this.appConfig() : this.appConfig;
     resolveDirectorSpawnModel(config, {
       modelMatrix: this.modelMatrix,
+      ...appConfig ? { config: appConfig } : {},
+      ...config.tier ? { tier: config.tier } : {},
+      onTierResolved: (resolved) => {
+        config.tier = resolved.tier;
+      },
       sessionProvider: this.sessionProvider,
       sessionModel: this.sessionModel,
       statusTracker: this.statusTracker,
@@ -7518,6 +7733,25 @@ var Director = class _Director {
       void this.remove(id).catch((err) => this.logShutdownError("terminate_all_remove", err));
     }
   }
+  /**
+   * Terminate every subagent spawned by ONE session.
+   *
+   * What a tab's Stop button needs. `terminateAll()` is the wrong tool once
+   * several sessions share a director: it would kill three other tabs' fleets
+   * along with this one's. Aborting the leader's run only unwinds workers the
+   * leader is BLOCKED on (the delegate tool terminates those itself); anything
+   * started with `spawn_subagent` + `assign_task` keeps running because nobody
+   * asked it to stop. This is that ask, scoped to the session that owns them.
+   */
+  async terminateSession(sessionId) {
+    if (!sessionId) return;
+    const ids = this.coordinator.subagentIdsForSession(sessionId);
+    if (ids.length === 0) return;
+    await this.coordinator.stopSession(sessionId);
+    for (const id of ids) {
+      void this.remove(id).catch((err) => this.logShutdownError("terminate_session_remove", err));
+    }
+  }
   async remove(subagentId) {
     this.clearSubagentIdleRetirement(subagentId);
     this.subagentIdleDelayMs.delete(subagentId);
@@ -8195,7 +8429,7 @@ function makeFleetStatusTool(opts = {}) {
   const resolveMailbox = opts.resolveMailbox ?? ((ctx) => getSharedProjectMailbox(opts.projectDir ?? defaultResolveProjectDir(ctx), opts.events));
   return {
     name: "fleet_status",
-    description: "Live snapshot of every agent working on this canonical project (all clients, processes, sessions, branches, and linked Git worktrees): who is online, what task each is on, which tool is running, and progress counters. Check it before starting work that might overlap with a peer, when deciding whether to wait for someone or proceed, or when a task mentions another agent. Read-only. To talk to a peer, use mail_send with the returned id.",
+    description: "Live snapshot of every agent working on this canonical project (all clients, processes, sessions, branches, and linked Git worktrees): who is online, what task each is on, which tool is running, and progress counters. Check it before starting work that might overlap with a peer, when deciding whether to wait for someone or proceed, or when a task mentions another agent. Read-only. Same-session talk: session_note with the returned id. Durable cross-session mail: mail_send.",
     usageHint: "fleet_status  (optionally: onlineOnly=false to include recently-offline agents)",
     category: "Coordination",
     permission: "auto",
@@ -8626,7 +8860,8 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
         });
         await this.opts.actions.notifyLeader(
           "Fleet rebalanced",
-          `Supervisor moved ${moved.length} queued task(s) off busy worker ${fromWorkerId}: ${moved.join(", ")}.`
+          `Supervisor moved ${moved.length} queued task(s) off busy worker ${fromWorkerId}: ${moved.join(", ")}.`,
+          fromWorkerId
         ).catch(() => {
         });
       }
@@ -8683,7 +8918,8 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
         });
         await this.opts.actions.notifyLeader(
           "Fleet helper spawned",
-          `Supervisor spawned helper ${res.subagentId} to drain a ${pendingCount}-task backlog.`
+          `Supervisor spawned helper ${res.subagentId} to drain a ${pendingCount}-task backlog.`,
+          res.subagentId
         ).catch(() => {
         });
       } else {
@@ -8748,7 +8984,8 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
       this.emitAction("steer", true, "stuck nudge", s.id);
       await this.opts.actions.notifyLeader(
         `Worker ${s.name} may be stuck`,
-        `No observable activity for ${Math.round(this.cfg.stuckMs / 1e3)}s. Supervisor nudged it; consider terminate_subagent + reassigning if it stays silent.`
+        `No observable activity for ${Math.round(this.cfg.stuckMs / 1e3)}s. Supervisor nudged it; consider terminate_subagent + reassigning if it stays silent.`,
+        s.id
       ).catch(() => {
       });
       this.record({
@@ -8799,7 +9036,8 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
         this.emitAction("terminate", true, `${streak} consecutive failures`, subagentId);
         await this.opts.actions.notifyLeader(
           `Worker ${subagentId} terminated`,
-          `Supervisor terminated ${subagentId} after ${streak} consecutive failures. Reassign its pending work.`
+          `Supervisor terminated ${subagentId} after ${streak} consecutive failures. Reassign its pending work.`,
+          subagentId
         ).catch(() => {
         });
         this.record({
@@ -8821,7 +9059,8 @@ Idle workers: ${idleWorkerIds.join(", ")}`,
         this.emitAction("steer", true, "failure streak", subagentId);
         await this.opts.actions.notifyLeader(
           `Worker ${subagentId} failing repeatedly`,
-          `${streak} consecutive failures. Supervisor steered it; consider reassigning its work if the next task also fails.`
+          `${streak} consecutive failures. Supervisor steered it; consider reassigning its work if the next task also fails.`,
+          subagentId
         ).catch(() => {
         });
         this.record({
@@ -9101,6 +9340,12 @@ function assertCapability(actor, cap, op) {
 }
 
 // src/coordination/mail-tools.ts
+function scopeAgentMailToOwningSession(ctx, to, sessionId) {
+  const owning = ctx.meta["sessionId"];
+  if (typeof owning !== "string" || owning.length === 0) return {};
+  if (to.trim().toLowerCase() !== "leader") return {};
+  return { sessionAffinity: { sessionId } };
+}
 function makeResolver(opts) {
   return opts.resolveMailbox ?? ((ctx) => getSharedProjectMailbox(opts.projectDir ?? defaultResolveProjectDir(ctx), opts.events));
 }
@@ -9204,7 +9449,8 @@ function makeMailSendTool(opts = {}) {
         body: parsed.body,
         priority: parsed.priority,
         replyTo: parsed.replyTo,
-        senderSessionId: identity.sessionId
+        senderSessionId: identity.sessionId,
+        ...scopeAgentMailToOwningSession(ctx, delivery.to, identity.sessionId)
       });
       return {
         ok: true,
@@ -9301,6 +9547,61 @@ function makeMailInboxTool(opts = {}) {
   };
 }
 
+// src/coordination/session-note-tool.ts
+var KINDS = ["note", "result", "ask", "steer"];
+function isKind(value) {
+  return KINDS.includes(value);
+}
+function makeSessionNoteTool() {
+  return {
+    name: "session_note",
+    description: 'Send an ephemeral note to the leader or another agent in THIS session. Delivered at their next iteration. Use it for same-session talk (findings, a short ask, a steer). Durable mail remains the durable cross-session channel. to="leader" reaches the session leader; to="@session" fans out to every other live agent in the session; an exact agent id reaches one peer. You never receive your own note.',
+    usageHint: 'session_note to="leader" kind="result" body="file:line \u2014 what it is"',
+    category: "Coordination",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.SESSION_NOTE],
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          description: 'Recipient: "leader", "@session", or a live agent id.'
+        },
+        body: { type: "string", description: "The note. Keep it compact." },
+        kind: {
+          type: "string",
+          enum: [...KINDS],
+          description: "note (default), result, ask, or steer."
+        },
+        subject: { type: "string", description: "Optional short subject (e.g. [explore])." }
+      },
+      required: ["to", "body"]
+    },
+    async execute(input, ctx) {
+      const rec = input && typeof input === "object" ? input : {};
+      const to = typeof rec["to"] === "string" ? rec["to"].trim() : "";
+      const body = typeof rec["body"] === "string" ? rec["body"] : "";
+      const subject = typeof rec["subject"] === "string" ? rec["subject"] : void 0;
+      const kindRaw = typeof rec["kind"] === "string" ? rec["kind"].trim().toLowerCase() : "note";
+      const kind = isKind(kindRaw) ? kindRaw : "note";
+      if (!to || !body.trim()) {
+        return { ok: false, delivered: 0, error: "to and body are required" };
+      }
+      const from = typeof ctx.meta["globalAgentId"] === "string" && ctx.meta["globalAgentId"] || ctx.agentId || mailboxIdentityBase(ctx.agentId);
+      const { delivered } = postSessionNote({
+        sessionId: resolveOwningSessionId(ctx),
+        from,
+        to,
+        kind,
+        body,
+        subject
+      });
+      return { ok: delivered > 0, delivered, to, kind };
+    }
+  };
+}
+
 // src/coordination/mailbox-actions.ts
 function actionToAckInput(action, input) {
   switch (action) {
@@ -9587,60 +9888,6 @@ function createMailboxHooks(opts) {
   };
 }
 
-// src/coordination/mailbox-http-auth.ts
-import { timingSafeEqual } from "node:crypto";
-function authorizeMailboxBearerToken(request, expectedToken) {
-  const header = request.headers.authorization;
-  if (typeof header !== "string") return { allowed: false };
-  const match = /^Bearer\s+(.+)$/i.exec(header);
-  if (match === null) return { allowed: false };
-  const presented = Buffer.from(match[1] ?? "", "utf8");
-  const expected = Buffer.from(expectedToken, "utf8");
-  if (presented.length !== expected.length || !timingSafeEqual(presented, expected)) {
-    return { allowed: false };
-  }
-  return { allowed: true, rateLimitKey: expectedToken };
-}
-async function authorizePersistedMailboxCredential(request, store) {
-  const parsed = parseCredentialAuthorization(request);
-  if (parsed === void 0) return { allowed: false };
-  return credentialDecision(
-    parsed.credentialId,
-    await store.verifyPersisted(parsed.credentialId, parsed.secret)
-  );
-}
-function credentialDecision(credentialId, result) {
-  const credential = result.credential;
-  const projectId = credential?.projectId;
-  if (!result.valid || credential === void 0 || projectId === void 0) {
-    return { allowed: false };
-  }
-  const identitySeparator = credential.principalId.indexOf("@");
-  const role = credential.kind === "agent" ? credential.principalId.slice(0, identitySeparator === -1 ? void 0 : identitySeparator) : void 0;
-  const sessionId = identitySeparator === -1 ? void 0 : credential.principalId.slice(identitySeparator + 1) || void 0;
-  return {
-    allowed: true,
-    rateLimitKey: `cred:${credentialId}`,
-    actor: {
-      actorId: credential.principalId,
-      projectId,
-      kind: credential.kind,
-      capabilities: new Set(credential.capabilities),
-      authMode: "identity-token",
-      recipientAliases: role === void 0 ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([role]),
-      ...role !== void 0 ? { role } : {},
-      ...sessionId !== void 0 ? { sessionId } : {}
-    }
-  };
-}
-function parseCredentialAuthorization(request) {
-  const header = request.headers.authorization;
-  if (typeof header !== "string") return void 0;
-  const match = /^Credential\s+([^:]+):(.+)$/i.exec(header);
-  if (match === null || match[1] === void 0 || match[2] === void 0) return void 0;
-  return { credentialId: match[1], secret: match[2] };
-}
-
 // src/coordination/mailbox-http-validation.ts
 var MAILBOX_HTTP_MAX_AGE_CEILING_MS = 7 * 24 * 60 * 60 * 1e3;
 var MailboxHttpValidationError = class extends Error {
@@ -9986,13 +10233,19 @@ function validateAgentRegistration(body, actor) {
   }
   return result;
 }
-function validateAgentHeartbeat(body, actorId) {
+function validateAgentHeartbeat(body, actor) {
   if (typeof body !== "object" || body === null) {
     throw validationError("expected JSON object body");
   }
   const object = body;
-  if (actorId !== void 0) rejectConflictingIdentity(object, "agentId", actorId);
-  const result = { agentId: actorId ?? requireString2(object, "agentId") };
+  if (actor !== void 0) {
+    rejectConflictingIdentity(object, "agentId", actor.actorId);
+    rejectConflictingOptionalIdentity(object, "sessionId", actor.sessionId);
+    rejectConflictingOptionalIdentity(object, "role", actor.role);
+  }
+  const agentId = actor?.actorId ?? requireString2(object, "agentId");
+  if (actor === void 0) validateReaderId(agentId);
+  const result = { agentId };
   const status = optionalString2(object, "status");
   const currentTool = optionalString2(object, "currentTool");
   const currentTask = optionalString2(object, "currentTask");
@@ -10013,6 +10266,25 @@ function validateAgentHeartbeat(body, actorId) {
     }
     result.toolCalls = toolCalls;
   }
+  const name = optionalString2(object, "name");
+  const pid = optionalNumber(object, "pid");
+  if (name !== void 0) result.name = name;
+  if (pid !== void 0) {
+    if (!Number.isInteger(pid) || pid < 1) {
+      throw validationError('field "pid" must be a positive integer when present');
+    }
+    result.pid = pid;
+  }
+  if (actor === void 0) {
+    const sessionId = optionalString2(object, "sessionId");
+    const role = optionalString2(object, "role");
+    if (sessionId !== void 0) result.sessionId = sessionId;
+    if (role !== void 0) result.role = role;
+  } else {
+    if (actor.sessionId !== void 0) result.sessionId = actor.sessionId;
+    if (actor.role !== void 0) result.role = actor.role;
+  }
+  result.source = "http";
   return result;
 }
 function validateClientRegistration(body) {
@@ -10192,6 +10464,60 @@ async function checkMailbox(mailbox, input, minTimestampIso, includeReceiptState
   return { data, count: data.length };
 }
 
+// src/coordination/mailbox-http-auth.ts
+import { timingSafeEqual } from "node:crypto";
+function authorizeMailboxBearerToken(request, expectedToken) {
+  const header = request.headers.authorization;
+  if (typeof header !== "string") return { allowed: false };
+  const match = /^Bearer\s+(.+)$/i.exec(header);
+  if (match === null) return { allowed: false };
+  const presented = Buffer.from(match[1] ?? "", "utf8");
+  const expected = Buffer.from(expectedToken, "utf8");
+  if (presented.length !== expected.length || !timingSafeEqual(presented, expected)) {
+    return { allowed: false };
+  }
+  return { allowed: true, rateLimitKey: expectedToken };
+}
+async function authorizePersistedMailboxCredential(request, store) {
+  const parsed = parseCredentialAuthorization(request);
+  if (parsed === void 0) return { allowed: false };
+  return credentialDecision(
+    parsed.credentialId,
+    await store.verifyPersisted(parsed.credentialId, parsed.secret)
+  );
+}
+function credentialDecision(credentialId, result) {
+  const credential = result.credential;
+  const projectId = credential?.projectId;
+  if (!result.valid || credential === void 0 || projectId === void 0) {
+    return { allowed: false };
+  }
+  const identitySeparator = credential.principalId.indexOf("@");
+  const role = credential.kind === "agent" ? credential.principalId.slice(0, identitySeparator === -1 ? void 0 : identitySeparator) : void 0;
+  const sessionId = identitySeparator === -1 ? void 0 : credential.principalId.slice(identitySeparator + 1) || void 0;
+  return {
+    allowed: true,
+    rateLimitKey: `cred:${credentialId}`,
+    actor: {
+      actorId: credential.principalId,
+      projectId,
+      kind: credential.kind,
+      capabilities: new Set(credential.capabilities),
+      authMode: "identity-token",
+      recipientAliases: role === void 0 ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([role]),
+      ...role !== void 0 ? { role } : {},
+      ...sessionId !== void 0 ? { sessionId } : {}
+    }
+  };
+}
+function parseCredentialAuthorization(request) {
+  const header = request.headers.authorization;
+  if (typeof header !== "string") return void 0;
+  const match = /^Credential\s+([^:]+):(.+)$/i.exec(header);
+  if (match === null || match[1] === void 0 || match[2] === void 0) return void 0;
+  return { credentialId: match[1], secret: match[2] };
+}
+
 // src/coordination/mailbox-http-sse.ts
 var MAX_SSE_BUFFER_BYTES = 8 * 1024 * 1024;
 function mailboxEventRecords(event) {
@@ -10422,7 +10748,10 @@ function createMailboxHttpRouter(options) {
             response,
             access3.status ?? 401,
             access3.body ?? {
-              error: { code: "UNAUTHORIZED", message: "invalid or missing authorization credential" }
+              error: {
+                code: "UNAUTHORIZED",
+                message: "invalid or missing authorization credential"
+              }
             }
           );
           return;
@@ -10480,7 +10809,10 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     const requiredCapability = requiredCredentialCapability(method, path12);
     if (requiredCapability === void 0) {
       writeJson(response, 403, {
-        error: { code: "FORBIDDEN", message: `credential access is not permitted for ${method} ${path12}` }
+        error: {
+          code: "FORBIDDEN",
+          message: `credential access is not permitted for ${method} ${path12}`
+        }
       });
       return;
     }
@@ -10613,7 +10945,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     return;
   }
   if (method === "POST" && path12 === "/mailbox/agents/heartbeat") {
-    const input = validateAgentHeartbeat(await readJsonBody(request, maxBodyBytes), actor?.actorId);
+    const input = validateAgentHeartbeat(await readJsonBody(request, maxBodyBytes), actor);
     if (actor !== void 0) input.agentId = actor.actorId;
     await mailbox.heartbeat(input);
     writeJson(response, 200, { ok: true });
@@ -10786,7 +11118,8 @@ async function getPackagesByAgent(opts, agentId) {
   const map = /* @__PURE__ */ new Map();
   for (const e of log.entries) {
     if (e.agentId === agentId) {
-      const key = `${e.manifestPath}|${e.packageName}`;
+      const normPath2 = e.manifestPath.replace(/\\/g, "/");
+      const key = `${normPath2}|${e.packageName}`;
       map.set(key, e);
     }
   }
@@ -11001,12 +11334,14 @@ var DEFAULTS2 = {
   degradedDurationMs: 3e4,
   blockAfterRateLimitHits: 1,
   blockAfterFailures: 5,
-  blockDurationMs: 3e5,
+  blockDurationMs: 12e4,
   quotaBlockDurationMs: 9e5,
+  quotaBlockEscalationMs: [18e5, 36e5],
   recoverAfterSuccesses: 3,
   maxErrorHistory: 50,
   quarantineSiblingsOnQuotaExhausted: true
 };
+var NON_QUOTA_HINT_CAP_FACTOR = 3;
 var ProviderModelStatusTracker = class {
   cfg;
   map = /* @__PURE__ */ new Map();
@@ -11015,6 +11350,7 @@ var ProviderModelStatusTracker = class {
   events;
   constructor(opts) {
     this.cfg = { ...DEFAULTS2, ...opts?.config };
+    this.cfg.quotaBlockEscalationMs = [...this.cfg.quotaBlockEscalationMs];
     this.events = opts?.events;
   }
   // ── Public API ──────────────────────────────────────────────────────────
@@ -11032,6 +11368,7 @@ var ProviderModelStatusTracker = class {
     const key = pairKey(providerId, model);
     const s = this.getOrCreate(key, providerId, model);
     s.consecutiveFailures = 0;
+    s.quotaBlockStreak = 0;
     s.consecutiveSuccesses += 1;
     s.totalSuccesses += 1;
     s.lastSuccessAt = Date.now();
@@ -11085,7 +11422,13 @@ var ProviderModelStatusTracker = class {
     const quotaExhausted = kind === "quota_exhausted" || isQuotaExhausted(kind, status, message);
     const providerWideQuota = quotaExhausted && !ROUTE_SCOPED_QUOTA_RE.test(message);
     const proseHintMs = quotaExhausted || kind === "rate_limit" ? parseResetHintMs(message, now) : void 0;
-    const effectiveRetryAfterMs = meta?.retryAfterMs && meta.retryAfterMs > 0 ? meta.retryAfterMs : proseHintMs;
+    const rawHintMs = meta?.retryAfterMs && meta.retryAfterMs > 0 ? meta.retryAfterMs : proseHintMs;
+    const effectiveRetryAfterMs = rawHintMs && rawHintMs > 0 ? quotaExhausted ? (
+      // Quota keeps the provider-published reset, but a corrupt or
+      // absurd structured Retry-After still cannot park a model
+      // beyond the prose-hint maximum.
+      Math.min(rawHintMs, MAX_RESET_HINT_MS)
+    ) : Math.min(rawHintMs, this.cfg.blockDurationMs * NON_QUOTA_HINT_CAP_FACTOR) : void 0;
     const entry = Object.freeze({
       timestamp: now,
       kind,
@@ -11105,7 +11448,8 @@ var ProviderModelStatusTracker = class {
     if (quotaExhausted) {
       newState = "blocked";
       reason = "quota_exhausted";
-      s.stateExpiresAt = now + this.cfg.quotaBlockDurationMs;
+      s.quotaBlockStreak += 1;
+      s.stateExpiresAt = now + this.quotaBlockDurationForStreak(s.quotaBlockStreak);
     } else if (endpointUnreachable) {
       newState = "blocked";
       reason = "endpoint_unreachable";
@@ -11131,13 +11475,18 @@ var ProviderModelStatusTracker = class {
     }
     if (newState !== "healthy" && effectiveRetryAfterMs && effectiveRetryAfterMs > 0) {
       const hintExpiry = now + effectiveRetryAfterMs;
-      if (s.stateExpiresAt === null || hintExpiry > s.stateExpiresAt) {
+      if (quotaExhausted) {
+        s.stateExpiresAt = hintExpiry;
+      } else if (s.stateExpiresAt === null || hintExpiry > s.stateExpiresAt) {
         s.stateExpiresAt = hintExpiry;
       }
     }
     if (this.cfg.quarantineSiblingsOnQuotaExhausted && providerWideQuota && s.stateExpiresAt !== null) {
       const previous = this.providerQuotaBlocks.get(providerId) ?? 0;
-      this.providerQuotaBlocks.set(providerId, Math.max(previous, s.stateExpiresAt));
+      this.providerQuotaBlocks.set(
+        providerId,
+        Math.max(previous, this.fanOutExpiryFor(now, s.stateExpiresAt))
+      );
     }
     if (s.state !== newState) {
       const oldState = s.state;
@@ -11147,10 +11496,26 @@ var ProviderModelStatusTracker = class {
       this.emitStatusChanged(providerId, model, s.state, s.state, "cooldown_extended");
     }
     if (this.cfg.quarantineSiblingsOnQuotaExhausted && providerWideQuota && newState === "blocked") {
-      this.quarantineSiblings(providerId, model, status, now, s.stateExpiresAt ?? 0);
+      this.quarantineSiblings(
+        providerId,
+        model,
+        status,
+        now,
+        this.fanOutExpiryFor(now, s.stateExpiresAt ?? now)
+      );
     }
     return newState;
   }
+  /**
+   * Quarantine fan-out expiry: the fixed quota cooldown, never the
+   * hint-extended trigger expiry. A weekly-cap reset time applies to the
+   * model that published it; sibling models (and unseen pairs behind the
+   * provider-wide gate) re-open after the base cooldown so one misclassified
+   * or hint-stretched failure cannot silence a whole provider for hours.
+   */
+  fanOutExpiryFor(now, triggerExpiry) {
+    return Math.min(triggerExpiry, now + this.cfg.quotaBlockDurationMs);
+  }
   /**
    * Mark every other tracked pair on the same provider as blocked with the
    * same expiry as the triggering pair. Only pairs already known to the
@@ -11247,6 +11612,7 @@ var ProviderModelStatusTracker = class {
       s.state = "healthy";
       s.stateExpiresAt = null;
       s.consecutiveFailures = 0;
+      s.quotaBlockStreak = 0;
       s.rateLimitHits = 0;
       s.overloadedHits = 0;
       s.serverErrors = 0;
@@ -11328,6 +11694,8 @@ var ProviderModelStatusTracker = class {
   /**
    * Release one entry for an immediate half-open probe on its next real use.
    * History and totals are retained so operators do not lose diagnostics.
+   * The quota escalation streak is also retained on purpose: a probe that
+   * fails with quota exhaustion again keeps climbing the ladder.
    */
   retryNow(providerId, model) {
     ({ providerId, model } = statusIdentity(providerId, model));
@@ -11470,13 +11838,29 @@ var ProviderModelStatusTracker = class {
       );
       if (this.cfg.quarantineSiblingsOnQuotaExhausted && providerWideQuota && !ROUTE_SCOPED_QUOTA_RE.test(s.lastErrorMessage ?? "") && s.state === "blocked" && s.stateExpiresAt !== null) {
         const previous = this.providerQuotaBlocks.get(providerId) ?? 0;
-        this.providerQuotaBlocks.set(providerId, Math.max(previous, s.stateExpiresAt));
+        this.providerQuotaBlocks.set(
+          providerId,
+          Math.max(previous, this.fanOutExpiryFor(now, s.stateExpiresAt))
+        );
       }
       restored += 1;
     }
     return restored;
   }
   // ── Private helpers ─────────────────────────────────────────────────────
+  /**
+   * Cooldown for the Nth consecutive quota block: the base duration for the
+   * first block, then the escalation ladder for repeats, capped at the last
+   * ladder entry. A provider-published reset hint bypasses this entirely
+   * (the pair is closed until that exact time instead).
+   */
+  quotaBlockDurationForStreak(streak) {
+    if (streak <= 1) return this.cfg.quotaBlockDurationMs;
+    const ladder = this.cfg.quotaBlockEscalationMs;
+    if (ladder.length === 0) return this.cfg.quotaBlockDurationMs;
+    const tier = Math.min(streak - 2, ladder.length - 1);
+    return ladder[tier] ?? this.cfg.quotaBlockDurationMs;
+  }
   getOrCreate(key, _providerId, _model) {
     let s = this.map.get(key);
     if (!s) {
@@ -11494,6 +11878,7 @@ var ProviderModelStatusTracker = class {
         firstFailureAt: null,
         lastFailureAt: null,
         stateExpiresAt: null,
+        quotaBlockStreak: 0,
         lastErrorKind: null,
         lastErrorMessage: null,
         lastErrorStatus: null,
@@ -11534,6 +11919,7 @@ var ProviderModelStatusTracker = class {
   emitStatusChanged(providerId, model, oldState, newState, reason) {
     if (!this.events) return;
     try {
+      const entry = this.map.get(pairKey(providerId, model));
       this.events.emit("provider.status_changed", {
         providerId,
         model,
@@ -11541,7 +11927,15 @@ var ProviderModelStatusTracker = class {
         newState,
         reason,
         timestamp: Date.now(),
-        stateExpiresAt: this.map.get(pairKey(providerId, model))?.stateExpiresAt ?? void 0
+        stateExpiresAt: entry?.stateExpiresAt ?? void 0,
+        // Error context for durable audit logs (who/what/why): the failure
+        // that led to this state, with the session/agent that hit it. Nulls
+        // normalize to undefined so JSON serialization drops them.
+        lastErrorKind: entry?.lastErrorKind ?? void 0,
+        lastErrorStatus: entry?.lastErrorStatus ?? void 0,
+        lastErrorMessage: entry?.lastErrorMessage ?? void 0,
+        lastSessionId: entry?.lastSessionId ?? void 0,
+        lastAgentId: entry?.lastAgentId ?? void 0
       });
     } catch {
     }
@@ -11686,7 +12080,7 @@ async function finalize(projectDir, tentative, boundPort) {
     url: `http://${tentative.host}:${boundPort}`
   };
   await atomicWriteJson(lockPath, finalized);
-  await fsp7.writeFile(tokenPath, finalized.token, { mode: 384 });
+  await atomicWriteString(tokenPath, finalized.token);
   return finalized;
 }
 async function release(projectDir, generation) {
@@ -11735,12 +12129,11 @@ async function readLiveLock(projectDir) {
   }
   return { kind: "absent" };
 }
-async function atomicWriteJson(targetPath, value) {
+async function atomicWriteString(targetPath, content) {
   const dir = path8.dirname(targetPath);
   await fsp7.mkdir(dir, { recursive: true });
   const tmp = `${targetPath}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
-  const body = JSON.stringify(value, null, 2) + "\n";
-  await fsp7.writeFile(tmp, body, { mode: 384 });
+  await fsp7.writeFile(tmp, content, { mode: 384 });
   try {
     await fsp7.rename(tmp, targetPath);
   } catch (err) {
@@ -11748,6 +12141,9 @@ async function atomicWriteJson(targetPath, value) {
     throw err;
   }
 }
+async function atomicWriteJson(targetPath, value) {
+  await atomicWriteString(targetPath, JSON.stringify(value, null, 2) + "\n");
+}
 async function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   if (pid === process.pid) return true;
@@ -11780,6 +12176,7 @@ async function probeHealthz(url) {
   try {
     const ctrl = new AbortController();
     const t = setTimeout(() => ctrl.abort(), 500);
+    if (typeof t.unref === "function") t.unref();
     const res = await fetch(`${url}/healthz`, {
       signal: ctrl.signal,
       redirect: "manual"
@@ -12212,8 +12609,11 @@ var AdaptiveConcurrencyController = class {
   }
   notifyStateChange() {
     const state = this.getState();
-    for (const handler of this.stateChangeHandlers) {
-      handler(state);
+    for (const handler of [...this.stateChangeHandlers]) {
+      try {
+        handler(state);
+      } catch {
+      }
     }
   }
   /**
@@ -12309,14 +12709,28 @@ var AgentMonitorService = class _AgentMonitorService {
    *
    * Entries already in the ring win: a live subagent's in-memory segment is
    * newer than its JSONL, which is only written when a segment closes.
+   *
+   * `only` restricts BOTH the disk scan and the returned set to a known list of
+   * subagent ids. This is how a session gets ITS OWN subagents back: the
+   * transcripts directory is shared by every session of the project, so the
+   * unfiltered form hands each of four open tabs the union of all four tabs'
+   * workers. The caller derives the list from the session's own journal
+   * (`deriveSessionAgents`), which is the only record that says which agents
+   * belong to which session.
    */
-  async loadSessionsFromDisk() {
+  async loadSessionsFromDisk(only) {
+    const wanted = only === void 0 ? void 0 : new Set(only);
+    if (wanted?.size === 0) return [];
     let subagentIds;
-    try {
-      const dirents = await fs3.readdir(this._transcriptsDir, { withFileTypes: true });
-      subagentIds = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
-    } catch {
-      return this.getAllSessions();
+    if (wanted) {
+      subagentIds = [...wanted];
+    } else {
+      try {
+        const dirents = await fs3.readdir(this._transcriptsDir, { withFileTypes: true });
+        subagentIds = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+      } catch {
+        return this.getAllSessions();
+      }
     }
     for (const subagentId of subagentIds) {
       if (this._sessions.has(subagentId)) continue;
@@ -12334,7 +12748,8 @@ var AgentMonitorService = class _AgentMonitorService {
         transcript: transcript.slice(-this._maxEntries)
       });
     }
-    return this.getAllSessions();
+    const all = this.getAllSessions();
+    return wanted ? all.filter((session) => wanted.has(session.subagentId)) : all;
   }
   async _readTranscriptFile(subagentId) {
     const file = path9.join(this._transcriptsDir, subagentId, "transcript.jsonl");
@@ -12678,7 +13093,8 @@ var AgentMonitorService = class _AgentMonitorService {
     this._writeDrain = drain;
   }
   async _appendToFile(subagentId, line) {
-    const dir = path9.join(this._transcriptsDir, subagentId);
+    const cleanId = subagentId.replace(/\\/g, "/");
+    const dir = path9.join(this._transcriptsDir, cleanId);
     if (!this._ensuredDirs.has(dir)) {
       await fs3.mkdir(dir, { recursive: true });
       this._ensuredDirs.add(dir);
@@ -13416,6 +13832,10 @@ var KnowledgeGraph = class _KnowledgeGraph {
             this._trackSeq(parsed.node.id);
             this._addToIndex(parsed.node, this._indexKeys(parsed.node));
           } else {
+            const oldNode = this.nodes.get(parsed.id);
+            if (oldNode) {
+              this._removeFromIndex(oldNode, this._indexKeys(oldNode));
+            }
             this.nodes.set(parsed.id, parsed);
             this._trackSeq(parsed.id);
             this._addToIndex(parsed, this._indexKeys(parsed));
@@ -14570,7 +14990,6 @@ var ChangeManager = class {
     });
     this.appliedChanges.set(appliedChangeId, rollback.id);
     await this.graph.update(appliedChangeId, {
-      rolledBackAt: (/* @__PURE__ */ new Date()).toISOString(),
       rollbackReason: reason
     });
     this._emit("change:rollback_proposed", {
@@ -16332,6 +16751,8 @@ export {
   BrainTraceRecorder,
   readBrainTrace,
   CollaborationBus,
+  collabPauseMiddleware,
+  collabInjectMiddleware,
   recordFileAction,
   getLastAuthor,
   getFileHistory,
@@ -16350,10 +16771,10 @@ export {
   FleetSpawnBudgetError,
   FleetCostCapError,
   FleetTokenCapError,
-  setKanbanDispatch,
-  kanbanDispatch,
   setKanbanBoundaryOps,
   kanbanBoundaryOps,
+  setKanbanDispatch,
+  kanbanDispatch,
   parseTaskBoundary,
   renderTaskBoundaryBlock,
   composeBoundedTaskDescription,
@@ -16369,8 +16790,8 @@ export {
   makeCollabDebugTool,
   makeFleetEmitTool,
   makeWorkCompleteTool,
-  makeQualityGateTool,
   makeMutationTestTool,
+  makeQualityGateTool,
   makeSpawnTool,
   makeKanbanQueueTool,
   DEFAULT_DIRECTOR_PREAMBLE,
@@ -16408,6 +16829,7 @@ export {
   parseMailboxAckInput,
   makeMailSendTool,
   makeMailInboxTool,
+  makeSessionNoteTool,
   actionToAckInput,
   MAILBOX_HEALTH_DEFAULT_INTERVAL_MS,
   MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS,
@@ -16418,9 +16840,9 @@ export {
   buildRecoveryAlert,
   validateWatchdogOptions,
   createMailboxHooks,
+  MAILBOX_HTTP_MAX_AGE_CEILING_MS,
   authorizeMailboxBearerToken,
   authorizePersistedMailboxCredential,
-  MAILBOX_HTTP_MAX_AGE_CEILING_MS,
   MAILBOX_HTTP_RATE_LIMIT_PER_MINUTE,
   MAILBOX_HTTP_RATE_LIMIT_WINDOW_MS,
   MailboxHttpRateLimiter,
@@ -16445,8 +16867,6 @@ export {
   release,
   readLiveLock,
   startTechStackConsumer,
-  collabPauseMiddleware,
-  collabInjectMiddleware,
   AdaptiveConcurrencyController,
   AgentMonitorService,
   createAgentMonitorService,
@@ -16461,4 +16881,4 @@ export {
   AgentStatusTracker,
   FleetNotifier
 };
-//# sourceMappingURL=chunk-FW5LDDMJ.js.map
+//# sourceMappingURL=chunk-45WI72ZB.js.map