@wrongstack/core 0.308.6 → 0.309.0

package/dist/coordination/index.js

@@ -285,6 +285,46 @@ function createMessage(type, from, payload, to) {
   };
 }
 
+// src/core/btw.ts
+var META_KEY = "_btwNotes";
+var MAX_PENDING = 20;
+function readQueue(ctx) {
+  const raw = ctx.meta[META_KEY];
+  return Array.isArray(raw) ? raw : [];
+}
+function setBtwNote(ctx, text) {
+  const trimmed = text.trim();
+  if (!trimmed) return readQueue(ctx).length;
+  const next = [...readQueue(ctx), trimmed].slice(-MAX_PENDING);
+  ctx.meta[META_KEY] = next;
+  return next.length;
+}
+
+// src/coordination/subagent-finish.ts
+var SUBAGENT_FINISH_REQUESTED_EVENT = "subagent.finish_requested";
+var DEFAULT_SUBAGENT_FINISH_GRACE_MS = 12e4;
+function resolveGracefulFinish(config) {
+  const raw = config.gracefulFinish;
+  if (raw === void 0 || raw === false) return void 0;
+  if (raw === true) return { graceMs: DEFAULT_SUBAGENT_FINISH_GRACE_MS };
+  const graceMs = typeof raw.graceMs === "number" && Number.isFinite(raw.graceMs) && raw.graceMs > 0 ? Math.floor(raw.graceMs) : DEFAULT_SUBAGENT_FINISH_GRACE_MS;
+  return { graceMs };
+}
+function buildSubagentFinishNotice(input) {
+  const localTime = new Date(input.deadlineMs).toISOString();
+  const seconds = Math.max(1, Math.round(input.graceMs / 1e3));
+  const timeLeft = input.graceMs > 0 ? `You have roughly ${seconds} seconds (until ${localTime}) of legitimate working time left.` : `Your working-time window is already spent (deadline was ${localTime}) \u2014 finish now.`;
+  return [
+    "[SUBAGENT FINISH] The leader agent has finished its work.",
+    `Reason: ${input.reason}`,
+    timeLeft,
+    "Finish your task now, in this turn: complete the thought you are working on, stop",
+    "starting new tool calls unless one is strictly required to finish, and write your",
+    "final answer or report as your final output, then end your turn.",
+    "Do not restart the task and do not begin new work."
+  ].join("\n");
+}
+
 // src/coordination/subagent-budget.ts
 var TIMEOUT_PREEMPT_FRACTION = 0.85;
 var DECISION_TIMEOUT_MS = 6e4;
@@ -342,6 +382,82 @@ var SubagentBudget = class _SubagentBudget {
       this.limits.idleTimeoutMs = ext.idleTimeoutMs;
     }
   }
+  /**
+   * Graceful-finish state (see coordination/subagent-finish.ts).
+   * `_finishNotified` guards the single in-band emission; `_grace` records a
+   * granted working-time extension past the original wall-clock deadline.
+   * They are separate because the two callers want different semantics:
+   * the watchdog grants grace at the deadline crossing (notify + extend),
+   * while an explicit leader-finished request only notifies — a subagent
+   * well inside its budget keeps its full legitimate working time and simply
+   * accelerates.
+   */
+  _finishNotified = false;
+  _grace = null;
+  /** True once the in-band finish notification has been emitted. */
+  get finishNotified() {
+    return this._finishNotified;
+  }
+  /** True once a grace window has been granted past the original deadline. */
+  get graceGranted() {
+    return this._grace !== null;
+  }
+  /**
+   * Notify the subagent in-band to finish its task in its own turn:
+   * `subagent.finish_requested` is emitted on the wired EventBus and the
+   * agent loop folds the notice into the conversation between tool batches.
+   * Nothing aborts — this is a notification, never an interrupt.
+   *
+   * `opts.graceMs` additionally extends the wall-clock ceiling by that window
+   * (used by the watchdog at a deadline crossing, so the model gets working
+   * time instead of a kill). Omit it to notify without touching the budget —
+   * the subagent keeps its existing time budget and just accelerates.
+   *
+   * Returns `true` when this call did something (emitted the notification
+   * and/or granted grace); `false` when there was nothing to do (already
+   * notified, grace already granted, no EventBus wired, budget not started).
+   */
+  notifyFinish(reason, opts, now = Date.now) {
+    if (!this._events) return false;
+    if (this.startTime === null) return false;
+    const shouldEmit = !this._finishNotified;
+    const rawGrace = opts?.graceMs;
+    const shouldGrant = rawGrace !== void 0 && this._grace === null;
+    if (!shouldEmit && !shouldGrant) return false;
+    let grantedGraceMs = 0;
+    let graceDeadlineMs;
+    if (shouldGrant && rawGrace !== void 0) {
+      grantedGraceMs = Number.isFinite(rawGrace) && rawGrace > 0 ? Math.floor(rawGrace) : DEFAULT_SUBAGENT_FINISH_GRACE_MS;
+      graceDeadlineMs = now() + grantedGraceMs;
+      this._grace = { deadlineMs: graceDeadlineMs, graceMs: grantedGraceMs };
+      this.patchLimits({ timeoutMs: graceDeadlineMs - this.startTime });
+    }
+    if (shouldEmit) {
+      this._finishNotified = true;
+      const effectiveDeadlineMs = graceDeadlineMs ?? (this.limits.timeoutMs !== void 0 ? this.startTime + this.limits.timeoutMs : now() + DEFAULT_SUBAGENT_FINISH_GRACE_MS);
+      const effectiveGraceMs = Math.max(0, effectiveDeadlineMs - now());
+      const subagentId = this._subagentId;
+      this._events.emit(SUBAGENT_FINISH_REQUESTED_EVENT, {
+        // Omitted entirely when the budget was built without an id — an
+        // empty string is an address that matches nothing.
+        ...subagentId !== void 0 ? { subagentId } : {},
+        reason,
+        deadlineMs: effectiveDeadlineMs,
+        graceMs: effectiveGraceMs,
+        notice: buildSubagentFinishNotice({
+          reason,
+          deadlineMs: effectiveDeadlineMs,
+          graceMs: effectiveGraceMs
+        })
+      });
+    }
+    return true;
+  }
+  /** Epoch ms by which the subagent should have produced its final output,
+   *  once a grace window was granted. Undefined before that. */
+  get finishDeadlineMs() {
+    return this._grace?.deadlineMs;
+  }
   iterations = 0;
   toolCalls = 0;
   tokenInput = 0;
@@ -357,6 +473,10 @@ var SubagentBudget = class _SubagentBudget {
   lastActivityTime = null;
   _onThreshold;
   _sessionId;
+  /** Owning subagent id — used to address the graceful-finish event. */
+  _subagentId;
+  /** True when only the coordinator watchdog may enforce wall-clock limits. */
+  _wallClockWatchdogOwned;
   /**
    * Hard cap on how long `_negotiateExtension` waits for the coordinator to
    * respond before defaulting to 'stop'. Without this fallback an absent
@@ -428,6 +548,8 @@ var SubagentBudget = class _SubagentBudget {
   constructor(limits = {}, mode = "auto", options = {}) {
     this._mode = mode;
     this._sessionId = options.sessionId;
+    this._subagentId = options.subagentId;
+    this._wallClockWatchdogOwned = options.wallClockWatchdogOwned === true;
     this.limits = { ...limits };
   }
   currentSessionId() {
@@ -506,7 +628,7 @@ var SubagentBudget = class _SubagentBudget {
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
         exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
       }
-      const wallOwnedByWatchdog = this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
+      const wallOwnedByWatchdog = this._wallClockWatchdogOwned || this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
       if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs && !wallOwnedByWatchdog) {
         exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
       }
@@ -705,7 +827,7 @@ var SubagentBudget = class _SubagentBudget {
     if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
     const wallSkipped = this._onThreshold !== void 0 && this._watchdogActive !== void 0 && timeoutMs !== void 0 && this._watchdogActive === timeoutMs;
-    const wallTripped = wallSkipped ? false : timeoutMs !== void 0 && elapsed > timeoutMs;
+    const wallTripped = this._wallClockWatchdogOwned || wallSkipped ? false : timeoutMs !== void 0 && elapsed > timeoutMs;
     const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
     if (!wallTripped && !idleTripped) return;
     void this.checkLimits(elapsed);
@@ -1165,6 +1287,14 @@ function makeAgentSubagentRunner(opts) {
     );
     const onParentAbort = () => aborter.abort();
     ctx.signal.addEventListener("abort", onParentAbort);
+    if (resolveGracefulFinish(ctx.config)) {
+      unsub.push(
+        events.on("subagent.finish_requested", (e) => {
+          if (e.subagentId && e.subagentId !== ctx.subagentId) return;
+          setBtwNote(agent.ctx, e.notice);
+        })
+      );
+    }
     let result;
     try {
       result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
@@ -2862,6 +2992,7 @@ function inferRuntimeCapabilities(toolNames) {
 var skillSet = (...names) => names;
 var ROLE_SKILL_SETS = {
   explore: skillSet("research-web", "node-modern", "typescript-strict"),
+  "explore-companion": skillSet("node-modern", "typescript-strict"),
   search: skillSet("bug-hunter", "typescript-strict", "research-web"),
   research: skillSet("research-web", "tech-stack", "security-scanner", "api-design"),
   analyst: skillSet("sdd", "api-design", "testing", "security-scanner"),
@@ -10389,6 +10520,42 @@ var SHADOW_AGENT = {
   ...defineAgent("shadow-agent", "Shadow"),
   skillNames: [...SHADOW_AGENT_SKILLS]
 };
+var EXPLORE_COMPANION_AGENT = {
+  ...defineAgent("explore-companion", "Explore Companion"),
+  tools: [...TOOLS.read, ...TOOLS.index],
+  // Read-only, triple-enforced: allowlist has no write/bash, and the
+  // disabled list blocks the escape hatches explicitly.
+  disabledTools: [
+    "write",
+    "edit",
+    "replace",
+    "patch",
+    "bash",
+    "exec",
+    "delegate",
+    "spawn_subagent",
+    "assign_task"
+  ],
+  skillNames: [...ROLE_SKILL_SETS["explore-companion"]],
+  spawnBudgetExempt: true,
+  // Findings travel via mailbox + submit_result, not the leader's stream.
+  textStream: "silent",
+  toolStream: "silent"
+};
+var CHAOS_MONKEY_AGENT = {
+  ...defineAgent("chaos-monkey", "Chaos Monkey"),
+  tools: [...TOOLS.build],
+  skillNames: ["testing", "typescript-strict"],
+  spawnBudgetExempt: true,
+  // Follow fleet worktree policy (NOT 'required'): mutation targets are
+  // often freshly written and uncommitted — a worktree spawned from HEAD
+  // would not contain them and every mutant would drift. Callers pass
+  // `worktree: 'off'` in the mutation_test input for uncommitted targets.
+  worktree: "auto",
+  // Report travels via submit_result + final text, not the leader's stream.
+  textStream: "silent",
+  toolStream: "silent"
+};
 var CRITIC_AGENT = defineAgent("critic", "Critic");
 var GENERIC_AGENT = defineAgent("generic", "Generic Project Agent");
 function withDispatchMetadata(definition) {
@@ -10407,6 +10574,8 @@ var FLEET_ROSTER = {
   critic: CRITIC_AGENT,
   generic: GENERIC_AGENT,
   "shadow-agent": SHADOW_AGENT,
+  "explore-companion": EXPLORE_COMPANION_AGENT,
+  "chaos-monkey": CHAOS_MONKEY_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, withDispatchMetadata(d)])
   )
@@ -10430,6 +10599,23 @@ var FLEET_ROSTER_BUDGETS = {
     maxTokens: 96e3,
     maxCostUsd: 0.5
   },
+  "explore-companion": {
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: 3e3,
+    maxToolCalls: 8e3,
+    maxTokens: 96e3,
+    maxCostUsd: 0.5
+  },
+  "chaos-monkey": {
+    // A mutation pass is many short apply/run/restore cycles — per-mutant
+    // work is tiny, but a large plan (25 mutants/file × N files) needs
+    // headroom. Idle-based reaping covers a stalled pass.
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: 2e3,
+    maxToolCalls: 6e3,
+    maxTokens: 96e3,
+    maxCostUsd: 0.5
+  },
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
   )
@@ -11168,89 +11354,648 @@ async function readSubagentPartial(opts, subagentId) {
   return void 0;
 }
 
-// src/coordination/dep-watcher.ts
-var DEPENDENCY_FILE_PATTERNS = [
-  "package.json",
-  "tsconfig.json",
-  "pnpm-lock.yaml",
-  "yarn.lock",
-  "package-lock.json",
-  "go.mod",
-  "go.sum",
-  "Cargo.toml",
-  "Cargo.lock",
-  "pyproject.toml",
-  "setup.py",
-  "setup.cfg",
-  "requirements.txt",
-  "Pipfile",
-  "Pipfile.lock",
-  "Gemfile",
-  "Gemfile.lock",
-  "composer.json",
-  "composer.lock",
-  "mix.exs",
-  "mix.lock",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts",
-  "settings.gradle",
-  "settings.gradle.kts",
-  "*.csproj",
-  "packages.config",
-  "pubspec.yaml",
-  "pubspec.lock",
-  "CMakeLists.txt",
-  "conanfile.txt",
-  "conanfile.py",
-  "vcpkg.json"
-];
-function makeDependencyWatcherConfig(opts) {
-  const {
-    projectRoot,
-    mailbox,
-    targetAgent = "*",
-    watcherAgentId = "dep-watcher",
-    debounceMs = 3e3,
-    patterns = DEPENDENCY_FILE_PATTERNS
-  } = opts;
-  const watchPaths = [];
-  for (const p of patterns) {
-    if (p.includes("*")) {
-      continue;
-    }
-    watchPaths.push(`${projectRoot}/${p}`);
+// src/coordination/explore-companion.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+
+// src/coordination/mailbox-type-properties.ts
+var MAILBOX_TYPE_PROPERTIES = {
+  note: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 20,
+    recipientObligation: "Read for context; no reply needed.",
+    senderGuidance: "General-purpose FYI. Use when no more specific type applies."
+  },
+  ask: {
+    category: "actionable",
+    expectsReply: true,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Answer as soon as possible \u2014 the sender is waiting.",
+    senderGuidance: "Blocking question. Only use when you need an answer to proceed."
+  },
+  assign: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Accept or decline; act on it when current operation allows.",
+    senderGuidance: 'Task delegation. Must be directed to a specific recipient (not "*").'
+  },
+  steer: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 0,
+    // Always rendered first
+    recipientObligation: "Pause current approach, adjust per instruction, then resume.",
+    senderGuidance: "Mid-task direction change. The recipient is already working on something."
+  },
+  btw: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 30,
+    recipientObligation: "Absorb the information and stay on current task; no reply needed.",
+    senderGuidance: "Low-priority aside. Non-urgent info that can wait."
+  },
+  broadcast: {
+    category: "routing",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 20,
+    recipientObligation: 'Read if addressed to you (direct recipient, alias, or "*").',
+    senderGuidance: 'Multi-recipient envelope. Auto-selected when to is "*" or "@session".'
+  },
+  status: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 40,
+    recipientObligation: "Use to avoid redundant work; never act on as a task or question.",
+    senderGuidance: "Agent/system status update. Machine-generated, not for human-originated messages."
+  },
+  result: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Factor into next decision; treat as evidence, not a new task.",
+    senderGuidance: "Task completion notice. Share the outcome of finished work."
+  },
+  review: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Inspect when convenient; no immediate reply required.",
+    senderGuidance: "Passive review request (code/doc/PR). No reply required."
+  },
+  control: {
+    category: "control_signal",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: true,
+    renderPriority: 999,
+    // Never rendered
+    recipientObligation: 'Handled by the agent loop, NOT folded into conversation. "interrupt" causes cooperative halt.',
+    senderGuidance: "RESERVED for runtime use. Agents must NOT send control messages."
   }
-  watchPaths.push(projectRoot);
-  const unique = [...new Set(watchPaths)];
-  const isMultiRecipient = targetAgent === "*" || targetAgent.startsWith("@session:");
-  const globPatterns = patterns.filter((p) => p.includes("*"));
-  const plainPatterns = patterns.filter((p) => !p.includes("*"));
-  function matchesPattern(filePath) {
-    const basename6 = filePath.split("/").pop()?.split("\\").pop() ?? "";
-    if (plainPatterns.includes(basename6)) return true;
-    for (const gp of globPatterns) {
-      const regex = new RegExp(
-        "^" + gp.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
-      );
-      if (regex.test(basename6)) return true;
-    }
-    return false;
+};
+
+// src/coordination/mailbox-auth-types.ts
+var MAILBOX_CAPABILITY_IMPLICATIONS = {
+  "mail.read.all": ["mail.read.self"],
+  "mail.events.all": ["mail.events.self"],
+  "mail.send.directive": ["mail.send.actionable", "mail.send.informational"],
+  "mail.send.actionable": ["mail.send.informational"],
+  // Leaf capabilities imply nothing further.
+  "mail.send.informational": [],
+  "mail.read.self": [],
+  "mail.ack.self": [],
+  "mail.events.self": [],
+  "mail.presence.register.self": [],
+  "mail.presence.heartbeat.self": [],
+  "mail.presence.deregister.self": [],
+  "mail.presence.read": [],
+  "mail.retention.purge": [],
+  "mail.retention.clear": [],
+  "mail.admin.receipts": []
+};
+function expandMailboxCapabilities(caps) {
+  const result = /* @__PURE__ */ new Set();
+  const queue = [...caps];
+  while (queue.length > 0) {
+    const cap = queue.pop();
+    if (result.has(cap)) continue;
+    result.add(cap);
+    const implied = MAILBOX_CAPABILITY_IMPLICATIONS[cap];
+    if (implied) queue.push(...implied);
   }
-  const pending = /* @__PURE__ */ new Map();
-  return {
-    watchPaths: unique,
-    debounceMs,
-    dispose() {
-      for (const t of pending.values()) clearTimeout(t);
-      pending.clear();
-    },
-    async onChange(entry) {
-      if (entry.event === "delete") return;
-      if (!matchesPattern(entry.path)) return;
-      const key = entry.path;
-      const existing = pending.get(key);
-      if (existing) clearTimeout(existing);
+  return result;
+}
+function hasMailboxCapability(actor, cap) {
+  if (actor.capabilities.has(cap)) return true;
+  const expanded = expandMailboxCapabilities(actor.capabilities);
+  return expanded.has(cap);
+}
+
+// src/coordination/mailbox-predicates.ts
+function mailboxIdentityBase(agentId) {
+  return agentId.split(/[@#]/, 1)[0].trim().toLowerCase();
+}
+function isMailboxLeader(agentId, role) {
+  return mailboxIdentityBase(agentId) === "leader" || role?.trim().toLowerCase() === "leader";
+}
+function isMailboxSenderInFamily(senderId, family) {
+  const base = mailboxIdentityBase(senderId);
+  const normalizedFamily = family.trim().toLowerCase();
+  if (normalizedFamily.length === 0) return false;
+  return base === normalizedFamily || base.startsWith(`${normalizedFamily}-`);
+}
+function isMailboxMessageVisibleTo(message, agentId, role) {
+  return message.audience !== "leaders" || isMailboxLeader(agentId, role);
+}
+function validateSendType(type, to) {
+  if (type === "control") {
+    throw new TypeError('Type "control" is reserved for runtime use and cannot be set by agents');
+  }
+  const isMultiRecipient = to === "*" || to.startsWith("@session:");
+  if (type === "assign" && isMultiRecipient) {
+    throw new TypeError(
+      `Type "assign" requires a specific recipient \u2014 multi-recipient target "${to}" is ambiguous`
+    );
+  }
+  if (type === "steer" && isMultiRecipient) {
+    throw new TypeError(
+      `Type "steer" requires a specific recipient \u2014 multi-recipient target "${to}" is ambiguous`
+    );
+  }
+}
+var SESSION_RECIPIENT_PREFIX = "@session:";
+function sessionRecipient(sessionId) {
+  const normalizedSessionId = sessionId.trim();
+  if (!normalizedSessionId) {
+    throw new TypeError('sessionId is required for the "@session" recipient');
+  }
+  return `${SESSION_RECIPIENT_PREFIX}${normalizedSessionId}`;
+}
+function normalizeRecipient(to, sessionId) {
+  const trimmed = to.trim();
+  const normalized = trimmed.toLowerCase();
+  if (normalized === "all") return "*";
+  if (normalized === "@session") return sessionRecipient(sessionId ?? "");
+  return trimmed;
+}
+function isActionRequiredForActor(message, projection) {
+  if (projection.legacyGlobalCompletion) return false;
+  if (message.deletedAt !== void 0) return false;
+  if (projection.completedByMe) return false;
+  return MAILBOX_TYPE_PROPERTIES[message.type]?.requiresAction === true;
+}
+
+// src/coordination/mailbox-session-sync.ts
+function isAffectedBySessionAffinity(message) {
+  return message.sessionAffinity !== void 0;
+}
+async function acceptMailboxMessageForSession(message, currentSessionId, ctx) {
+  if (!isAffectedBySessionAffinity(message)) return true;
+  const affinity = message.sessionAffinity;
+  if (affinity === null || typeof affinity !== "object" || Array.isArray(affinity)) {
+    return false;
+  }
+  if (affinity.sessionId !== void 0 && typeof affinity.sessionId !== "string" || affinity.reportId !== void 0 && typeof affinity.reportId !== "string") {
+    return false;
+  }
+  if (!currentSessionId) {
+    return ctx?.allowUnscoped === true;
+  }
+  if (typeof affinity.sessionId === "string" && affinity.sessionId.length > 0) {
+    if (affinity.sessionId !== currentSessionId) return false;
+    return true;
+  }
+  if (affinity.reportId && ctx?.resolveChimeraReportSessionId) {
+    try {
+      const resolved = await ctx.resolveChimeraReportSessionId(affinity.reportId);
+      if (resolved === currentSessionId) return true;
+      if (resolved !== void 0) return false;
+    } catch {
+    }
+  }
+  if (ctx?.allowUnscoped === true) return true;
+  return false;
+}
+
+// src/coordination/explore-companion.ts
+var DEFAULT_EXPLORE_COMPANION_AGENT_ID = "explore-companion";
+var DEFAULT_PROBE_COOLDOWN_MS = 12e4;
+var DEFAULT_MAX_PENDING_PROBES = 8;
+var DEFAULT_MAILBOX_POLL_INTERVAL_MS = 5e3;
+var DEFAULT_EXPLORE_EDIT_TOOLS = [
+  "edit",
+  "write",
+  "patch",
+  "multi_edit",
+  "multiedit",
+  "str_replace"
+];
+var DEFAULT_EXPLORE_SEARCH_TOOLS = [
+  "search",
+  "grep",
+  "codebase-search"
+];
+function buildProbeTaskText(probe) {
+  const payload = { probe: probe.probe };
+  if (probe.hint) payload.hint = probe.hint;
+  if (probe.context) payload.context = probe.context;
+  return JSON.stringify(payload, null, 2);
+}
+function extractedPath(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const rec = input;
+  const candidate = typeof rec["path"] === "string" ? rec["path"] : typeof rec["file"] === "string" ? rec["file"] : void 0;
+  return candidate && candidate.length > 0 ? candidate : void 0;
+}
+function looksEmpty(e) {
+  if (typeof e.outputLines === "number" && e.outputLines === 0) return true;
+  const out = e.output ?? "";
+  return /(?:^|\n)(?:no |0 )(?:matches|results|files? found|occurrences)/i.test(out) || /total\s*:\s*0\b/i.test(out);
+}
+function extractSubjectTokens(text) {
+  const out = [];
+  const fileRe = /([\w@./-]+\.(?:[cm]?[jt]sx?|json|md|py|go|rs|ya?ml))\b/g;
+  for (const m of text.matchAll(fileRe)) {
+    const value = m[1];
+    if (value) out.push({ kind: "file", value });
+  }
+  const symRe = /\b[A-Z][A-Za-z0-9_]{2,}\b/g;
+  for (const m of text.matchAll(symRe)) {
+    out.push({ kind: "symbol", value: m[0] });
+  }
+  return out;
+}
+var ExploreCompanion = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.cfg = this.resolveConfig(opts);
+  }
+  opts;
+  unsubscribers = [];
+  /** Paths the leader has read (readSet) — feeds edit-unread + unfamiliar-read. */
+  readSet = /* @__PURE__ */ new Set();
+  /** subject → last probe time; cooldown gate. Survives detach/reconfigure. */
+  probedAt = /* @__PURE__ */ new Map();
+  /** todo id → last observed status, per leader agent. */
+  todoSeen = /* @__PURE__ */ new Map();
+  pending = [];
+  inFlight = false;
+  pollTimer;
+  running = false;
+  hostStarted = false;
+  cfg;
+  resolveConfig(opts) {
+    const signals = opts.signals ?? {};
+    return {
+      enabled: opts.enabled ?? true,
+      cooldownMs: opts.cooldownMs ?? DEFAULT_PROBE_COOLDOWN_MS,
+      maxPending: opts.maxPending ?? DEFAULT_MAX_PENDING_PROBES,
+      pollIntervalMs: opts.pollIntervalMs ?? DEFAULT_MAILBOX_POLL_INTERVAL_MS,
+      companionAgentId: opts.companionAgentId ?? DEFAULT_EXPLORE_COMPANION_AGENT_ID,
+      signals: {
+        editUnreadFile: signals.editUnreadFile ?? true,
+        searchZeroHits: signals.searchZeroHits ?? true,
+        unfamiliarRead: signals.unfamiliarRead ?? true,
+        todoInProgress: signals.todoInProgress ?? true,
+        errorSymbol: signals.errorSymbol ?? true,
+        mailboxAsk: signals.mailboxAsk ?? true
+      },
+      fileEditTools: new Set(
+        (opts.fileEditTools ?? DEFAULT_EXPLORE_EDIT_TOOLS).map((t) => t.toLowerCase())
+      ),
+      searchTools: new Set(
+        (opts.searchTools ?? DEFAULT_EXPLORE_SEARCH_TOOLS).map((t) => t.toLowerCase())
+      )
+    };
+  }
+  /** Resolve the leader's own session id for event filtering. */
+  resolveLeaderSessionId() {
+    const sid = this.opts.leaderSessionId;
+    return typeof sid === "function" ? sid() : sid;
+  }
+  /** Resolve the leader's agent id for todo diffing (optional signal). */
+  resolveLeaderAgentId() {
+    const aid = this.opts.leaderAgentId;
+    if (!aid) return void 0;
+    return typeof aid === "function" ? aid() : aid;
+  }
+  /** Re-apply tunables to a (possibly running) companion. */
+  reconfigure(next) {
+    const merged = { ...this.opts, ...next };
+    const nextCfg = this.resolveConfig(merged);
+    const changed = nextCfg.enabled !== this.cfg.enabled || nextCfg.cooldownMs !== this.cfg.cooldownMs || nextCfg.maxPending !== this.cfg.maxPending || nextCfg.pollIntervalMs !== this.cfg.pollIntervalMs || nextCfg.companionAgentId !== this.cfg.companionAgentId || Object.keys(nextCfg.signals).some(
+      (k) => nextCfg.signals[k] !== this.cfg.signals[k]
+    );
+    this.cfg = nextCfg;
+    if (!changed) return false;
+    if (this.hostStarted) {
+      this.detach();
+      this.attach();
+    }
+    return true;
+  }
+  /** Begin watching. Idempotent; a disabled companion records intent only. */
+  start() {
+    this.hostStarted = true;
+    this.attach();
+  }
+  /** Stop watching and drop the host's intent to watch. */
+  stop() {
+    this.hostStarted = false;
+    this.detach();
+  }
+  /** True while the watchers are attached. */
+  isRunning() {
+    return this.running;
+  }
+  /** Number of probes queued but not yet dispatched (for status surfaces). */
+  pendingCount() {
+    return this.pending.length;
+  }
+  attach() {
+    if (!this.cfg.enabled || this.running) return;
+    this.running = true;
+    this.unsubscribers.push(
+      this.opts.events.on("tool.executed", (e) => {
+        const lsid = this.resolveLeaderSessionId();
+        if (lsid && e.sessionId && e.sessionId !== lsid) return;
+        this.trackToolExecuted(e);
+      })
+    );
+    if (this.cfg.signals.todoInProgress && this.resolveLeaderAgentId()) {
+      this.unsubscribers.push(
+        this.opts.events.on("session.agents_updated", (e) => {
+          const lsid = this.resolveLeaderSessionId();
+          if (lsid && e.sessionId && e.sessionId !== lsid) return;
+          this.trackAgentTodos(e.agents);
+        })
+      );
+    }
+    if (this.cfg.signals.errorSymbol) {
+      this.unsubscribers.push(
+        this.opts.events.on("error", (e) => {
+          const lsid = this.resolveLeaderSessionId();
+          if (lsid && e.sessionId && e.sessionId !== lsid) return;
+          this.trackError(e.err);
+        })
+      );
+    }
+    if (this.cfg.signals.mailboxAsk) {
+      this.pollTimer = setInterval(() => {
+        void this.pollMailbox();
+      }, this.cfg.pollIntervalMs);
+      this.pollTimer.unref?.();
+    }
+  }
+  /** Tear down watchers without touching host intent. Cooldowns survive. */
+  detach() {
+    for (const unsub of this.unsubscribers.splice(0)) unsub();
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = void 0;
+    }
+    this.running = false;
+  }
+  // ── signal handlers ──────────────────────────────────────────────────────
+  trackToolExecuted(e) {
+    const tool = e.name.toLowerCase();
+    const path42 = extractedPath(e.input);
+    if (e.ok && this.cfg.signals.editUnreadFile && this.cfg.fileEditTools.has(tool) && path42) {
+      if (!this.readSet.has(path42)) {
+        this.engage({
+          id: randomUUID6(),
+          probe: `Map file ${path42}: role, exports, dependencies, and callers \u2014 the leader is about to edit it.`,
+          hint: { file: path42 },
+          context: `Leader edited ${path42} without reading it first.`,
+          source: "edit_unread_file",
+          subject: `file:${path42}`,
+          createdAt: this.now()
+        });
+      }
+      return;
+    }
+    if (e.ok && this.cfg.signals.unfamiliarRead && tool === "read" && path42) {
+      if (!this.readSet.has(path42)) {
+        this.readSet.add(path42);
+        this.engage({
+          id: randomUUID6(),
+          probe: `Skeleton + callers + dependents of ${path42}: what it exports, who imports it, and how it fits the feature flow.`,
+          hint: { file: path42 },
+          context: `Leader read unfamiliar file ${path42}.`,
+          source: "unfamiliar_read",
+          subject: `file:${path42}`,
+          createdAt: this.now()
+        });
+      }
+      return;
+    }
+    if (e.ok && this.cfg.signals.searchZeroHits && this.cfg.searchTools.has(tool) && looksEmpty(e)) {
+      const input = e.input ?? {};
+      const query = typeof input["query"] === "string" ? input["query"] : typeof input["pattern"] === "string" ? input["pattern"] : "";
+      this.engage({
+        id: randomUUID6(),
+        probe: query ? `Locate "${query}" \u2014 the leader's ${e.name} returned no hits. Try synonyms, a refreshed index, and lexical fallbacks.` : `The leader's ${e.name} returned no results. Find where the concept actually lives.`,
+        hint: query ? { symbol: query } : void 0,
+        context: `${e.name} for "${query}" returned zero results.`,
+        source: "search_zero_hits",
+        subject: `search:${query}`,
+        createdAt: this.now()
+      });
+    }
+  }
+  trackAgentTodos(agents) {
+    const leaderId = this.resolveLeaderAgentId();
+    if (!leaderId) return;
+    const leader = agents.find((a) => a.id === leaderId);
+    if (!leader?.todos) return;
+    for (const todo of leader.todos) {
+      const prev = this.todoSeen.get(todo.id);
+      if (prev !== "in_progress" && todo.status === "in_progress") {
+        const mentions = extractSubjectTokens(todo.content);
+        const first = mentions[0];
+        this.engage({
+          id: randomUUID6(),
+          probe: `Pre-map the files/symbols behind this in-progress todo: "${todo.content.slice(0, 160)}".`,
+          hint: first ? { [first.kind]: first.value } : void 0,
+          context: `Todo "${todo.content.slice(0, 120)}" flipped to in_progress.`,
+          source: "todo_in_progress",
+          subject: `todo:${todo.id}`,
+          createdAt: this.now()
+        });
+      }
+      this.todoSeen.set(todo.id, todo.status);
+    }
+  }
+  trackError(err) {
+    const tokens = extractSubjectTokens(err.message);
+    for (const token of tokens.slice(0, 2)) {
+      this.engage({
+        id: randomUUID6(),
+        probe: `What is ${token.value}, where does it live, and who uses it? The leader hit an error naming it.`,
+        hint: { [token.kind]: token.value },
+        context: `Error: ${err.message.slice(0, 300)}`,
+        source: "error_symbol",
+        subject: `token:${token.value}`,
+        createdAt: this.now()
+      });
+    }
+  }
+  async pollMailbox() {
+    if (!this.cfg.enabled || !this.cfg.signals.mailboxAsk) return;
+    try {
+      const messages = await this.opts.mailbox.query({
+        unreadBy: this.cfg.companionAgentId,
+        limit: 20
+      });
+      const lsid = this.resolveLeaderSessionId();
+      for (const msg of messages) {
+        if (msg.type !== "ask" && msg.type !== "assign") continue;
+        const fromLeader = isMailboxLeader(msg.from) || lsid != null && msg.senderSessionId === lsid;
+        if (!fromLeader) continue;
+        this.engage({
+          id: randomUUID6(),
+          probe: msg.body.trim().slice(0, 2e3) || msg.subject,
+          context: `Direct ask from ${msg.from}: ${msg.subject}`,
+          source: "mailbox_ask",
+          subject: `mail:${msg.id}`,
+          createdAt: this.now()
+        });
+        await this.opts.mailbox.ack({
+          messageId: msg.id,
+          readerId: this.cfg.companionAgentId,
+          read: true,
+          completed: true
+        }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  // ── engagement ───────────────────────────────────────────────────────────
+  cooldownOk(subject) {
+    const last = this.probedAt.get(subject);
+    return last === void 0 || this.now() - last >= this.cfg.cooldownMs;
+  }
+  now() {
+    return this.opts.now ? this.opts.now() : Date.now();
+  }
+  engage(probe) {
+    if (!this.cfg.enabled) return;
+    if (!this.cooldownOk(probe.subject)) return;
+    this.probedAt.set(probe.subject, this.now());
+    if (this.pending.length >= this.cfg.maxPending) {
+      this.pending.shift();
+    }
+    this.pending.push(probe);
+    void this.drain();
+  }
+  async drain() {
+    if (this.inFlight) return;
+    const probe = this.pending.shift();
+    if (!probe) return;
+    this.inFlight = true;
+    try {
+      await this.opts.onProbe(probe);
+    } catch {
+    } finally {
+      this.inFlight = false;
+      if (this.pending.length > 0) void this.drain();
+    }
+  }
+};
+
+// src/coordination/dep-watcher.ts
+var DEPENDENCY_FILE_PATTERNS = [
+  "package.json",
+  "tsconfig.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "package-lock.json",
+  "go.mod",
+  "go.sum",
+  "Cargo.toml",
+  "Cargo.lock",
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
+  "Pipfile",
+  "Pipfile.lock",
+  "Gemfile",
+  "Gemfile.lock",
+  "composer.json",
+  "composer.lock",
+  "mix.exs",
+  "mix.lock",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts",
+  "*.csproj",
+  "packages.config",
+  "pubspec.yaml",
+  "pubspec.lock",
+  "CMakeLists.txt",
+  "conanfile.txt",
+  "conanfile.py",
+  "vcpkg.json"
+];
+function makeDependencyWatcherConfig(opts) {
+  const {
+    projectRoot,
+    mailbox,
+    targetAgent = "*",
+    watcherAgentId = "dep-watcher",
+    debounceMs = 3e3,
+    patterns = DEPENDENCY_FILE_PATTERNS
+  } = opts;
+  const watchPaths = [];
+  for (const p of patterns) {
+    if (p.includes("*")) {
+      continue;
+    }
+    watchPaths.push(`${projectRoot}/${p}`);
+  }
+  watchPaths.push(projectRoot);
+  const unique = [...new Set(watchPaths)];
+  const isMultiRecipient = targetAgent === "*" || targetAgent.startsWith("@session:");
+  const globPatterns = patterns.filter((p) => p.includes("*"));
+  const plainPatterns = patterns.filter((p) => !p.includes("*"));
+  function matchesPattern(filePath) {
+    const basename6 = filePath.split("/").pop()?.split("\\").pop() ?? "";
+    if (plainPatterns.includes(basename6)) return true;
+    for (const gp of globPatterns) {
+      const regex = new RegExp(
+        "^" + gp.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
+      );
+      if (regex.test(basename6)) return true;
+    }
+    return false;
+  }
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    watchPaths: unique,
+    debounceMs,
+    dispose() {
+      for (const t of pending.values()) clearTimeout(t);
+      pending.clear();
+    },
+    async onChange(entry) {
+      if (entry.event === "delete") return;
+      if (!matchesPattern(entry.path)) return;
+      const key = entry.path;
+      const existing = pending.get(key);
+      if (existing) clearTimeout(existing);
       pending.set(
         key,
         setTimeout(async () => {
@@ -11323,7 +12068,7 @@ function attachDepWatcherBridge(opts) {
 }
 
 // src/coordination/director.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 import * as fsp25 from "node:fs/promises";
 
 // src/core/instruction-template.ts
@@ -12128,7 +12873,7 @@ var FleetContextOverflowError = class extends Error {
 };
 
 // src/coordination/director/director-task-registry.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 var DirectorTaskRegistry = class _DirectorTaskRegistry {
   constructor(deps) {
     this.deps = deps;
@@ -12163,7 +12908,7 @@ var DirectorTaskRegistry = class _DirectorTaskRegistry {
     return { internal, consumedInBand: waiter !== void 0 || anyConsumed };
   }
   async assign(task) {
-    const taskWithId = task.id ? task : { ...task, id: randomUUID6() };
+    const taskWithId = task.id ? task : { ...task, id: randomUUID7() };
     if (this.deps.isWorkComplete()) {
       const stopped = this.makeStoppedResult(
         taskWithId.id,
@@ -12183,7 +12928,7 @@ var DirectorTaskRegistry = class _DirectorTaskRegistry {
     return taskWithId.id;
   }
   async assignInternal(task) {
-    const taskWithId = task.id ? task : { ...task, id: randomUUID6() };
+    const taskWithId = task.id ? task : { ...task, id: randomUUID7() };
     this.internalTaskIds.add(taskWithId.id);
     try {
       await this.deps.coordinator.assign(taskWithId);
@@ -12398,7 +13143,7 @@ ${JSON.stringify(result.result, null, 2)}
 };
 
 // src/coordination/director-tools.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 import {
   completeKanbanDispatch,
   failKanbanDispatch,
@@ -12411,7 +13156,7 @@ import {
 } from "@wrongstack/kanban";
 
 // src/coordination/director-input-helpers.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 function stringArray2(value) {
   if (!Array.isArray(value)) return void 0;
   const strings = value.filter((v) => typeof v === "string" && v.trim().length > 0);
@@ -12425,7 +13170,7 @@ function normalizeWorktreeOverride(value) {
 function instantiateRosterConfig2(role, base) {
   return {
     ...base,
-    id: `${role}-${randomUUID7().slice(0, 8)}`
+    id: `${role}-${randomUUID8().slice(0, 8)}`
   };
 }
 
@@ -12492,7 +13237,7 @@ function buildKanbanFleetTaskPrompt(board, task, lease) {
   const dependencyLines = (task.dependsOn ?? []).map((depId) => board.tasks.find((candidate) => candidate.id === depId)).filter((dep) => Boolean(dep)).map((dep) => `- ${dep.title} [${dep.status}] (${dep.id})`);
   const checks = task.successCriteria?.map((check) => `- ${check.description}`).join("\n");
   const metrics = task.goalMetrics?.map(
-    (metric) => `- ${metric.name}: ${metric.current ?? "n/a"}${metric.target !== void 0 ? ` / ${metric.target}` : ""}${metric.unit ? ` ${metric.unit}` : ""} [${metric.status}]`
+    (metric) => `- ${metric.name}: ${metric.current ?? "n/a"}${metric.target !== void 0 ? ` / ${metric.direction === "at_most" ? "\u2264" : "\u2265"} ${metric.target}` : ""}${metric.unit ? ` ${metric.unit}` : ""} [${metric.status}]`
   ).join("\n");
   const chain = task.chain ? [
     `chainId: ${task.chain.chainId}`,
@@ -12766,7 +13511,7 @@ function makeLLMClassifier(complete2) {
 }
 
 // src/coordination/director-basic-tools.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function makeAssignTool(director) {
   const inputSchema = {
     type: "object",
@@ -12805,7 +13550,7 @@ function makeAssignTool(director) {
         };
       }
       const task = {
-        id: randomUUID8(),
+        id: randomUUID9(),
         description: composeBoundedTaskDescription(i.description, boundary.boundary),
         subagentId: i.subagentId,
         maxToolCalls: i.maxToolCalls,
@@ -13225,7 +13970,7 @@ function makeWorkCompleteTool(director) {
 }
 
 // src/coordination/director-quality-gate-tool.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 function makeQualityGateTool(director, roster) {
   return {
     name: "quality_gate",
@@ -13322,7 +14067,7 @@ function makeQualityGateTool(director, roster) {
             makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
           );
           const taskId = await director.assign({
-            id: randomUUID9(),
+            id: randomUUID10(),
             subagentId,
             description: buildVerifierTask(i, {
               attempt,
@@ -13340,7 +14085,7 @@ function makeQualityGateTool(director, roster) {
             makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
           );
           const taskId = await director.assign({
-            id: randomUUID9(),
+            id: randomUUID10(),
             subagentId,
             description: buildReviewerTask(i, {
               attempt,
@@ -13368,7 +14113,7 @@ function makeQualityGateTool(director, roster) {
           };
         }
         const repairTaskId = await director.assign({
-          id: randomUUID9(),
+          id: randomUUID10(),
           subagentId: i.repairSubagentId,
           description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
           timeoutMs: i.timeoutMs
@@ -13598,6 +14343,413 @@ function excerpt(text, max) {
 ...(truncated)`;
 }
 
+// src/coordination/director-mutation-test-tool.ts
+import { randomUUID as randomUUID11 } from "node:crypto";
+import { readFileSync as readFileSync13 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join16 } from "node:path";
+
+// src/coordination/mutation-engine.ts
+var TOKEN_PATTERNS = [
+  {
+    kind: "relax-boundary",
+    // `>` not followed by `=` and not part of `=>` or `>>`; require code-ish
+    // context on both sides so generic text (JSX, strings) is not touched.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>>(?!=|>))/g,
+    replace: () => ">="
+  },
+  {
+    kind: "tighten-boundary",
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>>=)/g,
+    replace: () => ">"
+  },
+  {
+    kind: "arith-plus-to-minus",
+    // `+` between operands (binary), not `++`, unary `+x`, or `+=`.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>\+(?!\+|=))/g,
+    replace: () => "-"
+  },
+  {
+    kind: "arith-minus-to-plus",
+    // Binary `-` between operands, not `--`, `-=` or negative-number literal.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>-(?!-|=))/g,
+    replace: () => "+"
+  },
+  {
+    kind: "negate-boolean",
+    // Standalone boolean literals used as values, not property names.
+    regex: /(?<![.\w$])(?<op>true|false)(?![\w$])/g,
+    replace: (m) => m === "true" ? "false" : "true"
+  },
+  {
+    kind: "return-null",
+    // `return <expr>;` where expr is not already null/undefined/void.
+    regex: /(?<indent>\breturn\b)(?<expr>\s+[^;{}\n]+?)\s*;/g,
+    replace: () => "return null;"
+  }
+];
+function planMutations(file, source, opts = {}) {
+  const maxPerFile = opts.maxPerFile ?? 25;
+  const out = [];
+  const lines = source.split("\n");
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const line = lines[lineIdx];
+    const t = line.trim();
+    if (t.startsWith("//") || t.startsWith("*") || t.startsWith("/*")) continue;
+    for (const pattern of TOKEN_PATTERNS) {
+      pattern.regex.lastIndex = 0;
+      let m;
+      while ((m = pattern.regex.exec(line)) !== null) {
+        const token = m.groups?.["op"] ?? m[0];
+        const tokenStart = m.index + m[0].indexOf(token);
+        if (isMasked(line, tokenStart, token.length)) continue;
+        const original = line.slice(tokenStart, tokenStart + token.length);
+        const replacement = pattern.replace(token);
+        if (replacement === original) continue;
+        out.push({
+          id: `${pattern.kind}#${lineIdx + 1}#${tokenStart + 1}`,
+          kind: pattern.kind,
+          file,
+          line: lineIdx + 1,
+          column: tokenStart + 1,
+          original,
+          replacement
+        });
+      }
+    }
+    if (out.length >= maxPerFile) break;
+  }
+  return out.slice(0, maxPerFile);
+}
+function isMasked(line, start, len) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < start; i++) {
+    const c = line[i];
+    const prev = i > 0 ? line[i - 1] : void 0;
+    if (c === "'" && prev !== "\\") inSingle = !inSingle;
+    else if (c === '"' && prev !== "\\") inDouble = !inDouble;
+    if (!inSingle && !inDouble && c === "/" && prev === "/") return true;
+  }
+  if (inSingle || inDouble) return true;
+  const window = line.slice(start, start + len);
+  return /['"]/.test(window);
+}
+function parseMutationReport(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 {
+    }
+  }
+  return void 0;
+}
+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;
+    }
+    if (c === '"') inString = !inString;
+    if (inString) continue;
+    if (c === "{") depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return text.slice(start);
+}
+function normalizeMutantEntry(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const rec = value;
+  const id = typeof rec["id"] === "string" ? rec["id"] : void 0;
+  const status = rec["status"];
+  if (!id || status !== "killed" && status !== "survived" && status !== "skipped") {
+    return void 0;
+  }
+  return {
+    id,
+    file: typeof rec["file"] === "string" ? rec["file"] : "",
+    line: typeof rec["line"] === "number" ? rec["line"] : 0,
+    kind: typeof rec["kind"] === "string" ? rec["kind"] : "",
+    status,
+    evidence: typeof rec["evidence"] === "string" ? rec["evidence"] : void 0
+  };
+}
+
+// src/coordination/director-mutation-test-tool.ts
+var DEFAULT_MAX_PER_FILE = 10;
+var DEFAULT_MAX_STRENGTHEN_ATTEMPTS = 2;
+var CHAOS_ROLE = "chaos-monkey";
+function makeMutationTestTool(director, roster, opts = {}) {
+  return {
+    name: "mutation_test",
+    description: "Chaos Monkey mutation testing: deterministically sabotage boundary conditions in the target code (> to >=, + to -, boolean flips, return null), re-run the tests per mutant, and report which mutants were killed. Surviving mutants mean the tests are weak \u2014 optionally loop a strengthen-tests repair until they die.",
+    usageHint: "Use after writing new code AND its tests, before delivering. Pass targets (files) and testCommand. Provide repairSubagentId to auto-strengthen weak tests. Survivors that persist are reported as suspected-equivalent.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema: {
+      type: "object",
+      properties: {
+        targets: {
+          type: "array",
+          items: { type: "string" },
+          description: "Project-relative (or absolute) source files to mutate. Keep to files changed by the current task."
+        },
+        testCommand: {
+          type: "string",
+          description: 'Exact command that runs the relevant tests, e.g. "pnpm exec vitest run packages/core/tests/coordination/mutation-engine.test.ts".'
+        },
+        cwd: { type: "string", description: "Working directory for the test command." },
+        maxPerFile: {
+          type: "number",
+          minimum: 1,
+          maximum: 25,
+          description: "Mutant cap per file per pass. Default 10."
+        },
+        maxStrengthenAttempts: {
+          type: "number",
+          minimum: 0,
+          maximum: 5,
+          description: "Strengthen\u2192re-verify rounds. Default 2 when repairSubagentId is set, else 0."
+        },
+        repairSubagentId: {
+          type: "string",
+          description: "Subagent that owns the tests. When set and mutants survive, it receives a strengthen-tests task and the survivors are re-verified."
+        },
+        chaosWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Worktree override for the chaos agent. Use 'off' when targets are uncommitted \u2014 a worktree from HEAD would not contain them."
+        },
+        timeoutMs: { type: "number", minimum: 1, description: "Per-task timeout for chaos/strengthen/rerun tasks." },
+        reportOnly: {
+          type: "boolean",
+          description: "Skip the strengthen loop even when survivors exist. Default false."
+        }
+      },
+      required: ["targets", "testCommand"],
+      additionalProperties: false
+    },
+    async execute(input, ctx) {
+      const i = normalizeMutationTestInput(input);
+      const root = opts.projectRoot ?? ctx.projectRoot;
+      const plan = buildPlan(i, root);
+      if (plan.length === 0) {
+        return {
+          verdict: "inconclusive",
+          passed: false,
+          error: "No mutable sites found in the given targets (after comment/string filtering)."
+        };
+      }
+      const chaosSubagentId = await director.spawn(
+        makeChaosConfig(roster, i.chaosWorktree ?? "off")
+      );
+      const chaosTaskId = await director.assign({
+        id: randomUUID11(),
+        subagentId: chaosSubagentId,
+        description: buildChaosTask(plan, i, 1, []),
+        timeoutMs: i.timeoutMs
+      });
+      const [chaosResult] = await director.awaitTasks([chaosTaskId]);
+      const pass1 = collectOutcomes(chaosResult, plan);
+      const survivors = pass1.filter((m) => m.status === "survived");
+      const maxAttempts = clamp(
+        i.maxStrengthenAttempts ?? (i.repairSubagentId && !i.reportOnly ? DEFAULT_MAX_STRENGTHEN_ATTEMPTS : 0),
+        0,
+        5
+      );
+      const attempts = [];
+      let current = survivors;
+      while (current.length > 0 && attempts.length < maxAttempts && i.repairSubagentId) {
+        const attemptNo = attempts.length + 1;
+        const strengthenTaskId = await director.assign({
+          id: randomUUID11(),
+          subagentId: i.repairSubagentId,
+          description: buildStrengthenTask(current, i, attemptNo),
+          timeoutMs: i.timeoutMs
+        });
+        const [strengthenResult] = await director.awaitTasks([strengthenTaskId]);
+        if (strengthenResult?.status !== "success") {
+          attempts.push({
+            attempt: attemptNo,
+            survivorsBefore: current,
+            strengthenResult: strengthenResult ? { taskId: strengthenResult.taskId, status: strengthenResult.status } : void 0,
+            survivorsAfter: current,
+            suspectedEquivalent: []
+          });
+          break;
+        }
+        const survivorPlan = plan.filter((p) => current.some((s) => s.id === p.id));
+        const rerunSubagentId = await director.spawn(
+          makeChaosConfig(roster, i.chaosWorktree ?? "off")
+        );
+        const rerunTaskId = await director.assign({
+          id: randomUUID11(),
+          subagentId: rerunSubagentId,
+          description: buildChaosTask(survivorPlan, i, attemptNo + 1, current),
+          timeoutMs: i.timeoutMs
+        });
+        const [rerunResult] = await director.awaitTasks([rerunTaskId]);
+        const passN = collectOutcomes(rerunResult, survivorPlan);
+        const stillSurviving = passN.filter((m) => m.status === "survived" || m.status === "skipped");
+        attempts.push({
+          attempt: attemptNo,
+          survivorsBefore: current,
+          strengthenResult: { taskId: strengthenResult.taskId, status: strengthenResult.status },
+          rerunResult: { taskId: rerunTaskId, status: rerunResult?.status ?? "unknown" },
+          survivorsAfter: stillSurviving,
+          suspectedEquivalent: stillSurviving.filter((m) => current.some((c) => c.id === m.id)).map((m) => m.id)
+        });
+        current = stillSurviving.filter((m) => m.status === "survived");
+        if (passN.every((m) => m.status === "skipped")) break;
+      }
+      const finalSurvivors = current;
+      const verifiedCount = pass1.filter((m) => m.status !== "skipped").length;
+      const skippedCount = pass1.filter((m) => m.status === "skipped").length;
+      const score = plan.length === 0 ? 0 : pass1.filter((m) => m.status === "killed").length / plan.length;
+      const verdict = verifiedCount === 0 ? "inconclusive" : finalSurvivors.length === 0 ? skippedCount > 0 ? "partial" : "pass" : score >= 0.8 ? "partial" : "fail";
+      return {
+        verdict,
+        passed: verdict === "pass",
+        mutationScore: Number.parseFloat(score.toFixed(3)),
+        planned: plan.length,
+        killed: pass1.filter((m) => m.status === "killed").length,
+        survived: pass1.filter((m) => m.status === "survived").length,
+        skipped: pass1.filter((m) => m.status === "skipped").length,
+        finalSurvivors: finalSurvivors.map((m) => ({ id: m.id, file: m.file, kind: m.kind })),
+        suspectedEquivalent: attempts.flatMap((a) => a.suspectedEquivalent),
+        strengthenAttempts: attempts.length,
+        attempts,
+        chaosTaskId,
+        nextAction: finalSurvivors.length === 0 ? "accept" : attempts.length >= maxAttempts && i.repairSubagentId ? "manual_review_survivors" : "strengthen_tests"
+      };
+    }
+  };
+}
+function normalizeMutationTestInput(input) {
+  const raw = input ?? {};
+  const targets = stringArray2(raw["targets"]) ?? [];
+  const testCommand = typeof raw["testCommand"] === "string" ? raw["testCommand"].trim() : "";
+  return {
+    targets: targets.filter(Boolean),
+    testCommand,
+    cwd: typeof raw["cwd"] === "string" && raw["cwd"].trim() ? raw["cwd"].trim() : void 0,
+    maxPerFile: typeof raw["maxPerFile"] === "number" ? raw["maxPerFile"] : void 0,
+    maxStrengthenAttempts: typeof raw["maxStrengthenAttempts"] === "number" ? raw["maxStrengthenAttempts"] : void 0,
+    repairSubagentId: typeof raw["repairSubagentId"] === "string" && raw["repairSubagentId"].trim() ? raw["repairSubagentId"].trim() : void 0,
+    chaosWorktree: raw["chaosWorktree"] ?? void 0,
+    timeoutMs: typeof raw["timeoutMs"] === "number" ? raw["timeoutMs"] : void 0,
+    reportOnly: raw["reportOnly"] === true
+  };
+}
+function clamp(n, lo, hi) {
+  return Math.min(hi, Math.max(lo, n));
+}
+function buildPlan(i, projectRoot) {
+  const plan = [];
+  for (const target of i.targets) {
+    const abs = isAbsolute3(target) ? target : join16(projectRoot ?? process.cwd(), target);
+    let source;
+    try {
+      source = readFileSync13(abs, "utf8");
+    } catch {
+      continue;
+    }
+    plan.push(...planMutations(target, source, { maxPerFile: i.maxPerFile ?? DEFAULT_MAX_PER_FILE }));
+  }
+  return plan;
+}
+function makeChaosConfig(roster, worktree) {
+  const base = roster?.[CHAOS_ROLE] ?? getAgentDefinition(CHAOS_ROLE)?.config ?? { name: "Chaos Monkey", role: CHAOS_ROLE };
+  return { ...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) or survived (suite green).",
+    "4. Restore the file byte-for-byte before the next mutant.",
+    "",
+    "Mutants:",
+    mutants,
+    prior,
+    "",
+    "Rules: one mutation at a time; never stack; if the anchored token no longer matches, mark skipped with the drift as evidence; do not fix or refactor anything; stay inside the plan.",
+    "Finish with submit_result, then repeat the same JSON as your final text."
+  ].join("\n");
+}
+function buildStrengthenTask(survivors, i, attempt) {
+  return [
+    `Strengthen the tests so these SURVIVING mutants die (attempt ${attempt}).`,
+    "",
+    "Each survivor below was a deliberate sabotage of production code that the current suite did NOT catch:",
+    ...survivors.map((s) => `- ${s.id} | ${s.file}:${s.line} | ${s.kind}${s.evidence ? ` | ${s.evidence}` : ""}`),
+    "",
+    `Test command that must fail under each mutant: ${i.testCommand}`,
+    "",
+    "For each survivor add or tighten exactly one assertion that pins the sabotaged boundary/behavior. Do not change production code. Do not weaken other tests. Run the suite green on clean code before finishing."
+  ].join("\n");
+}
+function collectOutcomes(result, plan) {
+  const fromText = parseTextOutcomes(result);
+  if (fromText.length > 0) {
+    const planned = new Set(plan.map((p) => p.id));
+    const matched = fromText.filter((m) => planned.has(m.id));
+    if (matched.length > 0) return matched;
+  }
+  return plan.map((p) => ({
+    id: p.id,
+    file: p.file,
+    line: p.line,
+    kind: p.kind,
+    status: "skipped",
+    evidence: result ? `chaos task ended ${result.status}` : "chaos task produced no result"
+  }));
+}
+function parseTextOutcomes(result) {
+  const 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-tools.ts
 function makeSpawnTool(director, roster) {
   const dispatchCatalog = () => {
@@ -13890,7 +15042,7 @@ function makeKanbanQueueTool(director, roster) {
         try {
           const config = buildKanbanSubagentConfig(claim.task, i, roster, instantiateRosterConfig2);
           subagentId = await director.spawn(config);
-          const dispatchTaskId = randomUUID10();
+          const dispatchTaskId = randomUUID12();
           const taskSpec = {
             id: dispatchTaskId,
             subagentId,
@@ -14166,6 +15318,7 @@ function buildDirectorToolset(director, roster) {
     makeAskResultTool(director),
     makeRollUpTool(director),
     makeQualityGateTool(director, roster),
+    makeMutationTestTool(director, roster),
     makeTerminateTool(director),
     makeTerminateAllTool(director),
     makeFleetTool(director),
@@ -14252,7 +15405,7 @@ import * as fsp24 from "node:fs/promises";
 import * as path32 from "node:path";
 
 // src/storage/session-store.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 import * as fsp23 from "node:fs/promises";
 import * as path31 from "node:path";
 
@@ -15976,7 +17129,7 @@ var FileSessionWriter = class _FileSessionWriter {
 
 // src/storage/session-checkpoint-cas.ts
 import { spawn as spawn3 } from "node:child_process";
-import { createHash as createHash3, randomUUID as randomUUID11 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID13 } from "node:crypto";
 import * as fsp10 from "node:fs/promises";
 import * as path23 from "node:path";
 
@@ -16234,7 +17387,7 @@ var SessionCheckpointCas = class {
     }
     const temp = path23.join(
       path23.dirname(target),
-      `.${path23.basename(target)}.${process.pid}.${randomUUID11()}.tmp`
+      `.${path23.basename(target)}.${process.pid}.${randomUUID13()}.tmp`
     );
     let handle;
     try {
@@ -18030,7 +19183,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   onAppend;
   onAppendBatch;
   catalogClient;
-  maintenanceHolderId = randomUUID12();
+  maintenanceHolderId = randomUUID14();
   _loadCache = /* @__PURE__ */ new Map();
   loadCache = new SessionLoadCache(this._loadCache);
   _indexCache = null;
@@ -20237,7 +21390,7 @@ function hashStr(s) {
 }
 
 // src/coordination/multi-agent-coordinator.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import { EventEmitter as EventEmitter2 } from "node:events";
 
 // src/coordination/coordinator/error-classifier.ts
@@ -20328,7 +21481,8 @@ async function executeSubagentWithTimeout({
   budget,
   preemptFraction = TIMEOUT_PREEMPT_FRACTION,
   abortSubagent,
-  currentSessionId
+  currentSessionId,
+  gracefulFinish
 }) {
   const initialTimeoutMs = budget.limits.timeoutMs;
   const idleLimitMs = budget.limits.idleTimeoutMs;
@@ -20359,9 +21513,17 @@ async function executeSubagentWithTimeout({
     const scheduleNext = () => {
       const wallLimit = budget.limits.timeoutMs ?? initialTimeoutMs;
       const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : wallLimit - (Date.now() - start);
-      const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
-      const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
-      armFor(Math.max(25, Math.min(wallRemaining, idleRemaining, preemptRemaining)));
+      const idleRemaining = idleLimitMs === void 0 || gracefulFinish !== void 0 && initialTimeoutMs !== void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
+      const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit || gracefulFinish !== void 0 ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
+      const next = Math.min(wallRemaining, idleRemaining, preemptRemaining);
+      if (!Number.isFinite(next)) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        return;
+      }
+      armFor(Math.max(25, next));
     };
     const negotiateTimeout = async (used, limit) => {
       const handler = budget.onThreshold;
@@ -20410,6 +21572,10 @@ async function executeSubagentWithTimeout({
       const wallExceeded = wallLimit !== void 0 && elapsed >= wallLimit;
       const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
       if (idleExceeded && !wallExceeded) {
+        if (gracefulFinish !== void 0 && initialTimeoutMs !== void 0) {
+          scheduleNext();
+          return;
+        }
         const sessionId = currentSessionId();
         budget._events?.emit("budget.threshold_reached", {
           ...sessionId ? { sessionId } : {},
@@ -20426,7 +21592,7 @@ async function executeSubagentWithTimeout({
         reject(new BudgetExceededError("idle_timeout", idleLimit ?? 0, budget.idleMs()));
         return;
       }
-      if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed >= wallLimit * preemptFraction) {
+      if (wallLimit !== void 0 && !wallExceeded && gracefulFinish === void 0 && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed >= wallLimit * preemptFraction) {
         const activityTs = Date.now() - budget.idleMs();
         if (activityTs <= lastGrantActivityTs) {
           preemptState = "locked" /* LOCKED */;
@@ -20460,6 +21626,22 @@ async function executeSubagentWithTimeout({
         return;
       }
       const limit = wallLimit ?? 0;
+      if (gracefulFinish !== void 0) {
+        if (!budget.graceGranted) {
+          const reason = `wall-clock budget of ${Math.round(limit / 1e3)}s reached`;
+          if (budget.notifyFinish(reason, { graceMs: gracefulFinish.graceMs })) {
+            scheduleNext();
+            return;
+          }
+          abortSubagent(ctx.subagentId);
+          reject(new BudgetExceededError("timeout", limit, elapsed));
+          return;
+        } else {
+          abortSubagent(ctx.subagentId);
+          reject(new BudgetExceededError("timeout", limit, elapsed));
+          return;
+        }
+      }
       if (!budget.onThreshold) {
         abortSubagent(ctx.subagentId);
         reject(new BudgetExceededError("timeout", limit, elapsed));
@@ -20607,7 +21789,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     return { ...subagent, name: display };
   }
   async spawn(subagent) {
-    const id = subagent.id || randomUUID13();
+    const id = subagent.id || randomUUID15();
     const cfg = this.withNickname(subagent, id);
     if (this.subagents.has(id)) {
       throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
@@ -20844,6 +22026,32 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   completeTask(result) {
     this.recordCompletion(result);
   }
+  /**
+   * Ask every RUNNING subagent that opted into `gracefulFinish` to finish its
+   * task in its own turn (see coordination/subagent-finish.ts). This is the
+   * leader-side entry point for "the leader agent has finished": it delivers
+   * an in-band notification between tool batches — never an interrupt, never
+   * an abort. Each notified subagent keeps its existing time budget and
+   * accelerates; the watchdog still bounds the maximum lifetime.
+   *
+   * Subagents without the policy opted in are deliberately untouched — their
+   * lifecycle remains the legacy watchdog contract.
+   *
+   * Returns the number of subagents actually notified.
+   */
+  requestFinish(reason) {
+    let notified = 0;
+    for (const subagent of this.subagents.values()) {
+      if (subagent.status !== "running") continue;
+      if (!resolveGracefulFinish(subagent.config)) continue;
+      const budget = subagent.activeBudget;
+      if (!budget) continue;
+      const usage = budget.usage();
+      if (usage.iterations === 0 && usage.toolCalls === 0) continue;
+      if (budget.notifyFinish(reason)) notified++;
+    }
+    return notified;
+  }
   // --- internal dispatching ---------------------------------------------
   tryDispatchNext() {
     while (this.canDispatch()) {
@@ -21017,7 +22225,14 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         idleTimeoutMs: rawIdleTimeoutMs ?? this.config.defaultBudget?.idleTimeoutMs ?? configWithRosterDefaults.idleTimeoutMs
       },
       "auto",
-      { sessionId: () => this.currentSessionId() }
+      {
+        sessionId: () => this.currentSessionId(),
+        subagentId,
+        // Graceful-finish runs own wall-clock enforcement to the watchdog so
+        // the notify-then-bound lifecycle cannot be raced by tool.progress
+        // heartbeats calling checkTimeout() (see subagent-budget.ts).
+        ...resolveGracefulFinish(subagent.config) ? { wallClockWatchdogOwned: true } : {}
+      }
     );
     subagent.activeBudget = budget;
     if (!this.runner) {
@@ -21050,7 +22265,8 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         task,
         runCtx,
         budget,
-        subagent.config.preemptFraction
+        subagent.config.preemptFraction,
+        resolveGracefulFinish(subagent.config)
       );
       result = {
         subagentId,
@@ -21080,13 +22296,14 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     this.recordCompletion(result);
   }
-  async executeWithTimeout(runner, task, ctx, budget, preemptFraction) {
+  async executeWithTimeout(runner, task, ctx, budget, preemptFraction, gracefulFinish) {
     return executeSubagentWithTimeout({
       runner,
       task,
       ctx,
       budget,
       preemptFraction,
+      gracefulFinish,
       abortSubagent: (subagentId) => this.subagents.get(subagentId)?.abortController.abort(),
       currentSessionId: () => this.currentSessionId()
     });
@@ -21492,7 +22709,7 @@ var Director = class _Director {
   sessionProvider;
   sessionModel;
   constructor(opts) {
-    this.id = opts.config.coordinatorId || randomUUID14();
+    this.id = opts.config.coordinatorId || randomUUID16();
     this.manifestPath = opts.manifestPath;
     this.roster = opts.roster;
     this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
@@ -21699,6 +22916,17 @@ var Director = class _Director {
   isWorkComplete() {
     return this.workCompleteFlag;
   }
+  /**
+   * Ask every running background subagent that opted into `gracefulFinish`
+   * to finish its task in its own turn. In-band notification between tool
+   * batches — no interrupt, no abort; each subagent keeps its time budget and
+   * accelerates. Session shutdown calls this before draining Chimera work so
+   * the post-session reviewer is nudged to complete rather than killed.
+   * Returns the number of subagents notified.
+   */
+  requestFinish(reason) {
+    return this.coordinator.requestFinish(reason);
+  }
   setLeaderBtwNote(note) {
     return this.btwNotes.add(note);
   }
@@ -21775,7 +23003,7 @@ var Director = class _Director {
       );
     }
     const msg = {
-      id: randomUUID14(),
+      id: randomUUID16(),
       type: "task",
       from: this.id,
       to: subagentId,
@@ -22029,7 +23257,7 @@ var Director = class _Director {
 };
 
 // src/coordination/fleet-manager.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 import * as fsp26 from "node:fs/promises";
 import * as path33 from "node:path";
 var FleetManager = class {
@@ -22095,7 +23323,7 @@ var FleetManager = class {
   maxContext;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
-    this.directorRunId = opts.directorRunId ?? randomUUID15();
+    this.directorRunId = opts.directorRunId ?? randomUUID17();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = resolveMaxSpawnDepth(opts.maxSpawnDepth);
     this.spawnDepth = opts.spawnDepth ?? 0;
@@ -23004,235 +24232,6 @@ var MailboxProjectServerConnection = class {
   }
 };
 
-// src/coordination/mailbox-type-properties.ts
-var MAILBOX_TYPE_PROPERTIES = {
-  note: {
-    category: "informational",
-    expectsReply: false,
-    requiresAction: false,
-    backgroundEligible: false,
-    outOfBand: false,
-    renderPriority: 20,
-    recipientObligation: "Read for context; no reply needed.",
-    senderGuidance: "General-purpose FYI. Use when no more specific type applies."
-  },
-  ask: {
-    category: "actionable",
-    expectsReply: true,
-    requiresAction: true,
-    backgroundEligible: true,
-    outOfBand: false,
-    renderPriority: 10,
-    recipientObligation: "Answer as soon as possible \u2014 the sender is waiting.",
-    senderGuidance: "Blocking question. Only use when you need an answer to proceed."
-  },
-  assign: {
-    category: "actionable",
-    expectsReply: false,
-    requiresAction: true,
-    backgroundEligible: true,
-    outOfBand: false,
-    renderPriority: 10,
-    recipientObligation: "Accept or decline; act on it when current operation allows.",
-    senderGuidance: 'Task delegation. Must be directed to a specific recipient (not "*").'
-  },
-  steer: {
-    category: "actionable",
-    expectsReply: false,
-    requiresAction: true,
-    backgroundEligible: true,
-    outOfBand: false,
-    renderPriority: 0,
-    // Always rendered first
-    recipientObligation: "Pause current approach, adjust per instruction, then resume.",
-    senderGuidance: "Mid-task direction change. The recipient is already working on something."
-  },
-  btw: {
-    category: "informational",
-    expectsReply: false,
-    requiresAction: false,
-    backgroundEligible: false,
-    outOfBand: false,
-    renderPriority: 30,
-    recipientObligation: "Absorb the information and stay on current task; no reply needed.",
-    senderGuidance: "Low-priority aside. Non-urgent info that can wait."
-  },
-  broadcast: {
-    category: "routing",
-    expectsReply: false,
-    requiresAction: false,
-    backgroundEligible: false,
-    outOfBand: false,
-    renderPriority: 20,
-    recipientObligation: 'Read if addressed to you (direct recipient, alias, or "*").',
-    senderGuidance: 'Multi-recipient envelope. Auto-selected when to is "*" or "@session".'
-  },
-  status: {
-    category: "informational",
-    expectsReply: false,
-    requiresAction: false,
-    backgroundEligible: false,
-    outOfBand: false,
-    renderPriority: 40,
-    recipientObligation: "Use to avoid redundant work; never act on as a task or question.",
-    senderGuidance: "Agent/system status update. Machine-generated, not for human-originated messages."
-  },
-  result: {
-    category: "informational",
-    expectsReply: false,
-    requiresAction: false,
-    backgroundEligible: true,
-    outOfBand: false,
-    renderPriority: 10,
-    recipientObligation: "Factor into next decision; treat as evidence, not a new task.",
-    senderGuidance: "Task completion notice. Share the outcome of finished work."
-  },
-  review: {
-    category: "actionable",
-    expectsReply: false,
-    requiresAction: true,
-    backgroundEligible: true,
-    outOfBand: false,
-    renderPriority: 10,
-    recipientObligation: "Inspect when convenient; no immediate reply required.",
-    senderGuidance: "Passive review request (code/doc/PR). No reply required."
-  },
-  control: {
-    category: "control_signal",
-    expectsReply: false,
-    requiresAction: false,
-    backgroundEligible: false,
-    outOfBand: true,
-    renderPriority: 999,
-    // Never rendered
-    recipientObligation: 'Handled by the agent loop, NOT folded into conversation. "interrupt" causes cooperative halt.',
-    senderGuidance: "RESERVED for runtime use. Agents must NOT send control messages."
-  }
-};
-
-// src/coordination/mailbox-auth-types.ts
-var MAILBOX_CAPABILITY_IMPLICATIONS = {
-  "mail.read.all": ["mail.read.self"],
-  "mail.events.all": ["mail.events.self"],
-  "mail.send.directive": ["mail.send.actionable", "mail.send.informational"],
-  "mail.send.actionable": ["mail.send.informational"],
-  // Leaf capabilities imply nothing further.
-  "mail.send.informational": [],
-  "mail.read.self": [],
-  "mail.ack.self": [],
-  "mail.events.self": [],
-  "mail.presence.register.self": [],
-  "mail.presence.heartbeat.self": [],
-  "mail.presence.deregister.self": [],
-  "mail.presence.read": [],
-  "mail.retention.purge": [],
-  "mail.retention.clear": [],
-  "mail.admin.receipts": []
-};
-function expandMailboxCapabilities(caps) {
-  const result = /* @__PURE__ */ new Set();
-  const queue = [...caps];
-  while (queue.length > 0) {
-    const cap = queue.pop();
-    if (result.has(cap)) continue;
-    result.add(cap);
-    const implied = MAILBOX_CAPABILITY_IMPLICATIONS[cap];
-    if (implied) queue.push(...implied);
-  }
-  return result;
-}
-function hasMailboxCapability(actor, cap) {
-  if (actor.capabilities.has(cap)) return true;
-  const expanded = expandMailboxCapabilities(actor.capabilities);
-  return expanded.has(cap);
-}
-
-// src/coordination/mailbox-predicates.ts
-function mailboxIdentityBase(agentId) {
-  return agentId.split(/[@#]/, 1)[0].trim().toLowerCase();
-}
-function isMailboxLeader(agentId, role) {
-  return mailboxIdentityBase(agentId) === "leader" || role?.trim().toLowerCase() === "leader";
-}
-function isMailboxSenderInFamily(senderId, family) {
-  const base = mailboxIdentityBase(senderId);
-  const normalizedFamily = family.trim().toLowerCase();
-  if (normalizedFamily.length === 0) return false;
-  return base === normalizedFamily || base.startsWith(`${normalizedFamily}-`);
-}
-function isMailboxMessageVisibleTo(message, agentId, role) {
-  return message.audience !== "leaders" || isMailboxLeader(agentId, role);
-}
-function validateSendType(type, to) {
-  if (type === "control") {
-    throw new TypeError('Type "control" is reserved for runtime use and cannot be set by agents');
-  }
-  const isMultiRecipient = to === "*" || to.startsWith("@session:");
-  if (type === "assign" && isMultiRecipient) {
-    throw new TypeError(
-      `Type "assign" requires a specific recipient \u2014 multi-recipient target "${to}" is ambiguous`
-    );
-  }
-  if (type === "steer" && isMultiRecipient) {
-    throw new TypeError(
-      `Type "steer" requires a specific recipient \u2014 multi-recipient target "${to}" is ambiguous`
-    );
-  }
-}
-var SESSION_RECIPIENT_PREFIX = "@session:";
-function sessionRecipient(sessionId) {
-  const normalizedSessionId = sessionId.trim();
-  if (!normalizedSessionId) {
-    throw new TypeError('sessionId is required for the "@session" recipient');
-  }
-  return `${SESSION_RECIPIENT_PREFIX}${normalizedSessionId}`;
-}
-function normalizeRecipient(to, sessionId) {
-  const trimmed = to.trim();
-  const normalized = trimmed.toLowerCase();
-  if (normalized === "all") return "*";
-  if (normalized === "@session") return sessionRecipient(sessionId ?? "");
-  return trimmed;
-}
-function isActionRequiredForActor(message, projection) {
-  if (projection.legacyGlobalCompletion) return false;
-  if (message.deletedAt !== void 0) return false;
-  if (projection.completedByMe) return false;
-  return MAILBOX_TYPE_PROPERTIES[message.type]?.requiresAction === true;
-}
-
-// src/coordination/mailbox-session-sync.ts
-function isAffectedBySessionAffinity(message) {
-  return message.sessionAffinity !== void 0;
-}
-async function acceptMailboxMessageForSession(message, currentSessionId, ctx) {
-  if (!isAffectedBySessionAffinity(message)) return true;
-  const affinity = message.sessionAffinity;
-  if (affinity === null || typeof affinity !== "object" || Array.isArray(affinity)) {
-    return false;
-  }
-  if (affinity.sessionId !== void 0 && typeof affinity.sessionId !== "string" || affinity.reportId !== void 0 && typeof affinity.reportId !== "string") {
-    return false;
-  }
-  if (!currentSessionId) {
-    return ctx?.allowUnscoped === true;
-  }
-  if (typeof affinity.sessionId === "string" && affinity.sessionId.length > 0) {
-    if (affinity.sessionId !== currentSessionId) return false;
-    return true;
-  }
-  if (affinity.reportId && ctx?.resolveChimeraReportSessionId) {
-    try {
-      const resolved = await ctx.resolveChimeraReportSessionId(affinity.reportId);
-      if (resolved === currentSessionId) return true;
-      if (resolved !== void 0) return false;
-    } catch {
-    }
-  }
-  if (ctx?.allowUnscoped === true) return true;
-  return false;
-}
-
 // src/coordination/mailbox-message-codec.ts
 function resolveSendType(type, to) {
   const normalizedTo = normalizeRecipient(to);
@@ -24129,7 +25128,7 @@ function makeFleetStatusTool(opts = {}) {
 }
 
 // src/coordination/fleet-supervisor.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 var COLLAB_ID_PREFIXES2 = ["bug-hunter-", "refactor-planner-", "critic-"];
 var DEFAULTS = {
   intervalMs: 2e4,
@@ -24407,7 +25406,7 @@ var FleetSupervisor = class {
    */
   async decide(question, context, options, risk) {
     const request = {
-      id: `fleetsup-${randomUUID16()}`,
+      id: `fleetsup-${randomUUID18()}`,
       sessionId: this.opts.sessionId?.(),
       source: "system",
       question,
@@ -24767,6 +25766,22 @@ var SEND_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
   // receiver trusts the sender-asserted `sessionId`; the boundary must
   // refuse the field entirely.
 ]);
+var SEND_FORBIDDEN_FIELDS = /* @__PURE__ */ new Set([
+  "from",
+  "sessionAffinity"
+]);
+function filterMailboxSendPayload(input) {
+  const payload = {};
+  const stripped = [];
+  for (const key of Object.keys(input)) {
+    if (SEND_ALLOWED_FIELDS.has(key) || SEND_FORBIDDEN_FIELDS.has(key)) {
+      payload[key] = input[key];
+    } else {
+      stripped.push(key);
+    }
+  }
+  return { payload, stripped };
+}
 var ACK_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
   "messageId",
   "read",
@@ -25004,7 +26019,9 @@ function makeMailSendTool(opts = {}) {
       required: ["to", "subject", "body"]
     },
     async execute(input, ctx) {
-      const i = input ?? {};
+      const { payload: i, stripped } = filterMailboxSendPayload(
+        input ?? {}
+      );
       const rawTo = i.to;
       const subject = i.subject;
       const body = i.body;
@@ -25027,15 +26044,13 @@ function makeMailSendTool(opts = {}) {
         recipientAliases: /* @__PURE__ */ new Set([codecIdentity.baseId]),
         sessionId: codecIdentity.sessionId
       };
+      let parsed;
       try {
-        parseMailboxSendInput(i, codecActor);
+        parsed = parseMailboxSendInput(i, codecActor);
       } catch (err) {
         return { ok: false, error: err instanceof Error ? err.message : String(err) };
       }
-      const audience = i.audience;
-      if (audience !== void 0 && audience !== "all" && audience !== "leaders") {
-        return { ok: false, error: '"audience" must be "all" or "leaders".' };
-      }
+      const audience = parsed.audience;
       const mb = resolveMailbox(ctx);
       const identity = await register(mb, ctx);
       const requestedTo = normalizeRecipient(rawTo, identity.sessionId);
@@ -25049,10 +26064,10 @@ function makeMailSendTool(opts = {}) {
         to: delivery.to,
         type: resolvedType,
         audience: delivery.audience,
-        subject,
-        body,
-        priority: i.priority ?? "normal",
-        replyTo: i.replyTo,
+        subject: parsed.subject,
+        body: parsed.body,
+        priority: parsed.priority,
+        replyTo: parsed.replyTo,
         senderSessionId: identity.sessionId
       });
       return {
@@ -25060,7 +26075,9 @@ function makeMailSendTool(opts = {}) {
         messageId: msg.id,
         from: identity.callerId,
         to: msg.to,
-        summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity.callerId}.`
+        // Surfacing what was stripped keeps the send auditable without
+        // re-introducing the clutter into the payload itself.
+        ...stripped.length > 0 ? { strippedFields: stripped, summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity.callerId}. Ignored ${stripped.length} unrecognized field(s): ${stripped.join(", ")}.` } : { summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity.callerId}.` }
       };
     }
   };
@@ -28582,7 +29599,7 @@ function createAgentMonitorService(opts) {
 }
 
 // src/coordination/autonomous-brain.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 var AutonomousBrain = class {
   graph;
   // Fleet bus for emitting decisions — null-safe, no-op if not provided
@@ -28688,7 +29705,7 @@ var AutonomousBrain = class {
       consequence: i === 0 ? `Spawn the most appropriate agent for: ${taskDescription.slice(0, 80)}` : `Spawn an alternative agent for the same task`
     }));
     return this.decideAuto({
-      id: randomUUID17(),
+      id: randomUUID19(),
       source,
       decisionType: "spawn",
       question: `Should we spawn a subagent for this task?`,
@@ -28731,7 +29748,7 @@ var AutonomousBrain = class {
       }
     ];
     return this.decideAuto({
-      id: randomUUID17(),
+      id: randomUUID19(),
       source,
       decisionType: "approve_change",
       question: `Should we approve the change "${change.title}"?`,
@@ -28790,7 +29807,7 @@ var AutonomousBrain = class {
       consequence: "Break the task into smaller sub-tasks"
     });
     return this.decideAuto({
-      id: randomUUID17(),
+      id: randomUUID19(),
       source,
       decisionType: "escalate_task",
       question: `Task failed: ${error.slice(0, 100)}. How should we proceed?`,
@@ -28924,10 +29941,10 @@ ${ctx.error}`);
 };
 
 // src/coordination/autonomous-coordinator.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 
 // src/coordination/knowledge-graph.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import * as fsp28 from "node:fs/promises";
 import * as path41 from "node:path";
 var DEFAULT_MAX_NODES = 2e3;
@@ -28975,7 +29992,7 @@ var KnowledgeGraph = class _KnowledgeGraph {
    * Returns the node with its assigned id.
    */
   async add(node) {
-    const full = { id: randomUUID18(), ...node };
+    const full = { id: randomUUID20(), ...node };
     this.nodes.set(full.id, full);
     this._trackSeq(full.id);
     this._addToIndex(full, this._indexKeys(full));
@@ -29104,8 +30121,8 @@ var KnowledgeGraph = class _KnowledgeGraph {
     if (this.subs.size >= MAX_SUBSCRIPTIONS) {
       throw new Error(`Knowledge graph subscription limit reached (${MAX_SUBSCRIPTIONS})`);
     }
-    const channel = randomUUID18();
-    const sub = { id: randomUUID18(), agentId, filter, channel };
+    const channel = randomUUID20();
+    const sub = { id: randomUUID20(), agentId, filter, channel };
     this.subs.set(channel, sub);
     this.pendingDeliveries.set(channel, []);
     return channel;
@@ -29586,7 +30603,7 @@ var TaskDAG = class {
 };
 
 // src/coordination/task-auctioneer.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 function isTerminalGoalStatus(status) {
   return status === "done" || status === "failed";
 }
@@ -29709,7 +30726,7 @@ var TaskAuctioneer = class {
     const score = dispatchResult.confidence * (dispatchResult.role === agent.agentRole ? 1.2 : 1);
     if (score < this.minConfidence) return false;
     const bid = {
-      id: randomUUID19(),
+      id: randomUUID21(),
       taskId,
       agentId: agent.agentId,
       agentName: agent.agentName,
@@ -30646,7 +31663,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
           break;
         }
         const decision = await this.brain.decideAuto({
-          id: randomUUID20(),
+          id: randomUUID22(),
           source: "system",
           decisionType: "prioritize_goals",
           question: `What should we work on next? Open goals: ${dispatchable.map((g) => g.title).join(", ")}`,
@@ -31361,7 +32378,13 @@ export {
   DEFAULT_DIRECTOR_PREAMBLE,
   DEFAULT_DISPATCH_ROLE,
   DEFAULT_EAGER_SKILL_LIMIT,
+  DEFAULT_EXPLORE_COMPANION_AGENT_ID,
+  DEFAULT_EXPLORE_EDIT_TOOLS,
+  DEFAULT_EXPLORE_SEARCH_TOOLS,
+  DEFAULT_MAILBOX_POLL_INTERVAL_MS,
   DEFAULT_MAX_FLEET_SPAWNS,
+  DEFAULT_MAX_PENDING_PROBES,
+  DEFAULT_PROBE_COOLDOWN_MS,
   DEFAULT_QUALITY_CHECKS,
   DEFAULT_SUBAGENT_BASELINE,
   DELIVERY_AGENTS,
@@ -31375,6 +32398,7 @@ export {
   Director,
   DirectorAlertLevel,
   EscalationRoutingBrainArbiter,
+  ExploreCompanion,
   FLEET_ROSTER,
   FLEET_ROSTER_BUDGETS,
   FLEET_ROSTER_WITHACP,
@@ -31453,6 +32477,7 @@ export {
   brainDecisionKey,
   buildConsolidationInstruction,
   buildDownAlert,
+  buildProbeTaskText,
   buildProjectContextualizedPrompt,
   buildRecoveryAlert,
   buildSkillDistillInstruction,
@@ -31534,6 +32559,7 @@ export {
   makeMailInboxTool,
   makeMailSendTool,
   makeMailboxTool,
+  makeMutationTestTool,
   makeQualityGateTool,
   makeRollUpTool,
   makeSpawnTool,