@wrongstack/core 0.308.7 → 0.309.1

package/dist/index.js

@@ -1171,7 +1171,7 @@ __export(review_report_store_exports, {
   REPORT_STORE_FILE: () => REPORT_STORE_FILE,
   resolveReportStorePath: () => resolveReportStorePath
 });
-import { randomUUID as randomUUID31 } from "node:crypto";
+import { randomUUID as randomUUID32 } from "node:crypto";
 import * as fsp35 from "node:fs/promises";
 import * as path76 from "node:path";
 function resolveReportStorePath(projectDir) {
@@ -1238,7 +1238,7 @@ var init_review_report_store = __esm({
             ...input.evidenceChecks !== void 0 ? { evidenceChecks: input.evidenceChecks } : {}
           };
           const createdEvent = {
-            id: randomUUID31(),
+            id: randomUUID32(),
             reportId: report.id,
             eventType: "created",
             fromLifecycle: null,
@@ -1261,7 +1261,7 @@ var init_review_report_store = __esm({
           const from = this._materialize(entry).lifecycle;
           validateReportTransition(from, to);
           const event = {
-            id: randomUUID31(),
+            id: randomUUID32(),
             reportId,
             eventType: reportEventTypeFor(to),
             fromLifecycle: from,
@@ -1304,7 +1304,7 @@ var init_review_report_store = __esm({
           if (!entry) throw new Error(`Review report not found: ${reportId}`);
           const materialized = this._materialize(entry);
           const event = {
-            id: randomUUID31(),
+            id: randomUUID32(),
             reportId,
             eventType: "note_added",
             fromLifecycle: materialized.lifecycle,
@@ -1527,7 +1527,7 @@ __export(review_finding_store_exports, {
   JsonlFindingStore: () => JsonlFindingStore,
   resolveFindingStorePath: () => resolveFindingStorePath
 });
-import { randomUUID as randomUUID41 } from "node:crypto";
+import { randomUUID as randomUUID42 } from "node:crypto";
 import * as fsp48 from "node:fs/promises";
 import * as path105 from "node:path";
 function resolveFindingStorePath(projectDir) {
@@ -1616,7 +1616,7 @@ var init_review_finding_store = __esm({
           validateTransition(from, to);
           validateResolution(to, opts?.outcome);
           const event = {
-            id: randomUUID41(),
+            id: randomUUID42(),
             findingId,
             eventType: to === "resolved" ? "resolved" : to === "ignored" ? "ignored" : this._eventTypeFor(to),
             fromStatus: from,
@@ -1800,7 +1800,7 @@ var init_review_finding_store = __esm({
       }
       _makeEvent(findingId, eventType, fromStatus, toStatus, context) {
         return {
-          id: randomUUID41(),
+          id: randomUUID42(),
           findingId,
           eventType,
           fromStatus,
@@ -2513,7 +2513,7 @@ function walk(node, vault, transform) {
   }
   return out;
 }
-var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key|token\b)/i;
+var SECRET_KEY_PATTERN = /(?:api[-_]?key|auth[-_]?token|authorization|proxy-authorization|cookie|bearer|secret|password|passwd|pwd|refresh[-_]?token|session[-_]?key|access[_-]?token|private[_-]?key|token\b)/i;
 var NON_SECRET_OVERRIDES = /* @__PURE__ */ new Set(["publickey", "public_key"]);
 function isSecretField(name) {
   const lc = name.toLowerCase();
@@ -2684,6 +2684,14 @@ function keyFileNeedsHardening(keyFile, opts) {
   }
   return false;
 }
+function mkdirSecretDirSync(dir) {
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (process.platform === "win32") return;
+  try {
+    fs2.chmodSync(dir, 448);
+  } catch {
+  }
+}
 function writeKeyFileAtomicSync(keyFile, content) {
   const tmp = `${keyFile}.${randomBytes(4).toString("hex")}.tmp`;
   const fd = fs2.openSync(tmp, "w", 384);
@@ -2831,7 +2839,7 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    fs2.mkdirSync(path3.dirname(this.keyFile), { recursive: true });
+    mkdirSecretDirSync(path3.dirname(this.keyFile));
     const passphrase = getVaultPassphrase();
     if (passphrase) {
       writeKeyFileAtomicSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase));
@@ -2915,7 +2923,7 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs2.mkdirSync(path3.dirname(this.keyFile), { recursive: true });
+    mkdirSecretDirSync(path3.dirname(this.keyFile));
     const key = randomBytes(KEY_BYTES);
     const passphrase = getVaultPassphrase();
     const initialBytes = passphrase ? wrapDataKey(key, 1, passphrase) : key;
@@ -4069,6 +4077,17 @@ var IN_PROJECT_DENIED_PATHS = [
     // See discover-mailbox-bridge.ts:findWorkspaceCliEntry.
     path: "features.mailboxBridge",
     reason: "Enables the mailbox bridge, whose CLI-entry resolution walks up from the project root \u2014 a repo-supplied packages/cli/dist/index.js would be spawned on WebUI boot."
+  },
+  {
+    // `plugins` is already denied above, so a repo cannot ADD a plugin. This
+    // closes the other half: a repo could previously ship
+    // `{"features":{"pluginsTrust":false}}` and switch off the integrity gate
+    // for plugins the user had ALREADY installed globally — disarming the
+    // trust-on-first-use pin that exists to catch a supply-chain update
+    // rewriting a plugin's entry file. Same operator-owned class as the
+    // switches above.
+    path: "features.pluginsTrust",
+    reason: "Disables the plugin trust-on-first-use integrity gate, re-trusting changed code in already-installed global plugins."
   }
 ];
 function deleteNestedPath(target, path131) {
@@ -14860,6 +14879,42 @@ function formatTaskList(tasks) {
   return lines.join("\n");
 }
 
+// src/utils/terminal-sanitize.ts
+var ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+var ANSI_OSC_RE = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+var ANSI_CONTROL_STRING_RE = /\x1b[P^_X][\s\S]*?\x1b\\/g;
+var ANSI_ESCAPE_RE = /\x1b[ -/]*[@-~]/g;
+var BIDI_AND_ZERO_WIDTH_RE = /[​-‏‪-‮⁦-⁩]/g;
+function sanitizeTerminalText(value, tabWidth = 2) {
+  const tab = " ".repeat(Math.max(1, Math.min(8, Math.floor(tabWidth))));
+  const withoutEscapes = value.replace(ANSI_OSC_RE, "").replace(ANSI_CONTROL_STRING_RE, "").replace(ANSI_RE, "").replace(ANSI_ESCAPE_RE, "").replace(BIDI_AND_ZERO_WIDTH_RE, "").replace(/\t/g, tab).replace(/\r/g, "");
+  let safe = "";
+  for (const char of withoutEscapes) {
+    const code = char.codePointAt(0) ?? 0;
+    if (char === "\n" || code >= 32 && code !== 127 && !(code >= 128 && code <= 159)) {
+      safe += char;
+    }
+  }
+  return safe;
+}
+function sanitizeTerminalPreview(value, opts = {}) {
+  const maxLines = opts.maxLines ?? 40;
+  const maxChars = opts.maxChars ?? 8e3;
+  const safe = sanitizeTerminalText(value, opts.tabWidth);
+  let truncated = false;
+  let clipped = safe;
+  if (clipped.length > maxChars) {
+    clipped = clipped.slice(0, maxChars);
+    truncated = true;
+  }
+  const lines = clipped.split("\n");
+  if (lines.length > maxLines) {
+    clipped = lines.slice(0, maxLines).join("\n");
+    truncated = true;
+  }
+  return { text: clipped, truncated };
+}
+
 // src/utils/tool-description-mode.ts
 var DEFAULT_TOOL_DESCRIPTION_MODE = "extend";
 var ORIGINAL_TOOL_DESCRIPTION = /* @__PURE__ */ Symbol.for("wrongstack.tool.originalDescription");
@@ -15763,9 +15818,21 @@ function renderCommandLine(command, args) {
   });
   return [command, ...rendered].join(" ");
 }
-function subjectForToolInput(toolName, input, subjectKey) {
+function renderSubjectFields(obj, fields) {
+  const parts = [];
+  for (const field of fields) {
+    const value = obj[field];
+    if (value === void 0 || value === null || value === "" || value === false) continue;
+    const str = String(value);
+    parts.push(`${field}=${/\s/.test(str) ? `"${str.replace(/"/g, '\\"')}"` : str}`);
+  }
+  return parts.join(" ");
+}
+function subjectForToolInput(toolName, input, subjectKey, subjectFields) {
   if (!input || typeof input !== "object") return void 0;
   const obj = input;
+  const extra = subjectFields && subjectFields.length > 0 ? renderSubjectFields(obj, subjectFields) : "";
+  const withExtra = (base) => extra ? `${base} ${extra}` : base;
   if (subjectKey) {
     const value = obj[subjectKey];
     if (Array.isArray(value)) {
@@ -15781,9 +15848,9 @@ function subjectForToolInput(toolName, input, subjectKey) {
       if (subjectKey === "command") {
         const rendered = renderCommandLine(value, obj["args"]);
         if (value === "commit" && obj["dry_run"] === true) {
-          return `${escapeGlobSubject(rendered)}:dry-run`;
+          return `${escapeGlobSubject(withExtra(rendered))}:dry-run`;
         }
-        return escapeGlobSubject(rendered);
+        return escapeGlobSubject(withExtra(rendered));
       }
       if (subjectKey === "directory" && obj["dry_run"] === true) {
         return `${escapeGlobSubject(value)}:dry-run`;
@@ -15813,7 +15880,7 @@ function subjectForToolInput(toolName, input, subjectKey) {
 }
 
 // src/utils/win32-cmd.ts
-var WIN32_CMD_META = /[&|<>"\r\n\0]/;
+var WIN32_CMD_META = /[&|<>"%\r\n\0]/;
 function buildWin32CmdShimInvocation(command, args = []) {
   assertSafeWin32CmdArgs([command, ...args]);
   const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
@@ -19762,9 +19829,68 @@ function resourceId3(kind, value) {
   return `${kind}_${createHash17("sha256").update(value).digest("hex").slice(0, 24)}`;
 }
 
+// src/core/btw.ts
+var META_KEY2 = "_btwNotes";
+var MAX_PENDING = 20;
+function readQueue(ctx) {
+  const raw = ctx.meta[META_KEY2];
+  return Array.isArray(raw) ? raw : [];
+}
+function setBtwNote(ctx, text2) {
+  const trimmed = text2.trim();
+  if (!trimmed) return readQueue(ctx).length;
+  const next = [...readQueue(ctx), trimmed].slice(-MAX_PENDING);
+  ctx.meta[META_KEY2] = next;
+  return next.length;
+}
+function pendingBtwCount(ctx) {
+  return readQueue(ctx).length;
+}
+function consumeBtwNotes(ctx) {
+  const notes = readQueue(ctx);
+  if (notes.length > 0) delete ctx.meta[META_KEY2];
+  return notes;
+}
+function buildBtwBlock(notes) {
+  const body = notes.map((n) => `- ${n}`).join("\n");
+  return [
+    "[BY THE WAY \u2014 the user added this while you were working. Fold it into",
+    "your current task; do not restart from scratch unless it contradicts the",
+    "goal:",
+    "",
+    body,
+    "]"
+  ].join("\n");
+}
+
 // src/coordination/agent-subagent-runner.ts
 init_errors();
 
+// src/coordination/subagent-finish.ts
+var SUBAGENT_FINISH_REQUESTED_EVENT = "subagent.finish_requested";
+var DEFAULT_SUBAGENT_FINISH_GRACE_MS = 12e4;
+function resolveGracefulFinish(config) {
+  const raw = config.gracefulFinish;
+  if (raw === void 0 || raw === false) return void 0;
+  if (raw === true) return { graceMs: DEFAULT_SUBAGENT_FINISH_GRACE_MS };
+  const graceMs = typeof raw.graceMs === "number" && Number.isFinite(raw.graceMs) && raw.graceMs > 0 ? Math.floor(raw.graceMs) : DEFAULT_SUBAGENT_FINISH_GRACE_MS;
+  return { graceMs };
+}
+function buildSubagentFinishNotice(input) {
+  const localTime = new Date(input.deadlineMs).toISOString();
+  const seconds = Math.max(1, Math.round(input.graceMs / 1e3));
+  const timeLeft = input.graceMs > 0 ? `You have roughly ${seconds} seconds (until ${localTime}) of legitimate working time left.` : `Your working-time window is already spent (deadline was ${localTime}) \u2014 finish now.`;
+  return [
+    "[SUBAGENT FINISH] The leader agent has finished its work.",
+    `Reason: ${input.reason}`,
+    timeLeft,
+    "Finish your task now, in this turn: complete the thought you are working on, stop",
+    "starting new tool calls unless one is strictly required to finish, and write your",
+    "final answer or report as your final output, then end your turn.",
+    "Do not restart the task and do not begin new work."
+  ].join("\n");
+}
+
 // src/coordination/subagent-budget.ts
 var TIMEOUT_PREEMPT_FRACTION = 0.85;
 var DECISION_TIMEOUT_MS = 6e4;
@@ -19822,6 +19948,82 @@ var SubagentBudget = class _SubagentBudget {
       this.limits.idleTimeoutMs = ext.idleTimeoutMs;
     }
   }
+  /**
+   * Graceful-finish state (see coordination/subagent-finish.ts).
+   * `_finishNotified` guards the single in-band emission; `_grace` records a
+   * granted working-time extension past the original wall-clock deadline.
+   * They are separate because the two callers want different semantics:
+   * the watchdog grants grace at the deadline crossing (notify + extend),
+   * while an explicit leader-finished request only notifies — a subagent
+   * well inside its budget keeps its full legitimate working time and simply
+   * accelerates.
+   */
+  _finishNotified = false;
+  _grace = null;
+  /** True once the in-band finish notification has been emitted. */
+  get finishNotified() {
+    return this._finishNotified;
+  }
+  /** True once a grace window has been granted past the original deadline. */
+  get graceGranted() {
+    return this._grace !== null;
+  }
+  /**
+   * Notify the subagent in-band to finish its task in its own turn:
+   * `subagent.finish_requested` is emitted on the wired EventBus and the
+   * agent loop folds the notice into the conversation between tool batches.
+   * Nothing aborts — this is a notification, never an interrupt.
+   *
+   * `opts.graceMs` additionally extends the wall-clock ceiling by that window
+   * (used by the watchdog at a deadline crossing, so the model gets working
+   * time instead of a kill). Omit it to notify without touching the budget —
+   * the subagent keeps its existing time budget and just accelerates.
+   *
+   * Returns `true` when this call did something (emitted the notification
+   * and/or granted grace); `false` when there was nothing to do (already
+   * notified, grace already granted, no EventBus wired, budget not started).
+   */
+  notifyFinish(reason, opts, now = Date.now) {
+    if (!this._events) return false;
+    if (this.startTime === null) return false;
+    const shouldEmit = !this._finishNotified;
+    const rawGrace = opts?.graceMs;
+    const shouldGrant = rawGrace !== void 0 && this._grace === null;
+    if (!shouldEmit && !shouldGrant) return false;
+    let grantedGraceMs = 0;
+    let graceDeadlineMs;
+    if (shouldGrant && rawGrace !== void 0) {
+      grantedGraceMs = Number.isFinite(rawGrace) && rawGrace > 0 ? Math.floor(rawGrace) : DEFAULT_SUBAGENT_FINISH_GRACE_MS;
+      graceDeadlineMs = now() + grantedGraceMs;
+      this._grace = { deadlineMs: graceDeadlineMs, graceMs: grantedGraceMs };
+      this.patchLimits({ timeoutMs: graceDeadlineMs - this.startTime });
+    }
+    if (shouldEmit) {
+      this._finishNotified = true;
+      const effectiveDeadlineMs = graceDeadlineMs ?? (this.limits.timeoutMs !== void 0 ? this.startTime + this.limits.timeoutMs : now() + DEFAULT_SUBAGENT_FINISH_GRACE_MS);
+      const effectiveGraceMs = Math.max(0, effectiveDeadlineMs - now());
+      const subagentId = this._subagentId;
+      this._events.emit(SUBAGENT_FINISH_REQUESTED_EVENT, {
+        // Omitted entirely when the budget was built without an id — an
+        // empty string is an address that matches nothing.
+        ...subagentId !== void 0 ? { subagentId } : {},
+        reason,
+        deadlineMs: effectiveDeadlineMs,
+        graceMs: effectiveGraceMs,
+        notice: buildSubagentFinishNotice({
+          reason,
+          deadlineMs: effectiveDeadlineMs,
+          graceMs: effectiveGraceMs
+        })
+      });
+    }
+    return true;
+  }
+  /** Epoch ms by which the subagent should have produced its final output,
+   *  once a grace window was granted. Undefined before that. */
+  get finishDeadlineMs() {
+    return this._grace?.deadlineMs;
+  }
   iterations = 0;
   toolCalls = 0;
   tokenInput = 0;
@@ -19837,6 +20039,10 @@ var SubagentBudget = class _SubagentBudget {
   lastActivityTime = null;
   _onThreshold;
   _sessionId;
+  /** Owning subagent id — used to address the graceful-finish event. */
+  _subagentId;
+  /** True when only the coordinator watchdog may enforce wall-clock limits. */
+  _wallClockWatchdogOwned;
   /**
    * Hard cap on how long `_negotiateExtension` waits for the coordinator to
    * respond before defaulting to 'stop'. Without this fallback an absent
@@ -19908,6 +20114,8 @@ var SubagentBudget = class _SubagentBudget {
   constructor(limits = {}, mode = "auto", options = {}) {
     this._mode = mode;
     this._sessionId = options.sessionId;
+    this._subagentId = options.subagentId;
+    this._wallClockWatchdogOwned = options.wallClockWatchdogOwned === true;
     this.limits = { ...limits };
   }
   currentSessionId() {
@@ -19986,7 +20194,7 @@ var SubagentBudget = class _SubagentBudget {
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
         exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
       }
-      const wallOwnedByWatchdog = this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
+      const wallOwnedByWatchdog = this._wallClockWatchdogOwned || this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
       if (this.limits.timeoutMs !== void 0 && elapsedMs2 > this.limits.timeoutMs && !wallOwnedByWatchdog) {
         exceeded.push({ kind: "timeout", used: elapsedMs2, limit: this.limits.timeoutMs });
       }
@@ -20185,7 +20393,7 @@ var SubagentBudget = class _SubagentBudget {
     if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed2 = Date.now() - this.startTime;
     const wallSkipped = this._onThreshold !== void 0 && this._watchdogActive !== void 0 && timeoutMs !== void 0 && this._watchdogActive === timeoutMs;
-    const wallTripped = wallSkipped ? false : timeoutMs !== void 0 && elapsed2 > timeoutMs;
+    const wallTripped = this._wallClockWatchdogOwned || wallSkipped ? false : timeoutMs !== void 0 && elapsed2 > timeoutMs;
     const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
     if (!wallTripped && !idleTripped) return;
     void this.checkLimits(elapsed2);
@@ -20666,6 +20874,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 });
@@ -27827,6 +28043,14 @@ var PATTERNS = [
     anchor: "sk-ant-"
   },
   { type: "openai_key", regex: /(?<![A-Za-z0-9])sk-(?:proj-)?[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g, anchor: "sk-" },
+  {
+    // `xai` is a first-class provider in this codebase, but its key shape was
+    // absent here — so the one credential format WrongStack itself hands users
+    // was the one the scrubber could not recognize (audit 2026-08-20).
+    type: "xai_key",
+    regex: /(?<![A-Za-z0-9])xai-[A-Za-z0-9]{20,}(?![A-Za-z0-9])/g,
+    anchor: "xai-"
+  },
   { type: "github_pat", regex: /(?<![A-Za-z0-9])ghp_[A-Za-z0-9]{36,}(?![A-Za-z0-9])/g, anchor: "ghp_" },
   { type: "github_pat_v2", regex: /(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{50,}(?![A-Za-z0-9])/g, anchor: "github_pat_" },
   { type: "aws_access_key", regex: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}(?![A-Za-z0-9])/g, anchor: "AKIA" },
@@ -27917,8 +28141,8 @@ var PATTERNS = [
     // replacement so the separator between adjacent secrets is preserved
     // rather than collapsed. Capture groups are therefore: 1=leading
     // delimiter, 2=key name, 3=value.
-    regex: /(^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?=\s|$)/g,
-    anchor: ["KEY", "TOKEN", "SECRET", "PASSWORD", "PWD"]
+    regex: /(^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD|PASSPHRASE))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?=\s|$)/g,
+    anchor: ["KEY", "TOKEN", "SECRET", "PASSWORD", "PWD", "PASSPHRASE"]
   },
   {
     type: "json_credential_key",
@@ -28035,6 +28259,27 @@ var JSON_CREDENTIAL_REGEX = PATTERNS.find((p) => p.type === "json_credential_key
 var COMBINED_REPLACEMENTS = SIMPLE_PATTERNS.map((p) => `[REDACTED:${p.type}]`);
 var SCRUB_CHUNK_BYTES = 64 * 1024;
 var SCRUB_OVERLAP_BYTES = 1024;
+var PEM_PRIVATE_KEY_BEGIN_RE = /-----BEGIN (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----/;
+var PEM_END_MARKER = "-----END";
+var MAX_PEM_BLOCK_BYTES = 64 * 1024;
+var PEM_END_LINE_TOLERANCE = 64;
+function extendChunkBoundaryPastPem(text2, chunkStart, proposedEnd) {
+  const head = text2.slice(chunkStart, proposedEnd);
+  const lastBegin = head.lastIndexOf("-----BEGIN ");
+  if (lastBegin === -1) return proposedEnd;
+  const fromBegin = text2.slice(chunkStart + lastBegin);
+  const marker = PEM_PRIVATE_KEY_BEGIN_RE.exec(fromBegin);
+  if (!marker || marker.index !== 0) return proposedEnd;
+  const bodyStart = marker[0].length;
+  const cap = Math.min(text2.length, chunkStart + lastBegin + MAX_PEM_BLOCK_BYTES);
+  const closeIdx = fromBegin.indexOf(PEM_END_MARKER, bodyStart);
+  if (closeIdx === -1 || chunkStart + lastBegin + closeIdx >= cap + PEM_END_LINE_TOLERANCE) {
+    return proposedEnd;
+  }
+  const lineEnd = fromBegin.indexOf("\n", closeIdx);
+  const end = lineEnd === -1 ? text2.length : chunkStart + lastBegin + lineEnd + 1;
+  return Math.max(proposedEnd, end);
+}
 var PATTERN_ANCHORS = [
   ...new Set(
     PATTERNS.flatMap(
@@ -28071,6 +28316,7 @@ var DefaultSecretScrubber = class {
           }
         }
         end = safe === -1 ? end : safe + 1;
+        end = extendChunkBoundaryPastPem(text2, i, end);
       }
       out.push(this.scrubOne(text2.slice(i, end)));
       i = end;
@@ -29007,7 +29253,7 @@ function attachDepWatcherBridge(opts) {
 }
 
 // src/coordination/director.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import * as fsp30 from "node:fs/promises";
 
 // src/storage/director-state.ts
@@ -30902,7 +31148,7 @@ ${JSON.stringify(result.result, null, 2)}
 };
 
 // src/coordination/director-tools.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import {
   completeKanbanDispatch,
   failKanbanDispatch,
@@ -32136,6 +32382,626 @@ function excerpt(text2, max) {
 ...(truncated)`;
 }
 
+// src/coordination/director-mutation-test-tool.ts
+import { randomUUID as randomUUID14 } from "node:crypto";
+import { readFileSync as readFileSync19 } from "node:fs";
+import { isAbsolute as isAbsolute9, join as join40 } from "node:path";
+
+// src/coordination/mutation-engine.ts
+var TOKEN_PATTERNS = [
+  {
+    kind: "relax-boundary",
+    // `>` not followed by `=` and not part of `=>` or `>>`; require code-ish
+    // context on both sides so generic text (JSX, strings) is not touched.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>>(?!=|>))/g,
+    replace: () => ">="
+  },
+  {
+    kind: "tighten-boundary",
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>>=)/g,
+    replace: () => ">"
+  },
+  {
+    kind: "arith-plus-to-minus",
+    // `+` between operands (binary), not `++`, unary `+x`, or `+=`.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>\+(?!\+|=))/g,
+    replace: () => "-"
+  },
+  {
+    kind: "arith-minus-to-plus",
+    // Binary `-` between operands, not `--`, `-=` or negative-number literal.
+    regex: /(?<=[\w\)\]\}'"`])\s*\x20?(?<op>-(?!-|=))/g,
+    replace: () => "+"
+  },
+  {
+    kind: "negate-boolean",
+    // Standalone boolean literals used as values, not property names.
+    regex: /(?<![.\w$])(?<op>true|false)(?![\w$])/g,
+    replace: (m) => m === "true" ? "false" : "true"
+  },
+  {
+    kind: "return-null",
+    // `return <expr>;` where expr is not already null/undefined/void.
+    regex: /(?<indent>\breturn\b)(?<expr>\s+[^;{}\n]+?)\s*;/g,
+    replace: () => "return null;",
+    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 t2 = line.trim();
+    if (t2.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++;
+        }
+        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;
+        }
+        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;
+      }
+      if (runStart === null) runStart = i;
+      i++;
+    }
+    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 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 parseMutationReport(text2) {
+  const candidates = [];
+  const fence = text2.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fence?.[1]) candidates.push(fence[1].trim());
+  const firstBrace = text2.indexOf("{");
+  if (firstBrace >= 0) candidates.push(extractBalancedObject(text2, firstBrace));
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try {
+      const parsed = JSON.parse(candidate);
+      if (!Array.isArray(parsed.mutants)) continue;
+      return {
+        mutants: parsed.mutants.map(normalizeMutantEntry).filter((x) => Boolean(x)),
+        summary: typeof parsed.summary === "string" ? parsed.summary : void 0
+      };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function extractBalancedObject(text2, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text2.length; i++) {
+    const c = text2[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (c === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (c === '"') inString = !inString;
+    if (inString) continue;
+    if (c === "{") depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) return text2.slice(start, i + 1);
+    }
+  }
+  return text2.slice(start);
+}
+function normalizeMutantEntry(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const rec = value;
+  const id = typeof rec["id"] === "string" ? rec["id"] : void 0;
+  const status = rec["status"];
+  if (!id || status !== "killed" && status !== "survived" && status !== "skipped" && 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
+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."
+        }
+      },
+      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) {
+        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)."
+        };
+      }
+      const chaosSubagentId = await director.spawn(
+        makeChaosConfig(chaosBase, i.chaosWorktree ?? chaosBase.worktree ?? "off")
+      );
+      const chaosTaskId = await director.assign({
+        id: randomUUID14(),
+        subagentId: chaosSubagentId,
+        description: buildChaosTask(plan, i, 1, []),
+        timeoutMs: i.timeoutMs
+      });
+      const [chaosResult] = await director.awaitTasks([chaosTaskId]);
+      const pass1 = collectOutcomes(chaosResult, plan);
+      const survivors = pass1.filter((m) => m.status === "survived");
+      const maxAttempts = clamp(
+        i.maxStrengthenAttempts ?? (i.repairSubagentId && !i.reportOnly ? DEFAULT_MAX_STRENGTHEN_ATTEMPTS : 0),
+        0,
+        5
+      );
+      const attempts = [];
+      let current = survivors;
+      let rerunUnknowns = [];
+      while (current.length > 0 && attempts.length < maxAttempts && i.repairSubagentId) {
+        const attemptNo = attempts.length + 1;
+        const strengthenTaskId = await director.assign({
+          id: randomUUID14(),
+          subagentId: i.repairSubagentId,
+          description: buildStrengthenTask(current, i, attemptNo),
+          timeoutMs: i.timeoutMs
+        });
+        const [strengthenResult] = await director.awaitTasks([strengthenTaskId]);
+        if (strengthenResult?.status !== "success") {
+          attempts.push({
+            attempt: attemptNo,
+            survivorsBefore: current,
+            strengthenResult: strengthenResult ? { taskId: strengthenResult.taskId, status: strengthenResult.status } : void 0,
+            survivorsAfter: current,
+            suspectedEquivalent: []
+          });
+          break;
+        }
+        const survivorPlan = plan.filter((p) => current.some((s) => s.id === p.id));
+        const rerunSubagentId = await director.spawn(
+          makeChaosConfig(chaosBase, i.chaosWorktree ?? chaosBase.worktree ?? "off")
+        );
+        const rerunTaskId = await director.assign({
+          id: randomUUID14(),
+          subagentId: rerunSubagentId,
+          description: buildChaosTask(survivorPlan, i, attemptNo + 1, current),
+          timeoutMs: i.timeoutMs
+        });
+        const [rerunResult] = await director.awaitTasks([rerunTaskId]);
+        const passN = collectOutcomes(rerunResult, survivorPlan);
+        const stillSurviving = passN.filter((m) => !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 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) {
+  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: normalizeWorktreeOverride(raw["chaosWorktree"]),
+    timeoutMs: typeof raw["timeoutMs"] === "number" ? raw["timeoutMs"] : void 0,
+    reportOnly: raw["reportOnly"] === true
+  };
+}
+function clamp(n, lo, hi) {
+  return Math.min(hi, Math.max(lo, n));
+}
+function buildPlan(i, projectRoot) {
+  const plan = [];
+  for (const target of i.targets) {
+    const abs = isAbsolute9(target) ? target : join40(projectRoot ?? process.cwd(), target);
+    let source;
+    try {
+      source = readFileSync19(abs, "utf8");
+    } catch {
+      continue;
+    }
+    plan.push(...planMutations(target, source, { maxPerFile: i.maxPerFile ?? DEFAULT_MAX_PER_FILE }));
+  }
+  return plan;
+}
+function makeChaosConfig(base, worktree) {
+  return { ...instantiateRosterConfig(CHAOS_ROLE, base), worktree };
+}
+function buildChaosTask(plan, i, pass, priorSurvivors) {
+  const mutants = plan.map(
+    (m) => `- ${m.id} | ${m.file}:${m.line}:${m.column} | ${m.kind} | "${m.original}" -> "${m.replacement}"`
+  ).join("\n");
+  const prior = priorSurvivors.length > 0 ? `
+These mutants survived a previous pass (pass ${pass - 1}) \u2014 re-verify them against the STRENGTHENED tests:
+${priorSurvivors.map((s) => `- ${s.id} (${s.kind} @ ${s.file}:${s.line})`).join("\n")}` : "";
+  return [
+    "Execute this deterministic mutation plan against the current checkout.",
+    "",
+    "For each mutant, in order:",
+    "1. Apply ONLY that mutation at its exact (file, line, column).",
+    `2. Run the test command: ${i.testCommand}${i.cwd ? ` (cwd: ${i.cwd})` : ""}`,
+    "3. Record killed (tests failed \u2014 quote first failing assertion), 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 (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 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 isKill(status) {
+  return status === "killed" || status === "killed-by-hang";
+}
+function parseTextOutcomes(result) {
+  const text2 = typeof result?.result === "string" ? result.result : void 0;
+  if (!text2) return [];
+  const parsed = parseMutationReport(text2);
+  if (!parsed) return [];
+  return parsed.mutants.map((m) => ({
+    id: m.id,
+    file: m.file,
+    line: m.line,
+    kind: m.kind,
+    status: m.status,
+    evidence: m.evidence
+  }));
+}
+
 // src/coordination/director-tools.ts
 function makeSpawnTool(director, roster) {
   const dispatchCatalog = () => {
@@ -32428,7 +33294,7 @@ function makeKanbanQueueTool(director, roster) {
         try {
           const config = buildKanbanSubagentConfig(claim.task, i, roster, instantiateRosterConfig);
           subagentId = await director.spawn(config);
-          const dispatchTaskId = randomUUID14();
+          const dispatchTaskId = randomUUID15();
           const taskSpec = {
             id: dispatchTaskId,
             subagentId,
@@ -32704,6 +33570,7 @@ function buildDirectorToolset(director, roster) {
     makeAskResultTool(director),
     makeRollUpTool(director),
     makeQualityGateTool(director, roster),
+    makeMutationTestTool(director, roster),
     makeTerminateTool(director),
     makeTerminateAllTool(director),
     makeFleetTool(director),
@@ -32790,7 +33657,7 @@ import * as fsp29 from "node:fs/promises";
 import * as path63 from "node:path";
 
 // src/storage/session-store.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 import * as fsp28 from "node:fs/promises";
 import * as path62 from "node:path";
 init_client();
@@ -33961,7 +34828,7 @@ var FileSessionWriter = class _FileSessionWriter {
 // src/storage/session-checkpoint-cas.ts
 init_atomic_write();
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash18, randomUUID as randomUUID15 } from "node:crypto";
+import { createHash as createHash18, randomUUID as randomUUID16 } from "node:crypto";
 import * as fsp15 from "node:fs/promises";
 import * as path54 from "node:path";
 init_error();
@@ -34199,7 +35066,7 @@ var SessionCheckpointCas = class {
     }
     const temp = path54.join(
       path54.dirname(target),
-      `.${path54.basename(target)}.${process.pid}.${randomUUID15()}.tmp`
+      `.${path54.basename(target)}.${process.pid}.${randomUUID16()}.tmp`
     );
     let handle;
     try {
@@ -36007,7 +36874,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   onAppend;
   onAppendBatch;
   catalogClient;
-  maintenanceHolderId = randomUUID16();
+  maintenanceHolderId = randomUUID17();
   _loadCache = /* @__PURE__ */ new Map();
   loadCache = new SessionLoadCache(this._loadCache);
   _indexCache = null;
@@ -36699,7 +37566,7 @@ async function readDirectorSubagentSession(args) {
 }
 
 // src/core/fallback-model.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 
 // src/types/provider.ts
 init_errors();
@@ -36709,6 +37576,18 @@ var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not eno
 var ROUTE_SCOPED_QUOTA_RE = /\b(?:for|on)\s+(?:(?:this|the)\s+)?(?:route|model)\b|\b(?:route|model)(?:[-_\s]+[\w.-]+)?[-_\s]*(?:quota|limit)\b|\b(?:quota|limit).{0,24}\b(?:for|on)\s+(?:(?:this|the)\s+)?(?:route|model)\b/i;
 
 // src/types/provider.ts
+var REASONING_EFFORT_LEVELS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function isReasoningEffort(value) {
+  return typeof value === "string" && REASONING_EFFORT_LEVELS.includes(value);
+}
 function effectiveInputTokens(usage) {
   return usage.input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
 }
@@ -37731,7 +38610,7 @@ function createFallbackModelExtension(deps) {
         let gateRequestId;
         const configuredGateSeconds = cfg.fallbackGateSeconds ?? deps.fallbackGateSeconds;
         if (configuredGateSeconds !== 0 && deps.fallbackGate && usableChain.length > 0) {
-          gateRequestId = randomUUID17();
+          gateRequestId = randomUUID18();
           const autoSwitchSeconds = Math.max(1, configuredGateSeconds ?? 7);
           const gateCandidates = usableChain.map((e) => ({
             providerId: e.providerId,
@@ -38703,7 +39582,7 @@ function hashStr(s) {
 }
 
 // src/coordination/multi-agent-coordinator.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 import { EventEmitter as EventEmitter2 } from "node:events";
 
 // src/coordination/coordinator/error-classifier.ts
@@ -38828,6 +39707,22 @@ var EXPLORE_COMPANION_AGENT = {
   textStream: "silent",
   toolStream: "silent"
 };
+var CHAOS_MONKEY_AGENT = {
+  ...defineAgent("chaos-monkey", "Chaos Monkey"),
+  tools: [...TOOLS.build],
+  skillNames: ["testing", "typescript-strict"],
+  spawnBudgetExempt: true,
+  // Run in the live checkout: mutation targets are usually freshly
+  // written and uncommitted — a worktree spawned from HEAD would not
+  // contain them and every mutant would drift. The mutation_test tool
+  // honors this value as its default; callers can still override per
+  // call via its `chaosWorktree` input when targets are committed and
+  // isolation is wanted.
+  worktree: "off",
+  // 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) {
@@ -38847,6 +39742,7 @@ var FLEET_ROSTER = {
   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)])
   )
@@ -38877,6 +39773,16 @@ var FLEET_ROSTER_BUDGETS = {
     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])
   )
@@ -38939,7 +39845,8 @@ async function executeSubagentWithTimeout({
   budget,
   preemptFraction = TIMEOUT_PREEMPT_FRACTION,
   abortSubagent,
-  currentSessionId
+  currentSessionId,
+  gracefulFinish
 }) {
   const initialTimeoutMs = budget.limits.timeoutMs;
   const idleLimitMs = budget.limits.idleTimeoutMs;
@@ -38970,9 +39877,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;
@@ -39021,6 +39936,10 @@ async function executeSubagentWithTimeout({
       const wallExceeded = wallLimit !== void 0 && elapsed2 >= wallLimit;
       const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
       if (idleExceeded && !wallExceeded) {
+        if (gracefulFinish !== void 0 && initialTimeoutMs !== void 0) {
+          scheduleNext();
+          return;
+        }
         const sessionId = currentSessionId();
         budget._events?.emit("budget.threshold_reached", {
           ...sessionId ? { sessionId } : {},
@@ -39037,7 +39956,7 @@ async function executeSubagentWithTimeout({
         reject(new BudgetExceededError("idle_timeout", idleLimit ?? 0, budget.idleMs()));
         return;
       }
-      if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed2 >= wallLimit * preemptFraction) {
+      if (wallLimit !== void 0 && !wallExceeded && gracefulFinish === void 0 && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed2 >= wallLimit * preemptFraction) {
         const activityTs = Date.now() - budget.idleMs();
         if (activityTs <= lastGrantActivityTs) {
           preemptState = "locked" /* LOCKED */;
@@ -39071,6 +39990,22 @@ async function executeSubagentWithTimeout({
         return;
       }
       const limit = wallLimit ?? 0;
+      if (gracefulFinish !== void 0) {
+        if (!budget.graceGranted) {
+          const reason = `wall-clock budget of ${Math.round(limit / 1e3)}s reached`;
+          if (budget.notifyFinish(reason, { graceMs: gracefulFinish.graceMs })) {
+            scheduleNext();
+            return;
+          }
+          abortSubagent(ctx.subagentId);
+          reject(new BudgetExceededError("timeout", limit, elapsed2));
+          return;
+        } else {
+          abortSubagent(ctx.subagentId);
+          reject(new BudgetExceededError("timeout", limit, elapsed2));
+          return;
+        }
+      }
       if (!budget.onThreshold) {
         abortSubagent(ctx.subagentId);
         reject(new BudgetExceededError("timeout", limit, elapsed2));
@@ -39218,7 +40153,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     return { ...subagent, name: display };
   }
   async spawn(subagent) {
-    const id = subagent.id || randomUUID18();
+    const id = subagent.id || randomUUID19();
     const cfg = this.withNickname(subagent, id);
     if (this.subagents.has(id)) {
       throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
@@ -39455,6 +40390,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()) {
@@ -39628,7 +40589,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) {
@@ -39661,7 +40629,8 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         task,
         runCtx,
         budget,
-        subagent.config.preemptFraction
+        subagent.config.preemptFraction,
+        resolveGracefulFinish(subagent.config)
       );
       result = {
         subagentId,
@@ -39691,13 +40660,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()
     });
@@ -40007,6 +40977,7 @@ function worktreeOwnerLabel(task, config) {
 }
 
 // src/coordination/director.ts
+var BUSY_REARM_FLOOR_MS = 1e3;
 var Director = class _Director {
   /* eslint-disable-next-line @typescript-eslint/no-unused-vars — just a cast helper */
   static _asManifestEntry(v) {
@@ -40072,6 +41043,13 @@ var Director = class _Director {
   subagentIdleTimeoutMs;
   retireSubagentOnTaskComplete;
   subagentIdleTimers = /* @__PURE__ */ new Map();
+  /**
+   * Effective idle window per subagent (spawn-time `idleTimeoutMs` override
+   * or the Director-wide default; undefined = no window). Internal-task
+   * completion re-arms with THIS value, not the Director-wide default, so
+   * a subagent-configured window survives its first internal probe.
+   */
+  subagentIdleDelayMs = /* @__PURE__ */ new Map();
   sharedScratchpadPath;
   maxSpawns;
   maxSpawnDepth;
@@ -40104,7 +41082,7 @@ var Director = class _Director {
   sessionProvider;
   sessionModel;
   constructor(opts) {
-    this.id = opts.config.coordinatorId || randomUUID19();
+    this.id = opts.config.coordinatorId || randomUUID20();
     this.manifestPath = opts.manifestPath;
     this.roster = opts.roster;
     this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
@@ -40228,7 +41206,13 @@ var Director = class _Director {
   handleTaskCompleted(payload) {
     const r = payload.result;
     const settled = this.tasks.settle(r);
-    if (settled.internal) return;
+    if (settled.internal) {
+      this.armSubagentIdleRetirement(
+        r.subagentId,
+        this.subagentIdleDelayMs.get(r.subagentId) ?? this.subagentIdleTimeoutMs
+      );
+      return;
+    }
     const title = this.tasks.descriptionFor(r.taskId, payload.task.description ?? r.taskId);
     if (!settled.consumedInBand && this.taskResultNotifier) {
       const resultText = typeof r.result === "string" ? r.result : r.result !== void 0 ? safeStringify(r.result) : void 0;
@@ -40293,7 +41277,7 @@ var Director = class _Director {
     }
     this.armSubagentIdleRetirement(
       r.subagentId,
-      this.retireSubagentOnTaskComplete ? 0 : this.subagentIdleTimeoutMs
+      this.retireSubagentOnTaskComplete ? 0 : this.subagentIdleDelayMs.get(r.subagentId) ?? this.subagentIdleTimeoutMs
     );
   }
   extensionsFor(subagentId) {
@@ -40311,6 +41295,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);
   }
@@ -40368,6 +41363,7 @@ var Director = class _Director {
     this.resolveSpawnModel(config);
     const subagentId = await spawn6(this, config, priceLookup);
     const perSubagentIdleMs = typeof config.idleTimeoutMs === "number" && Number.isFinite(config.idleTimeoutMs) && config.idleTimeoutMs >= 0 ? config.idleTimeoutMs : this.subagentIdleTimeoutMs;
+    this.subagentIdleDelayMs.set(subagentId, perSubagentIdleMs);
     this.armSubagentIdleRetirement(subagentId, perSubagentIdleMs);
     return subagentId;
   }
@@ -40387,7 +41383,7 @@ var Director = class _Director {
       );
     }
     const msg = {
-      id: randomUUID19(),
+      id: randomUUID20(),
       type: "task",
       from: this.id,
       to: subagentId,
@@ -40421,6 +41417,7 @@ var Director = class _Director {
     this.budgetPolicy.dispose();
     for (const timer of this.subagentIdleTimers.values()) clearTimeout(timer);
     this.subagentIdleTimers.clear();
+    this.subagentIdleDelayMs.clear();
     await this.coordinator.stopAll();
     this.tasks.resolveWaitersOnShutdown();
     for (const b of this.subagentBridges.values()) {
@@ -40479,6 +41476,7 @@ var Director = class _Director {
   }
   async remove(subagentId) {
     this.clearSubagentIdleRetirement(subagentId);
+    this.subagentIdleDelayMs.delete(subagentId);
     void this.appendSessionEvent({
       type: "agent_stopped",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -40531,9 +41529,13 @@ var Director = class _Director {
     const timer = setTimeout(() => {
       this.subagentIdleTimers.delete(subagentId);
       const entry = this.coordinator.getStatus().subagents.find((a) => a.id === subagentId);
-      if (entry?.status !== "idle") return;
+      if (entry === void 0) return;
+      if (entry.status !== "idle") {
+        this.armSubagentIdleRetirement(subagentId, Math.max(delayMs, BUSY_REARM_FLOOR_MS));
+        return;
+      }
       if (this.coordinator.listPendingTasks().some((task) => task.subagentId === subagentId)) {
-        this.armSubagentIdleRetirement(subagentId, this.subagentIdleTimeoutMs);
+        this.armSubagentIdleRetirement(subagentId, Math.max(delayMs, BUSY_REARM_FLOOR_MS));
         return;
       }
       void this.remove(subagentId).catch(
@@ -40641,7 +41643,7 @@ var Director = class _Director {
 };
 
 // src/coordination/fleet-manager.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 import * as fsp31 from "node:fs/promises";
 import * as path64 from "node:path";
 init_atomic_write();
@@ -40709,7 +41711,7 @@ var FleetManager = class {
   maxContext;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
-    this.directorRunId = opts.directorRunId ?? randomUUID20();
+    this.directorRunId = opts.directorRunId ?? randomUUID21();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = resolveMaxSpawnDepth(opts.maxSpawnDepth);
     this.spawnDepth = opts.spawnDepth ?? 0;
@@ -42761,7 +43763,7 @@ function makeFleetStatusTool(opts = {}) {
 }
 
 // src/coordination/fleet-supervisor.ts
-import { randomUUID as randomUUID21 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 var COLLAB_ID_PREFIXES2 = ["bug-hunter-", "refactor-planner-", "critic-"];
 var DEFAULTS = {
   intervalMs: 2e4,
@@ -43039,7 +44041,7 @@ var FleetSupervisor = class {
    */
   async decide(question, context, options, risk) {
     const request = {
-      id: `fleetsup-${randomUUID21()}`,
+      id: `fleetsup-${randomUUID22()}`,
       sessionId: this.opts.sessionId?.(),
       source: "system",
       question,
@@ -43435,7 +44437,7 @@ function attachAutoExtend(events, policy = {}) {
 }
 
 // src/coordination/delegate-tool.ts
-import { randomUUID as randomUUID22 } from "node:crypto";
+import { randomUUID as randomUUID23 } from "node:crypto";
 import * as fsp32 from "node:fs/promises";
 import * as path69 from "node:path";
 init_error();
@@ -43642,7 +44644,7 @@ function createDelegateTool(opts) {
           }
           const description = delegatedTask;
           const taskId = await dir.assign({
-            id: randomUUID22(),
+            id: randomUUID23(),
             description,
             subagentId
           });
@@ -43863,7 +44865,7 @@ async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abo
 function freshHandoffConfig(cfg, role, handoffCount) {
   return {
     ...cfg,
-    id: role ? `${role}-${randomUUID22().slice(0, 8)}` : `${cfg.name.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "subagent"}-handoff-${handoffCount}-${randomUUID22().slice(0, 6)}`
+    id: role ? `${role}-${randomUUID23().slice(0, 8)}` : `${cfg.name.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "subagent"}-handoff-${handoffCount}-${randomUUID23().slice(0, 6)}`
   };
 }
 function continuationFor(result, partial, config) {
@@ -43923,7 +44925,7 @@ function instantiateRosterConfig2(role, base, requestedTimeoutMs, defaultTimeout
     timeoutMs: requestedTimeoutMs === void 0 ? rosterTimeoutMs ?? defaultTimeoutMs : void 0,
     // Give each spawn a fresh id so parallel or repeated delegates
     // can use the same role safely.
-    id: `${role}-${randomUUID22().slice(0, 8)}`
+    id: `${role}-${randomUUID23().slice(0, 8)}`
   };
 }
 function hintForKind(kind, retryable, backoffMs, partial) {
@@ -44049,7 +45051,7 @@ async function readSubagentPartial(opts, subagentId) {
 }
 
 // src/coordination/explore-companion.ts
-import { randomUUID as randomUUID23 } from "node:crypto";
+import { randomUUID as randomUUID24 } from "node:crypto";
 var DEFAULT_EXPLORE_COMPANION_AGENT_ID = "explore-companion";
 var DEFAULT_PROBE_COOLDOWN_MS = 12e4;
 var DEFAULT_MAX_PENDING_PROBES = 8;
@@ -44189,16 +45191,14 @@ var ExploreCompanion = class {
     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;
+        if (e.sessionId !== this.resolveLeaderSessionId()) 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;
+          if (e.sessionId !== this.resolveLeaderSessionId()) return;
           this.trackAgentTodos(e.agents);
         })
       );
@@ -44206,8 +45206,7 @@ var ExploreCompanion = class {
     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;
+          if (e.sessionId !== this.resolveLeaderSessionId()) return;
           this.trackError(e.err);
         })
       );
@@ -44235,7 +45234,7 @@ var ExploreCompanion = class {
     if (e.ok && this.cfg.signals.editUnreadFile && this.cfg.fileEditTools.has(tool) && path131) {
       if (!this.readSet.has(path131)) {
         this.engage({
-          id: randomUUID23(),
+          id: randomUUID24(),
           probe: `Map file ${path131}: role, exports, dependencies, and callers \u2014 the leader is about to edit it.`,
           hint: { file: path131 },
           context: `Leader edited ${path131} without reading it first.`,
@@ -44250,7 +45249,7 @@ var ExploreCompanion = class {
       if (!this.readSet.has(path131)) {
         this.readSet.add(path131);
         this.engage({
-          id: randomUUID23(),
+          id: randomUUID24(),
           probe: `Skeleton + callers + dependents of ${path131}: what it exports, who imports it, and how it fits the feature flow.`,
           hint: { file: path131 },
           context: `Leader read unfamiliar file ${path131}.`,
@@ -44265,7 +45264,7 @@ var ExploreCompanion = class {
       const input = e.input ?? {};
       const query = typeof input["query"] === "string" ? input["query"] : typeof input["pattern"] === "string" ? input["pattern"] : "";
       this.engage({
-        id: randomUUID23(),
+        id: randomUUID24(),
         probe: query ? `Locate "${query}" \u2014 the leader's ${e.name} returned no hits. Try synonyms, a refreshed index, and lexical fallbacks.` : `The leader's ${e.name} returned no results. Find where the concept actually lives.`,
         hint: query ? { symbol: query } : void 0,
         context: `${e.name} for "${query}" returned zero results.`,
@@ -44286,7 +45285,7 @@ var ExploreCompanion = class {
         const mentions = extractSubjectTokens(todo.content);
         const first = mentions[0];
         this.engage({
-          id: randomUUID23(),
+          id: randomUUID24(),
           probe: `Pre-map the files/symbols behind this in-progress todo: "${todo.content.slice(0, 160)}".`,
           hint: first ? { [first.kind]: first.value } : void 0,
           context: `Todo "${todo.content.slice(0, 120)}" flipped to in_progress.`,
@@ -44302,7 +45301,7 @@ var ExploreCompanion = class {
     const tokens = extractSubjectTokens(err.message);
     for (const token of tokens.slice(0, 2)) {
       this.engage({
-        id: randomUUID23(),
+        id: randomUUID24(),
         probe: `What is ${token.value}, where does it live, and who uses it? The leader hit an error naming it.`,
         hint: { [token.kind]: token.value },
         context: `Error: ${err.message.slice(0, 300)}`,
@@ -44320,12 +45319,21 @@ var ExploreCompanion = class {
         limit: 20
       });
       const lsid = this.resolveLeaderSessionId();
+      const selfRecipients = new Set(
+        [
+          this.cfg.companionAgentId,
+          mailboxIdentityBase(this.cfg.companionAgentId),
+          ...lsid != null ? [sessionRecipient(lsid)] : []
+        ].map((r) => r.toLowerCase())
+      );
       for (const msg of messages) {
         if (msg.type !== "ask" && msg.type !== "assign") continue;
-        const fromLeader = isMailboxLeader(msg.from) || lsid != null && msg.senderSessionId === lsid;
+        const to = msg.to.trim().toLowerCase();
+        if (to !== "*" && !selfRecipients.has(to)) continue;
+        const fromLeader = msg.senderSessionId === void 0 && isMailboxLeader(msg.from) || lsid != null && msg.senderSessionId === lsid;
         if (!fromLeader) continue;
         this.engage({
-          id: randomUUID23(),
+          id: randomUUID24(),
           probe: msg.body.trim().slice(0, 2e3) || msg.subject,
           context: `Direct ask from ${msg.from}: ${msg.subject}`,
           source: "mailbox_ask",
@@ -44407,6 +45415,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",
@@ -44644,7 +45668,9 @@ function makeMailSendTool(opts = {}) {
       required: ["to", "subject", "body"]
     },
     async execute(input, ctx) {
-      const i = input ?? {};
+      const { payload: i, stripped } = filterMailboxSendPayload(
+        input ?? {}
+      );
       const rawTo = i.to;
       const subject2 = i.subject;
       const body = i.body;
@@ -44667,15 +45693,13 @@ function makeMailSendTool(opts = {}) {
         recipientAliases: /* @__PURE__ */ new Set([codecIdentity.baseId]),
         sessionId: codecIdentity.sessionId
       };
+      let parsed;
       try {
-        parseMailboxSendInput(i, codecActor);
+        parsed = parseMailboxSendInput(i, codecActor);
       } catch (err) {
         return { ok: false, error: err instanceof Error ? err.message : String(err) };
       }
-      const audience = i.audience;
-      if (audience !== void 0 && audience !== "all" && audience !== "leaders") {
-        return { ok: false, error: '"audience" must be "all" or "leaders".' };
-      }
+      const audience = parsed.audience;
       const mb = resolveMailbox(ctx);
       const identity2 = await register(mb, ctx);
       const requestedTo = normalizeRecipient(rawTo, identity2.sessionId);
@@ -44689,10 +45713,10 @@ function makeMailSendTool(opts = {}) {
         to: delivery.to,
         type: resolvedType,
         audience: delivery.audience,
-        subject: subject2,
-        body,
-        priority: i.priority ?? "normal",
-        replyTo: i.replyTo,
+        subject: parsed.subject,
+        body: parsed.body,
+        priority: parsed.priority,
+        replyTo: parsed.replyTo,
         senderSessionId: identity2.sessionId
       });
       return {
@@ -44700,7 +45724,9 @@ function makeMailSendTool(opts = {}) {
         messageId: msg.id,
         from: identity2.callerId,
         to: msg.to,
-        summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity2.callerId}.`
+        // Surfacing what was stripped keeps the send auditable without
+        // re-introducing the clutter into the payload itself.
+        ...stripped.length > 0 ? { strippedFields: stripped, summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity2.callerId}. Ignored ${stripped.length} unrecognized field(s): ${stripped.join(", ")}.` } : { summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity2.callerId}.` }
       };
     }
   };
@@ -48226,7 +49252,7 @@ function createAgentMonitorService(opts) {
 }
 
 // src/coordination/autonomous-brain.ts
-import { randomUUID as randomUUID24 } from "node:crypto";
+import { randomUUID as randomUUID25 } from "node:crypto";
 var AutonomousBrain = class {
   graph;
   // Fleet bus for emitting decisions — null-safe, no-op if not provided
@@ -48332,7 +49358,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: randomUUID24(),
+      id: randomUUID25(),
       source,
       decisionType: "spawn",
       question: `Should we spawn a subagent for this task?`,
@@ -48375,7 +49401,7 @@ var AutonomousBrain = class {
       }
     ];
     return this.decideAuto({
-      id: randomUUID24(),
+      id: randomUUID25(),
       source,
       decisionType: "approve_change",
       question: `Should we approve the change "${change.title}"?`,
@@ -48434,7 +49460,7 @@ var AutonomousBrain = class {
       consequence: "Break the task into smaller sub-tasks"
     });
     return this.decideAuto({
-      id: randomUUID24(),
+      id: randomUUID25(),
       source,
       decisionType: "escalate_task",
       question: `Task failed: ${error2.slice(0, 100)}. How should we proceed?`,
@@ -48568,12 +49594,12 @@ ${ctx.error}`);
 };
 
 // src/coordination/autonomous-coordinator.ts
-import { randomUUID as randomUUID27 } from "node:crypto";
+import { randomUUID as randomUUID28 } from "node:crypto";
 
 // src/coordination/knowledge-graph.ts
 init_file_permissions();
 init_atomic_write();
-import { randomUUID as randomUUID25 } from "node:crypto";
+import { randomUUID as randomUUID26 } from "node:crypto";
 import * as fsp34 from "node:fs/promises";
 import * as path73 from "node:path";
 var DEFAULT_MAX_NODES = 2e3;
@@ -48621,7 +49647,7 @@ var KnowledgeGraph = class _KnowledgeGraph {
    * Returns the node with its assigned id.
    */
   async add(node) {
-    const full = { id: randomUUID25(), ...node };
+    const full = { id: randomUUID26(), ...node };
     this.nodes.set(full.id, full);
     this._trackSeq(full.id);
     this._addToIndex(full, this._indexKeys(full));
@@ -48750,8 +49776,8 @@ var KnowledgeGraph = class _KnowledgeGraph {
     if (this.subs.size >= MAX_SUBSCRIPTIONS) {
       throw new Error(`Knowledge graph subscription limit reached (${MAX_SUBSCRIPTIONS})`);
     }
-    const channel2 = randomUUID25();
-    const sub = { id: randomUUID25(), agentId, filter, channel: channel2 };
+    const channel2 = randomUUID26();
+    const sub = { id: randomUUID26(), agentId, filter, channel: channel2 };
     this.subs.set(channel2, sub);
     this.pendingDeliveries.set(channel2, []);
     return channel2;
@@ -49232,7 +50258,7 @@ var TaskDAG = class {
 };
 
 // src/coordination/task-auctioneer.ts
-import { randomUUID as randomUUID26 } from "node:crypto";
+import { randomUUID as randomUUID27 } from "node:crypto";
 function isTerminalGoalStatus(status) {
   return status === "done" || status === "failed";
 }
@@ -49355,7 +50381,7 @@ var TaskAuctioneer = class {
     const score = dispatchResult.confidence * (dispatchResult.role === agent.agentRole ? 1.2 : 1);
     if (score < this.minConfidence) return false;
     const bid = {
-      id: randomUUID26(),
+      id: randomUUID27(),
       taskId,
       agentId: agent.agentId,
       agentName: agent.agentName,
@@ -50292,7 +51318,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
           break;
         }
         const decision = await this.brain.decideAuto({
-          id: randomUUID27(),
+          id: randomUUID28(),
           source: "system",
           decisionType: "prioritize_goals",
           question: `What should we work on next? Open goals: ${dispatchable.map((g) => g.title).join(", ")}`,
@@ -51207,7 +52233,7 @@ var TOKENS = {
 init_errors();
 
 // src/hq/factory.ts
-import { createHash as createHash24, randomUUID as randomUUID30 } from "node:crypto";
+import { createHash as createHash24, randomUUID as randomUUID31 } from "node:crypto";
 import * as fs30 from "node:fs";
 import { hostname as hostname3 } from "node:os";
 import { basename as basename15 } from "node:path";
@@ -51215,13 +52241,13 @@ import { basename as basename15 } from "node:path";
 // src/hq/auth-store.ts
 init_file_permissions();
 init_atomic_write();
-import { createHash as createHash23, randomBytes as randomBytes4, randomUUID as randomUUID28, scrypt, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createHash as createHash23, randomBytes as randomBytes4, randomUUID as randomUUID29, scrypt, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import * as syncFs from "node:fs";
 import * as fs29 from "node:fs/promises";
 import * as path75 from "node:path";
 
 // src/hq/auth-audit.ts
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync20, mkdirSync as mkdirSync9 } from "node:fs";
+import { appendFileSync as appendFileSync2, readFileSync as readFileSync21, mkdirSync as mkdirSync9 } from "node:fs";
 import * as path74 from "node:path";
 function hqAuthAuditPath(dataDir) {
   return path74.join(dataDir, "auth-audit.jsonl");
@@ -51230,7 +52256,7 @@ function readHqAuthAuditTail(dataDir, maxEntries = 50) {
   const filePath = hqAuthAuditPath(dataDir);
   let content;
   try {
-    content = readFileSync20(filePath, "utf8");
+    content = readFileSync21(filePath, "utf8");
   } catch {
     return [];
   }
@@ -51542,8 +52568,8 @@ function mintHqToken(labelOrOptions) {
   const at = opts.now ?? Date.now();
   const createdAtIso = new Date(at).toISOString();
   return {
-    id: randomUUID28(),
-    token: randomUUID28().replace(/-/g, "") + randomUUID28().replace(/-/g, ""),
+    id: randomUUID29(),
+    token: randomUUID29().replace(/-/g, "") + randomUUID29().replace(/-/g, ""),
     createdAt: createdAtIso,
     ...opts.label ? { label: opts.label } : {},
     ...opts.ttlMs !== void 0 && Number.isFinite(opts.ttlMs) && opts.ttlMs > 0 ? { expiresAt: new Date(at + opts.ttlMs).toISOString() } : {}
@@ -51603,7 +52629,7 @@ function watchHqAuthFile(dataDir, onChange, opts = {}) {
 }
 
 // src/hq/publisher.ts
-import { randomUUID as randomUUID29 } from "node:crypto";
+import { randomUUID as randomUUID30 } from "node:crypto";
 import * as v82 from "node:v8";
 
 // src/hq/protocol/governance.ts
@@ -52677,7 +53703,7 @@ var HqPublisher = class {
     this.options = options;
     this.socketFactory = options.socketFactory ?? defaultSocketFactory;
     this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-    this.idFactory = options.idFactory ?? randomUUID29;
+    this.idFactory = options.idFactory ?? randomUUID30;
     this.capabilities = options.capabilities ?? [
       "telemetry.publish",
       "mailbox.summary",
@@ -53261,7 +54287,7 @@ function createHqPublisherFromEnv(options) {
   const projectAlias = config.projectAlias?.trim() || void 0;
   const projectName = projectAlias ?? options.projectName ?? (basename15(options.projectRoot) || "unknown");
   const client = {
-    clientId: `${machineId}:${options.clientKind}:${process.pid}:${randomUUID30().slice(0, 8)}`,
+    clientId: `${machineId}:${options.clientKind}:${process.pid}:${randomUUID31().slice(0, 8)}`,
     kind: options.clientKind,
     machineId,
     ...host ? { hostname: host } : {},
@@ -53530,40 +54556,6 @@ async function injectPendingMailboxMessages(checkMailbox2, foldFn, a, deliveryMo
   return interruptMsg ? { interrupt: true, interruptReason: interruptMsg.body || interruptMsg.subject || "operator interrupt" } : { interrupt: false };
 }
 
-// src/core/btw.ts
-var META_KEY2 = "_btwNotes";
-var MAX_PENDING = 20;
-function readQueue(ctx) {
-  const raw = ctx.meta[META_KEY2];
-  return Array.isArray(raw) ? raw : [];
-}
-function setBtwNote(ctx, text2) {
-  const trimmed = text2.trim();
-  if (!trimmed) return readQueue(ctx).length;
-  const next = [...readQueue(ctx), trimmed].slice(-MAX_PENDING);
-  ctx.meta[META_KEY2] = next;
-  return next.length;
-}
-function pendingBtwCount(ctx) {
-  return readQueue(ctx).length;
-}
-function consumeBtwNotes(ctx) {
-  const notes = readQueue(ctx);
-  if (notes.length > 0) delete ctx.meta[META_KEY2];
-  return notes;
-}
-function buildBtwBlock(notes) {
-  const body = notes.map((n) => `- ${n}`).join("\n");
-  return [
-    "[BY THE WAY \u2014 the user added this while you were working. Fold it into",
-    "your current task; do not restart from scratch unless it contradicts the",
-    "goal:",
-    "",
-    body,
-    "]"
-  ].join("\n");
-}
-
 // src/core/fleet-pulse.ts
 var DEFAULT_MAX_AGENTS = 15;
 var DEFAULT_MAX_CHARS = 900;
@@ -53571,9 +54563,17 @@ var TASK_SNIPPET_CHARS2 = 60;
 function fleetPulseSignature(statuses) {
   return statuses.map((s) => `${s.agentId}|${s.status}|${s.currentTask ?? ""}`).sort().join("\n");
 }
-function peerLine(s) {
+function visibleLineKey(s) {
+  const role = s.role && s.role !== s.name ? s.role : "";
+  const task = s.currentTask && s.currentTask.length > TASK_SNIPPET_CHARS2 ? `${s.currentTask.slice(0, TASK_SNIPPET_CHARS2)}\u2026` : s.currentTask ?? "";
+  const tool = s.currentTool || "";
+  const toolCalls = s.toolCalls > 0 ? String(s.toolCalls) : "";
+  return [s.name, role, s.status, task, tool, toolCalls].join("\0");
+}
+function peerLine(s, count = 1) {
   const role = s.role && s.role !== s.name ? ` (${s.role})` : "";
-  const parts = [`\u2022 ${s.name}${role} \u2014 ${s.status}`];
+  const grouped = count > 1 ? ` \xD7${count}` : "";
+  const parts = [`\u2022 ${s.name}${role}${grouped} \u2014 ${s.status}`];
   if (s.currentTask) {
     const task = s.currentTask.length > TASK_SNIPPET_CHARS2 ? `${s.currentTask.slice(0, TASK_SNIPPET_CHARS2)}\u2026` : s.currentTask;
     parts.push(`"${task}"`);
@@ -53589,13 +54589,20 @@ function buildFleetPulseBlock(statuses, opts) {
   if (peers.length === 0) return null;
   const order = { running: 0, streaming: 0, waiting_user: 1, idle: 2, error: 3, offline: 4 };
   const sorted = [...peers].sort(
-    (x, y) => (order[x.status] ?? 5) - (order[y.status] ?? 5) || x.name.localeCompare(y.name)
+    (x, y) => (order[x.status] ?? 5) - (order[y.status] ?? 5) || visibleLineKey(x).localeCompare(visibleLineKey(y))
   );
   const shown = sorted.slice(0, maxAgents);
   const hidden = sorted.length - shown.length;
   const parts = [];
   parts.push(`[FLEET PULSE] ${peers.length} peer${peers.length === 1 ? "" : "s"} online:`);
-  for (const s of shown) parts.push(peerLine(s));
+  for (let i = 0; i < shown.length; ) {
+    let run = 1;
+    while (i + run < shown.length && visibleLineKey(shown[i]) === visibleLineKey(shown[i + run])) {
+      run++;
+    }
+    parts.push(peerLine(shown[i], run));
+    i += run;
+  }
   if (hidden > 0) parts.push(`\u2026 +${hidden} more`);
   parts.push(
     "[END FLEET PULSE] (FYI \u2014 coordinate via mail_send; avoid duplicating peers' work)"
@@ -54277,6 +55284,7 @@ function requestLimitExtension(opts) {
 // src/prompts/prompt-journal.ts
 import * as fs31 from "node:fs/promises";
 import * as path77 from "node:path";
+var defaultScrubber2 = new DefaultSecretScrubber();
 var PROMPT_JOURNAL_RAW_MARKER = "promptJournal.raw";
 async function ensureGitignore(projectRoot) {
   const gitignorePath = path77.join(projectRoot, ".gitignore");
@@ -54305,7 +55313,9 @@ async function recordPromptJournalEntry(opts) {
   const monthStr = dateStr.slice(0, 7);
   const sessionId = opts.sessionId && opts.sessionId.trim() ? opts.sessionId.trim() : "general";
   const id = `pmt_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-  const content = opts.content ?? "";
+  const content = defaultScrubber2.scrub(opts.content ?? "");
+  const rawContent = typeof opts.rawContent === "string" && opts.rawContent.length > 0 ? defaultScrubber2.scrub(opts.rawContent) : opts.rawContent;
+  const decisionReason = typeof opts.decisionReason === "string" && opts.decisionReason.length > 0 ? defaultScrubber2.scrub(opts.decisionReason) : opts.decisionReason;
   const lines = content.split("\n");
   const characterCount = content.length;
   const lineCount2 = lines.length;
@@ -54318,7 +55328,7 @@ async function recordPromptJournalEntry(opts) {
     role: opts.role ?? (opts.category === "system_prompt" ? "system" : "user"),
     category: opts.category,
     content,
-    rawContent: opts.rawContent,
+    rawContent,
     metadata: {
       model: opts.model,
       provider: opts.provider,
@@ -54329,7 +55339,7 @@ async function recordPromptJournalEntry(opts) {
       activeTools: opts.activeTools,
       contextFiles: opts.contextFiles,
       durationMs: opts.durationMs,
-      decisionReason: opts.decisionReason,
+      decisionReason,
       tags: opts.tags
     }
   };
@@ -54546,7 +55556,7 @@ async function getPromptJournalEntries(projectRoot, filter = {}) {
 init_errors();
 
 // src/core/streaming-response-builder.ts
-import { randomUUID as randomUUID32 } from "node:crypto";
+import { randomUUID as randomUUID33 } from "node:crypto";
 var STREAM_DRAIN_TIMEOUT_MS = 500;
 function buildResponse(state) {
   const content = [];
@@ -54606,7 +55616,7 @@ function handleContentBlockStart(state, ev) {
     state.textBuffers.push("");
     state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
   } else if (kind === "tool_use") {
-    const id = ev.id ?? randomUUID32();
+    const id = ev.id ?? randomUUID33();
     state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
     state.blockOrder.push({ kind: "tool", id });
     state.currentTextIndex = -1;
@@ -54841,7 +55851,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
 
 // src/observability/network-telemetry.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createHash as createHash25, randomUUID as randomUUID33 } from "node:crypto";
+import { createHash as createHash25, randomUUID as randomUUID34 } from "node:crypto";
 import { channel } from "node:diagnostics_channel";
 var storage = new AsyncLocalStorage();
 var requests = /* @__PURE__ */ new WeakMap();
@@ -54878,7 +55888,7 @@ function subscribe() {
     const requestBytes = numberField2(request, "contentLength");
     const state = {
       ...context,
-      requestId: randomUUID33(),
+      requestId: randomUUID34(),
       ...target,
       ...requestBytes !== void 0 ? { requestBytes } : {},
       startedAt,
@@ -55013,7 +56023,7 @@ function hash3(value) {
 }
 
 // src/core/provider-runner.ts
-import { randomUUID as randomUUID34 } from "node:crypto";
+import { randomUUID as randomUUID35 } from "node:crypto";
 function scrubProviderBody(body) {
   if (!body) return void 0;
   return {
@@ -55035,11 +56045,11 @@ function providerLogCtx(p, r) {
 }
 async function runProviderWithRetry(opts) {
   const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
-  const logicalRequestId = randomUUID34();
+  const logicalRequestId = randomUUID35();
   const promptManifest = createChroniclePromptManifest(request);
   let attempt = 0;
   for (; ; ) {
-    const attemptId = randomUUID34();
+    const attemptId = randomUUID35();
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startedNs = process.hrtime.bigint();
     const correlation = {
@@ -55892,10 +56902,7 @@ function createAgentToolHandler(a) {
           } catch {
           }
         }
-        if (decision === "yes") {
-          const p = a.permission;
-          p.allowOnce?.({ tool: tool.name, pattern: result.suggestedPattern });
-        } else if (decision === "no") {
+        if (decision === "no") {
           const p = a.permission;
           p.denyOnce?.({ tool: tool.name, pattern: result.suggestedPattern });
         }
@@ -59708,7 +60715,7 @@ function _resetDesignRulesCache() {
 }
 
 // src/execution/design-color.ts
-function clamp(n, lo, hi) {
+function clamp2(n, lo, hi) {
   return n < lo ? lo : n > hi ? hi : n;
 }
 function parseOklch(value) {
@@ -59724,9 +60731,9 @@ function parseOklch(value) {
   let a = 1;
   if (alphaPart !== void 0) {
     const av = parseComponent(alphaPart.trim(), true);
-    if (av !== null) a = clamp(av, 0, 1);
+    if (av !== null) a = clamp2(av, 0, 1);
   }
-  return [clamp(L, 0, 1), Math.max(0, C), H, a];
+  return [clamp2(L, 0, 1), Math.max(0, C), H, a];
 }
 function parseComponent(s, percentIsFraction) {
   s = s.trim();
@@ -59745,7 +60752,7 @@ function parseAngle(s) {
 }
 function linearToSrgb(c) {
   const v = c <= 31308e-7 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
-  return clamp(v, 0, 1);
+  return clamp2(v, 0, 1);
 }
 function toHex2(n) {
   return Math.round(n * 255).toString(16).padStart(2, "0");
@@ -62492,7 +63499,7 @@ ${summaryText}` : summaryText;
 
 // src/execution/parallel-eternal-engine.ts
 init_error();
-import { randomUUID as randomUUID35 } from "node:crypto";
+import { randomUUID as randomUUID36 } from "node:crypto";
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
@@ -62569,7 +63576,7 @@ var ParallelEternalEngine = class {
     this.state = "running";
     await this.persistState("running");
     const config = {
-      coordinatorId: `parallel-${randomUUID35().slice(0, 8)}`,
+      coordinatorId: `parallel-${randomUUID36().slice(0, 8)}`,
       maxConcurrent: this.slots,
       doneCondition: { type: "all_tasks_done" }
     };
@@ -62623,7 +63630,7 @@ var ParallelEternalEngine = class {
     }
     if (!this.coordinator) {
       const config = {
-        coordinatorId: `parallel-${randomUUID35().slice(0, 8)}`,
+        coordinatorId: `parallel-${randomUUID36().slice(0, 8)}`,
         maxConcurrent: this.slots,
         doneCondition: { type: "all_tasks_done" }
       };
@@ -62709,7 +63716,7 @@ ${recentJournal}` : "No prior iterations.",
       const task = expectDefined(tasks[i]);
       const route = routes[i] ?? null;
       const subagentId = `parallel-${this.iterations}-${i}`;
-      const taskId = randomUUID35();
+      const taskId = randomUUID36();
       const personaLine = route ? `Acting agent: ${route.definition.config.name} \u2014 ${route.definition.capability.summary}
 ` : "";
       const spec = {
@@ -63659,6 +64666,10 @@ var DefaultSkillLoader = class {
         );
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
+          if (!isValidSkillNameFormat(e.name)) {
+            this.skipped.push({ dir, entry: e.name, reason: "invalid-name-format" });
+            continue;
+          }
           const skillFile = path80.join(dir, e.name, "SKILL.md");
           let raw;
           try {
@@ -64337,7 +65348,7 @@ function readPolicy(ctx) {
 }
 
 // src/execution/tool-executor.ts
-import { randomUUID as randomUUID38 } from "node:crypto";
+import { randomUUID as randomUUID39 } from "node:crypto";
 import * as fs38 from "node:fs/promises";
 import * as path85 from "node:path";
 init_errors();
@@ -64359,7 +65370,7 @@ var ToolErrorCategory = /* @__PURE__ */ ((ToolErrorCategory2) => {
 })(ToolErrorCategory || {});
 
 // src/execution/tool-executor-support.ts
-import { createHash as createHash29, randomUUID as randomUUID36 } from "node:crypto";
+import { createHash as createHash29, randomUUID as randomUUID37 } from "node:crypto";
 import * as fs37 from "node:fs/promises";
 import * as path83 from "node:path";
 init_errors();
@@ -64491,7 +65502,7 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     await fs37.mkdir(dir, { recursive: true });
     const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const filePath = path83.join(dir, `${stamp}-${safeTool}-${randomUUID36()}.log`);
+    const filePath = path83.join(dir, `${stamp}-${safeTool}-${randomUUID37()}.log`);
     await fs37.writeFile(filePath, content, "utf8");
     const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
     const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
@@ -65041,7 +66052,7 @@ ${errorDetails}`,
 }
 
 // src/execution/tool-executor-runner.ts
-import { randomUUID as randomUUID37 } from "node:crypto";
+import { randomUUID as randomUUID38 } from "node:crypto";
 
 // src/observability/process-telemetry.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
@@ -65063,7 +66074,7 @@ var SENSITIVE_FLAG_PATTERNS = [
   // redaction function (false positive = cosmetic noise; false negative = leak).
   /(?<![-\w])-(?:password|p|a)(?:[=\s]+)?[^\s,-]+/gi,
   // env var–style secrets: TOKEN=x, API_KEY=y, etc.
-  /(?:TOKEN|API_KEY|API_SECRET|AUTH_TOKEN|GITHUB_TOKEN|GH_TOKEN|BEARER|JWT|OAUTH|CREDENTIAL|SECRET|PRIVATE_KEY|PASSWORD|PASSWD)\s*[=:]\s*[^\s,]+/gi,
+  /(?:TOKEN|API_KEY|API_SECRET|AUTH_TOKEN|GITHUB_TOKEN|GH_TOKEN|BEARER|JWT|OAUTH|CREDENTIAL|SECRET|PRIVATE_KEY|PASSWORD|PASSWD|PASSPHRASE)\s*[=:]\s*[^\s,]+/gi,
   // Generic high-entropy look: base64 strings >32 chars or hex strings >32 digits — but only
   // when preceded by a flag name (e.g. --github-token=EyJ...). Global flag so
   // every such flag in the command line is redacted, not just the first.
@@ -65265,7 +66276,7 @@ async function runToolWithTimeout(tool, input, parentSignal, ctx, opts, config,
     progressTailChars: config.progressTailChars,
     progressHeadChars: config.progressHeadChars
   }) : (async () => tool.execute(input, ctx, { signal: combined }))();
-  const telemetryToolCallId = toolUseId ?? `nested-${randomUUID37()}`;
+  const telemetryToolCallId = toolUseId ?? `nested-${randomUUID38()}`;
   const toolPromise = opts.events ? runWithNetworkTelemetry(
     {
       events: opts.events,
@@ -65438,7 +66449,7 @@ var ToolExecutor = class _ToolExecutor {
         return { result, tool, durationMs: Date.now() - start };
       }
       if (effectivePermission === "confirm") {
-        const suggestedPattern = boundary.decision === "confirm" ? `kanban-boundary:${boundary.path ?? tool.name}` : subjectForToolInput(tool.name, use.input, tool.subjectKey) ?? tool.name;
+        const suggestedPattern = boundary.decision === "confirm" ? `kanban-boundary:${boundary.path ?? tool.name}` : subjectForToolInput(tool.name, use.input, tool.subjectKey, tool.subjectFields) ?? tool.name;
         if (this.opts.confirmAwaiter) {
           const awaiter = this.opts.confirmAwaiter;
           const choice = await new Promise(
@@ -65658,7 +66669,7 @@ ${post.additionalContext}`;
     const bridge = async (toolName, input) => {
       const nestedUse = {
         type: "tool_use",
-        id: `nested-${randomUUID38()}`,
+        id: `nested-${randomUUID39()}`,
         name: toolName,
         input
       };
@@ -66263,13 +67274,13 @@ import * as fs39 from "node:fs/promises";
 import * as path87 from "node:path";
 
 // src/types/mode-prompts.ts
-import { readFileSync as readFileSync23, statSync as statSync9 } from "node:fs";
+import { readFileSync as readFileSync24, statSync as statSync9 } from "node:fs";
 import * as path86 from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function modePrompt(id) {
   for (const dir of modePromptDirCandidates()) {
     try {
-      return readFileSync23(path86.join(dir, `${id}.md`), "utf8").trimEnd();
+      return readFileSync24(path86.join(dir, `${id}.md`), "utf8").trimEnd();
     } catch {
     }
   }
@@ -66950,7 +67961,17 @@ function normalizeModelsDevModel(model) {
   const reasoningConfig = {
     default: disableSupported ? "enabled" : "always_on",
     disableSupported,
-    effortSupported: effortLevels.length > 0,
+    // Tri-state (see ReasoningConfig.effortSupported):
+    //   options present  → documented answer (true when effort values exist;
+    //                      an explicitly EMPTY array is a documented "no
+    //                      effort control", not an absent field).
+    //   field ABSENT     → the model is known to reason but its vocabulary is
+    //                      undocumented → `undefined`, so the resolver forwards
+    //                      the request and each wire adapter applies its own
+    //                      transport gating. Sending `false` here would make
+    //                      the resolver claim "does not support effort" — an
+    //                      assertion the catalog never made.
+    ...raw === void 0 ? {} : { effortSupported: effortLevels.length > 0 },
     effortLevels,
     preserveThinking: model.interleaved ? "always_on" : "unsupported"
   };
@@ -67539,9 +68560,9 @@ async function startMetricsServer(opts) {
   let server;
   if (useHttps && tls) {
     const { createServer } = await import("node:https");
-    const { readFileSync: readFileSync25 } = await import("node:fs");
+    const { readFileSync: readFileSync26 } = await import("node:fs");
     server = createServer(
-      { cert: readFileSync25(tls.cert), key: readFileSync25(tls.key) },
+      { cert: readFileSync26(tls.cert), key: readFileSync26(tls.key) },
       listener
     );
   } else {
@@ -67965,7 +68986,9 @@ function hasRecursiveForceDelete(command, projectRoot) {
     if (token === "rd" || token === "rmdir") {
       const args = commandSegment(tokens, i + 1).map((arg) => arg.toLowerCase());
       if (args.includes("/s")) {
-        const targets = args.filter((arg) => !arg.startsWith("-") && !arg.startsWith("/") && !SHELL_OPERATORS.has(arg));
+        const targets = args.filter(
+          (arg) => !arg.startsWith("-") && !arg.startsWith("/") && !SHELL_OPERATORS.has(arg)
+        );
         if (targets.length === 0) return true;
         if (targets.some(isCatastrophicDeleteTarget)) return true;
         if (targets.some((target) => !pathLooksInsideProject(target, projectRoot))) return true;
@@ -68034,7 +69057,8 @@ function hasFindExec(command) {
 function isCatastrophicDeleteTarget(rawTarget) {
   const t2 = rawTarget.replace(/^['"]|['"]$/g, "").trim();
   if (!t2) return false;
-  if (t2 === "*" || t2 === "." || t2 === "./" || t2 === ".\\" || t2 === "./*" || t2 === ".\\*") return true;
+  if (t2 === "*" || t2 === "." || t2 === "./" || t2 === ".\\" || t2 === "./*" || t2 === ".\\*")
+    return true;
   const s = t2.replace(/[\\/]\*+$/, "").replace(/[\\/]+$/, "");
   if (s === "") return true;
   if (s === "~" || /^\$HOME$/i.test(s) || /^%USERPROFILE%$/i.test(s)) return true;
@@ -68074,12 +69098,16 @@ function hasCatastrophicDelete(command) {
       const args = tokens.slice(i + 1);
       const recursive = args.some((arg) => arg.toLowerCase() === "/s");
       if (!recursive) continue;
-      const targets = args.filter((arg) => !arg.startsWith("-") && !arg.startsWith("/") && !SHELL_OPERATORS.has(arg));
+      const targets = args.filter(
+        (arg) => !arg.startsWith("-") && !arg.startsWith("/") && !SHELL_OPERATORS.has(arg)
+      );
       if (targets.some(isCatastrophicDeleteTarget)) return true;
     }
     if (token === "del" || token === "erase") {
       const args = tokens.slice(i + 1);
-      const targets = args.filter((arg) => !arg.startsWith("-") && !arg.startsWith("/") && !SHELL_OPERATORS.has(arg));
+      const targets = args.filter(
+        (arg) => !arg.startsWith("-") && !arg.startsWith("/") && !SHELL_OPERATORS.has(arg)
+      );
       if (targets.some(isCatastrophicDeleteTarget)) return true;
     }
   }
@@ -68140,6 +69168,47 @@ function isClearlyDestructiveBashCommand(command, projectRoot) {
   if (HIGH_IMPACT_PATTERNS.some((pattern) => pattern.test(trimmed))) return true;
   return false;
 }
+var WELL_KNOWN_CREDENTIAL_ENV_VARS = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "OPENAI_API_KEY",
+  "AZURE_OPENAI_API_KEY",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "GROQ_API_KEY",
+  "MISTRAL_API_KEY",
+  "COHERE_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "XAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "PERPLEXITY_API_KEY",
+  "TOGETHER_API_KEY",
+  "FIREWORKS_API_KEY",
+  "HUGGINGFACE_API_KEY",
+  "HF_TOKEN",
+  "GITHUB_TOKEN",
+  "GH_TOKEN",
+  "NPM_TOKEN",
+  "AWS_ACCESS_KEY_ID",
+  "AWS_SECRET_ACCESS_KEY",
+  "AWS_SESSION_TOKEN",
+  "AZURE_CLIENT_SECRET",
+  "GITLAB_TOKEN",
+  "SLACK_TOKEN",
+  "STRIPE_SECRET_KEY",
+  "TELEGRAM_BOT_TOKEN",
+  "WRONGSTACK_VAULT_PASSPHRASE"
+]);
+function attachesWellKnownCredential(input) {
+  if (!input || typeof input !== "object") return false;
+  const envVars = input["envVars"];
+  if (!Array.isArray(envVars)) return false;
+  return envVars.some(
+    (name) => typeof name === "string" && WELL_KNOWN_CREDENTIAL_ENV_VARS.has(name.toUpperCase())
+  );
+}
 
 // src/security/permission-helpers.ts
 function matchesTrust(patterns, subject2) {
@@ -68156,7 +69225,7 @@ function hasShellSubject(tool) {
   ]);
 }
 function alwaysAllowUnavailableReason(tool, input) {
-  const subject2 = subjectForToolInput(tool.name, input, tool.subjectKey);
+  const subject2 = subjectForToolInput(tool.name, input, tool.subjectKey, tool.subjectFields);
   if (subject2 !== void 0) return void 0;
   return `"always allow" needs a subject to remember, and ${tool.name} calls do not carry one (no subjectKey, and no path/url/name input). Recording it would store a rule that can never match. Approve this call, or set a trust rule for ${tool.name} explicitly.`;
 }
@@ -68216,8 +69285,18 @@ var AGENT_STATE_SENSITIVE_BASENAMES = /^(?:config\.json|config\.local\.json|trus
 function unescapeGlobSubject(value) {
   return value.replace(/\\([*?[\]])/g, "$1");
 }
+function stripAdsSuffix(forwardSlashPath) {
+  const cut = forwardSlashPath.lastIndexOf("/");
+  const dir = cut === -1 ? "" : forwardSlashPath.slice(0, cut + 1);
+  const base = cut === -1 ? forwardSlashPath : forwardSlashPath.slice(cut + 1);
+  const colon = base.indexOf(":");
+  if (colon === -1 || cut === -1 && colon === 1 && base.length <= 2) return forwardSlashPath;
+  return dir + base.slice(0, colon);
+}
 function normalizeForCompare(value) {
-  const forward = unescapeGlobSubject(value).replace(/\\/g, "/").replace(/\/+$/, "");
+  const forward = stripAdsSuffix(
+    unescapeGlobSubject(value).replace(/\\/g, "/").replace(/\/+$/, "")
+  );
   return process.platform === "win32" ? forward.toLowerCase() : forward;
 }
 function realpathOfNearestExisting(p) {
@@ -68254,7 +69333,7 @@ function isProtectedAgentStatePath(absPath) {
   return AGENT_STATE_SENSITIVE_BASENAMES.test(path90.basename(normalizeForCompare(absPath)));
 }
 function pathLooksSensitive(rawPath) {
-  const normalized = stripShellQuotes(rawPath).replace(/\\/g, "/");
+  const normalized = stripAdsSuffix(stripShellQuotes(rawPath).replace(/\\/g, "/"));
   if (SENSITIVE_READ_PATHS.some((pattern) => pattern.test(normalized))) return true;
   return isProtectedAgentStatePath(normalized);
 }
@@ -68278,10 +69357,24 @@ function shellCommandReadsSensitivePath(command) {
   }
   return false;
 }
+function isSensitiveReadCall(tool, input) {
+  const isReadTool = hasCapability(tool, ToolCapabilities.FS_READ) || tool.name === "read" || tool.name === "grep" || tool.name === "glob" || tool.name === "tree";
+  if (isReadTool && inputPathLooksSensitive(input)) return true;
+  const hasShellCap = hasCapability(tool, [
+    ToolCapabilities.SHELL_ARBITRARY,
+    ToolCapabilities.SHELL_RESTRICTED,
+    ToolCapabilities.SHELL_EXEC
+  ]);
+  if (!hasShellCap && tool.name !== "bash" && tool.name !== "shell" && tool.name !== "exec") {
+    return false;
+  }
+  const command = shellCommandLineFromInput(input);
+  return command ? shellCommandReadsSensitivePath(command) : false;
+}
 
 // src/security/permission-explain.ts
 function explainPermissionTrace(state, tool, input, ctx) {
-  const subject2 = subjectForToolInput(tool.name, input, tool.subjectKey);
+  const subject2 = subjectForToolInput(tool.name, input, tool.subjectKey, tool.subjectFields);
   const steps = [];
   let winnerIndex = -1;
   const add = (rule, matched, decision, source, detail) => {
@@ -68502,13 +69595,7 @@ function explainPermissionTrace(state, tool, input, ctx) {
         }
       };
     }
-    add(
-      "yolo",
-      true,
-      "auto",
-      "yolo",
-      "YOLO mode is active \u2014 auto-approving every non-denied call"
-    );
+    add("yolo", true, "auto", "yolo", "YOLO mode is active \u2014 auto-approving every non-denied call");
     winnerIndex = steps.length - 1;
     return {
       toolName: tool.name,
@@ -68780,7 +69867,14 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
   static isMcpTool(name) {
     return name.startsWith("mcp__");
   }
-  async evaluate(tool) {
+  async evaluate(tool, input) {
+    if (input !== void 0 && isSensitiveReadCall(tool, input)) {
+      return {
+        permission: "deny",
+        source: "subagent_guard",
+        reason: "subagents may not read credential-bearing paths \u2014 the leader must perform this read so the user can approve it"
+      };
+    }
     const caps = tool.capabilities ?? [];
     const hasAllowedCap = caps.some((c) => this.allowedCapabilities.includes(c));
     const isMcp = _AutoApprovePermissionPolicy.isMcpTool(tool.name);
@@ -68807,8 +69901,8 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
   }
   allowOnce() {
   }
-  async explain(tool) {
-    const decision = await this.evaluate(tool);
+  async explain(tool, input) {
+    const decision = await this.evaluate(tool, input);
     return {
       toolName: tool.name,
       subject: null,
@@ -68858,6 +69952,17 @@ function fsWriteTargetPaths(input) {
   }
   return out;
 }
+function mergeTrustEntries(exact, wildcard) {
+  if (!exact) return wildcard;
+  if (!wildcard) return exact;
+  const deny = [...wildcard.deny ?? [], ...exact.deny ?? []];
+  const merged = {
+    ...wildcard,
+    ...exact
+  };
+  if (deny.length > 0) merged.deny = [...new Set(deny)];
+  return merged;
+}
 var DefaultPermissionPolicy = class {
   policy = {};
   loaded = false;
@@ -68896,6 +70001,7 @@ var DefaultPermissionPolicy = class {
   yoloBlockedAsDestructive(tool, input, ctx) {
     if (!this.yolo || this.yoloDestructive) return false;
     if (this.hasAgentStateWriteTarget(tool, input, ctx)) return true;
+    if (attachesWellKnownCredential(input)) return true;
     const isShellSurface = tool.name === "bash" || tool.name === "exec" || (tool.capabilities ?? []).includes("shell.arbitrary");
     if (!isShellSurface) return false;
     const command = getInputString(input, "command") ?? shellCommandLineFromInput(input);
@@ -68989,8 +70095,8 @@ var DefaultPermissionPolicy = class {
       };
     }
     const namespaceEntry = this.findNamespaceEntry(tool.name);
-    const entry = this.policy[tool.name] ?? namespaceEntry;
-    const subject2 = subjectForToolInput(tool.name, input, tool.subjectKey);
+    const entry = mergeTrustEntries(this.policy[tool.name], namespaceEntry);
+    const subject2 = subjectForToolInput(tool.name, input, tool.subjectKey, tool.subjectFields);
     const cacheKey = `${tool.name}::${subject2 ?? tool.name}`;
     const evalKey = `${cacheKey}::${permissionFingerprint(tool)}`;
     if (tool.name !== "write" && !this.hasAgentStateWriteTarget(tool, input, ctx)) {
@@ -69007,15 +70113,6 @@ var DefaultPermissionPolicy = class {
       this._evalCache.set(evalKey, decision);
       return decision;
     }
-    if (this.sessionAllowed.has(cacheKey)) {
-      this.sessionAllowed.delete(cacheKey);
-      const decision = {
-        permission: "auto",
-        source: "trust",
-        reason: "session one-shot allow (user pressed yes)"
-      };
-      return decision;
-    }
     if (entry?.deny && subject2 && matchesTrust(entry.deny, subject2)) {
       this._logDeny(tool.name, subject2, "matched deny pattern");
       const decision = {
@@ -69026,6 +70123,15 @@ var DefaultPermissionPolicy = class {
       this._evalCache.set(evalKey, decision);
       return decision;
     }
+    if (this.sessionAllowed.has(cacheKey)) {
+      this.sessionAllowed.delete(cacheKey);
+      const decision = {
+        permission: "auto",
+        source: "trust",
+        reason: "session one-shot allow (user pressed yes)"
+      };
+      return decision;
+    }
     if (tool.permission === "deny") {
       this._logDeny(tool.name, subject2, "tool default deny");
       const decision = {
@@ -69036,6 +70142,7 @@ var DefaultPermissionPolicy = class {
       this._evalCache.set(evalKey, decision);
       return decision;
     }
+    const denyUnevaluated = Boolean(entry?.deny?.length) && subject2 === void 0;
     const allowMatches = hasShellSubject(tool) ? matchesCommandTrust : matchesTrust;
     if (entry?.allow && subject2 && allowMatches(entry.allow, subject2)) {
       const decision = {
@@ -69046,7 +70153,7 @@ var DefaultPermissionPolicy = class {
       this._evalCache.set(evalKey, decision);
       return decision;
     }
-    if (entry?.auto) {
+    if (entry?.auto && !denyUnevaluated) {
       const decision = { permission: "auto", source: "trust" };
       this._evalCache.set(evalKey, decision);
       return decision;
@@ -69146,19 +70253,10 @@ var DefaultPermissionPolicy = class {
     }
     return { permission: "confirm", source: "default" };
   }
+  // Delegates to the shared helper so the subagent policy applies the exact
+  // same rule — see `isSensitiveReadCall` in ./permission-helpers.ts.
   isSensitiveReadCall(tool, input) {
-    const isReadTool = hasCapability(tool, ToolCapabilities.FS_READ) || tool.name === "read" || tool.name === "grep" || tool.name === "glob" || tool.name === "tree";
-    if (isReadTool && inputPathLooksSensitive(input)) return true;
-    const hasShellCap = hasCapability(tool, [
-      ToolCapabilities.SHELL_ARBITRARY,
-      ToolCapabilities.SHELL_RESTRICTED,
-      ToolCapabilities.SHELL_EXEC
-    ]);
-    if (!hasShellCap && tool.name !== "bash" && tool.name !== "shell" && tool.name !== "exec") {
-      return false;
-    }
-    const command = shellCommandLineFromInput(input);
-    return command ? shellCommandReadsSensitivePath(command) : false;
+    return isSensitiveReadCall(tool, input);
   }
   async trust(rule) {
     if (!this.loaded) await this.reload();
@@ -69507,7 +70605,7 @@ function deepFreeze(obj) {
 init_errors();
 init_atomic_write();
 init_error();
-import { randomUUID as randomUUID39 } from "node:crypto";
+import { randomUUID as randomUUID40 } from "node:crypto";
 import * as fsp38 from "node:fs/promises";
 function assertPlanMutationInvariants(previous, updated) {
   const ids = updated.items.map((item) => item.id);
@@ -69629,7 +70727,7 @@ function emptyPlan(sessionId, title) {
 function addPlanItem(plan, title, details) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const item = {
-    id: `plan_${Date.now()}_${randomUUID39().slice(0, 6)}`,
+    id: `plan_${Date.now()}_${randomUUID40().slice(0, 6)}`,
     title,
     details,
     status: "open",
@@ -69701,7 +70799,7 @@ function deriveTodosFromPlanItem(plan, idOrIndex, subtasks) {
   if (subtasks && subtasks.length > 0) {
     for (const st of subtasks) {
       todos.push({
-        id: `todo_${Date.now()}_${randomUUID39().slice(0, 6)}`,
+        id: `todo_${Date.now()}_${randomUUID40().slice(0, 6)}`,
         content: st,
         status: "pending",
         promotedFromPlan: item.id
@@ -73698,7 +74796,7 @@ function resolveReasoningForRequest(settings, rc, warnings) {
   const cfg = settings.reasoning;
   if (!cfg) return void 0;
   const capKnown = rc !== void 0;
-  const supportsReasoning = rc ? rc.default !== "disabled" || rc.disableSupported || rc.effortSupported : false;
+  const supportsReasoning = rc ? rc.default !== "disabled" || rc.disableSupported || rc.effortSupported !== false : false;
   const out = {};
   if (cfg.mode === "off") {
     if (capKnown && rc?.disableSupported) {
@@ -73720,14 +74818,17 @@ function resolveReasoningForRequest(settings, rc, warnings) {
   }
   const effort = cfg.effort;
   if (effort !== void 0) {
-    if (capKnown && rc?.effortSupported && rc.effortLevels.includes(effort)) {
-      out.effort = effort;
-    } else if (capKnown && rc?.effortSupported) {
+    if (!capKnown) {
+    } else if (rc?.effortSupported === false) {
+      warnings.push(
+        `reasoning effort "${effort}" requested, but this model does not support effort control; the setting was omitted.`
+      );
+    } else if (rc?.effortSupported === true && rc.effortLevels.length > 0 && !rc.effortLevels.includes(effort)) {
       warnings.push(
         `reasoning effort "${effort}" not supported by this model (supported: ${rc.effortLevels.join(", ")}); the setting was omitted.`
       );
-    } else if (capKnown) {
-      warnings.push(`reasoning effort "${effort}" requested, but this model does not support effort; the setting was omitted.`);
+    } else {
+      out.effort = effort;
     }
   }
   if (cfg.preserve !== void 0) {
@@ -78189,6 +79290,15 @@ function deriveSessionStatus(agents) {
     (a) => a.status === "running" || a.status === "streaming" || a.status === "waiting_user"
   ) ? "active" : "idle";
 }
+function downgradeStaleAgentStatuses(agents, nowMs) {
+  const cutoff = nowMs - HQ_STALE_SNAPSHOT_WINDOW_MS;
+  return agents.map((agent) => {
+    if (agent.status !== "running" && agent.status !== "streaming") return agent;
+    const lastActivityAt = Date.parse(agent.lastActivityAt);
+    if (!Number.isFinite(lastActivityAt) || lastActivityAt >= cutoff) return agent;
+    return { ...agent, status: "idle" };
+  });
+}
 function startSessionTelemetryBridge(opts) {
   const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const publisher = opts.publisher;
@@ -78209,6 +79319,7 @@ function startSessionTelemetryBridge(opts) {
   let lastPublishedAtMs = Date.now();
   let disposed = false;
   function buildSnapshot() {
+    const effectiveAgents = downgradeStaleAgentStatuses(agents, Date.parse(now()));
     return {
       sessionId: opts.sessionId,
       clientKind: identity2.kind,
@@ -78216,11 +79327,11 @@ function startSessionTelemetryBridge(opts) {
       projectId: project2.projectId,
       projectName: opts.projectName ?? project2.projectName,
       projectRoot: opts.projectRoot,
-      status: deriveSessionStatus(agents),
+      status: deriveSessionStatus(effectiveAgents),
       startedAt,
       lastActivityAt,
-      agentCount: agents.length,
-      agents,
+      agentCount: effectiveAgents.length,
+      agents: effectiveAgents,
       ...identity2.hostname !== void 0 ? { hostname: identity2.hostname } : {},
       ...identity2.pid !== void 0 ? { pid: identity2.pid } : {},
       ...opts.gitBranch !== void 0 ? { gitBranch: opts.gitBranch } : {}
@@ -81601,18 +82712,88 @@ var DefaultPluginAPI = class {
       list: () => tr.list()
     };
     const pr = init.providerRegistry;
+    const providerTypesIOwn = /* @__PURE__ */ new Set();
+    const assertCanMutateProvider = (type, op) => {
+      if (isOfficial) return;
+      if (providerTypesIOwn.has(type)) return;
+      if (!pr.has(type)) return;
+      throw new Error(
+        `Plugin "${owner}" may not ${op} provider "${type}" \u2014 it was not registered by this plugin. Replacing an existing provider would route prompts and credentials through plugin code.`
+      );
+    };
     this.providers = {
-      register: (f) => pr.register(f),
-      unregister: (type) => pr.unregister(type),
+      register: (f) => {
+        assertCanMutateProvider(f.type, "replace");
+        pr.register(f);
+        providerTypesIOwn.add(f.type);
+      },
+      unregister: (type) => {
+        assertCanMutateProvider(type, "unregister");
+        providerTypesIOwn.delete(type);
+        return pr.unregister(type);
+      },
       create: (cfg) => pr.create(cfg),
       list: () => pr.list()
     };
-    this.mcp = init.mcpRegistry ?? noopMcp;
+    const mcpRegistry = init.mcpRegistry;
+    if (!mcpRegistry) {
+      this.mcp = noopMcp;
+    } else {
+      const mcpServersIStarted = /* @__PURE__ */ new Set();
+      const assertOwnsMcpServer = (name, op) => {
+        if (isOfficial) return;
+        if (mcpServersIStarted.has(name)) return;
+        if (!mcpRegistry.list().some((s) => s.name === name)) return;
+        throw new Error(
+          `Plugin "${owner}" may not ${op} MCP server "${name}" \u2014 it was not started by this plugin.`
+        );
+      };
+      this.mcp = {
+        start: async (cfg) => {
+          const name = cfg?.name;
+          if (typeof name === "string" && mcpRegistry.list().some((s) => s.name === name)) {
+            assertOwnsMcpServer(name, "start");
+          }
+          await mcpRegistry.start(cfg);
+          if (typeof name === "string") mcpServersIStarted.add(name);
+        },
+        stop: async (name) => {
+          assertOwnsMcpServer(name, "stop");
+          await mcpRegistry.stop(name);
+        },
+        restart: async (name) => {
+          assertOwnsMcpServer(name, "restart");
+          await mcpRegistry.restart(name);
+        },
+        list: () => mcpRegistry.list()
+      };
+    }
     const scr = init.slashCommandRegistry;
     const official = init.official === true;
+    const commandsIOwn = /* @__PURE__ */ new Set();
     this.slashCommands = scr ? {
-      register: (cmd) => scr.register(cmd, owner, { official }),
-      unregister: (name) => scr.unregister(name),
+      register: (cmd) => {
+        scr.register(cmd, owner, { official });
+        for (const key of [cmd.name, ...cmd.aliases ?? []]) {
+          commandsIOwn.add(key);
+          commandsIOwn.add(`${owner}:${key}`);
+        }
+      },
+      unregister: (name) => {
+        if (!official && !commandsIOwn.has(name) && scr.get(name) !== void 0) {
+          throw new Error(
+            `Plugin "${owner}" may not unregister slash command "${name}" \u2014 it was not registered by this plugin.`
+          );
+        }
+        for (const key of [
+          name,
+          `${owner}:${name}`,
+          name.startsWith(`${owner}:`) ? name.slice(owner.length + 1) : name
+        ]) {
+          commandsIOwn.delete(key);
+        }
+        return scr.unregister(name);
+      },
       get: (name) => scr.get(name),
       list: () => scr.list()
     } : noopSlashCommands;
@@ -82152,7 +83333,7 @@ async function snapshotChangedFiles(cwd) {
 }
 
 // src/plugins/review-claim-registry.ts
-import { createHash as createHash33, randomUUID as randomUUID40 } from "node:crypto";
+import { createHash as createHash33, randomUUID as randomUUID41 } from "node:crypto";
 import * as fsp46 from "node:fs/promises";
 import { hostname as hostname5 } from "node:os";
 import * as path103 from "node:path";
@@ -82215,7 +83396,7 @@ async function breakStaleLock(lockPath) {
   return false;
 }
 async function breakLockAtomically(lockPath) {
-  const tombstone = `${lockPath}.stale-${randomUUID40()}.tmp`;
+  const tombstone = `${lockPath}.stale-${randomUUID41()}.tmp`;
   try {
     await fsp46.rename(lockPath, tombstone);
   } catch {
@@ -82275,7 +83456,7 @@ async function withStoreLock(storeDir, fn, waitMs = LOCK_WAIT_MS) {
   }
 }
 var MAX_LEDGER_LINES = 1e4;
-var HOST_SID = randomUUID40();
+var HOST_SID = randomUUID41();
 var claimsByEventBus = /* @__PURE__ */ new WeakMap();
 var startedReviews = /* @__PURE__ */ new WeakMap();
 var pendingStartedReviews = /* @__PURE__ */ new WeakMap();
@@ -82356,7 +83537,7 @@ async function compactLedger(storeDir, active) {
       );
     }
   }
-  const tmp = `${claimsFilePath(storeDir)}.tmp-${randomUUID40()}`;
+  const tmp = `${claimsFilePath(storeDir)}.tmp-${randomUUID41()}`;
   await fsp46.writeFile(tmp, lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf8");
   let replaced = false;
@@ -83285,7 +84466,7 @@ init_review_finding_store();
 
 // src/plugins/review-finding-parser.ts
 init_review_finding_types();
-import { randomUUID as randomUUID42 } from "node:crypto";
+import { randomUUID as randomUUID43 } from "node:crypto";
 var SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low"]);
 var CATEGORIES = /* @__PURE__ */ new Set([
   "bug",
@@ -83357,7 +84538,7 @@ function parseChimeraReviewReport(reportText, context = {}) {
   }
   const structured = extractStructuredFindingsBlock(reportText);
   if (structured) {
-    const reportId2 = context.reportId ?? randomUUID42();
+    const reportId2 = context.reportId ?? randomUUID43();
     const findings2 = structured.findings.map(
       (item) => buildFindingFromStructuredItem(item, { ...context, reportId: reportId2 })
     );
@@ -83369,7 +84550,7 @@ function parseChimeraReviewReport(reportText, context = {}) {
     };
   }
   const findings = [];
-  const reportId = context.reportId ?? randomUUID42();
+  const reportId = context.reportId ?? randomUUID43();
   let unparseableCount = 0;
   let durationSeconds;
   let currentSeverity = null;
@@ -83470,7 +84651,7 @@ function parseFindingSegment(segment, severity, context) {
   const fullDesc = suggestions.length > 0 ? cleanDesc + "\n" + suggestions.map((s) => "  \u2192 " + s).join("\n") : cleanDesc;
   const suggestedFix = suggestions.length > 0 ? suggestions.join("\n") : void 0;
   return {
-    id: randomUUID42(),
+    id: randomUUID43(),
     fingerprint: computeFindingFingerprint(file ?? "", line ?? null, title),
     severity,
     source: normalizeFindingSource(context.reviewType),
@@ -83481,7 +84662,7 @@ function parseFindingSegment(segment, severity, context) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     status: "active",
     originReport: {
-      reportId: context.reportId ?? randomUUID42(),
+      reportId: context.reportId ?? randomUUID43(),
       sessionId: context.sessionId ?? "",
       agentId: context.agentId ?? "",
       reviewerModel: context.reviewerModel ?? ""
@@ -83505,7 +84686,7 @@ function buildFindingFromStructuredItem(item, context) {
   const title = item.title;
   const description = item.description ?? title;
   return {
-    id: randomUUID42(),
+    id: randomUUID43(),
     fingerprint: computeFindingFingerprint(file ?? "", line ?? null, title),
     severity: item.severity,
     source: normalizeFindingSource(context.reviewType),
@@ -83518,7 +84699,7 @@ function buildFindingFromStructuredItem(item, context) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     status: "active",
     originReport: {
-      reportId: context.reportId ?? randomUUID42(),
+      reportId: context.reportId ?? randomUUID43(),
       sessionId: context.sessionId ?? "",
       agentId: context.agentId ?? "",
       reviewerModel: context.reviewerModel ?? ""
@@ -86217,14 +87398,21 @@ async function openInEditor(filePath, env = process.env) {
       context: { filePath }
     });
   }
-  const child = spawn12(parts[0], [...parts.slice(1), filePath], {
+  const editorArgs = [...parts.slice(1), filePath];
+  const child = shell ? (() => {
+    const inv = buildWin32CmdShimInvocation(parts[0], editorArgs);
+    return spawn12(inv.command, inv.args, {
+      stdio: "ignore",
+      detached: true,
+      windowsVerbatimArguments: inv.windowsVerbatimArguments,
+      // Suppresses the console flash the cmd.exe wrapper would otherwise
+      // show before the editor appears. Repo convention — see
+      // `core/tests/architecture/spawn-convention.test.ts`.
+      windowsHide: true
+    });
+  })() : spawn12(parts[0], editorArgs, {
     stdio: "ignore",
     detached: true,
-    shell,
-    // `shell` routes through cmd.exe on win32, which flashes a console window
-    // before the editor appears. A GUI editor is unaffected by the flag; the
-    // shell wrapper is what it suppresses. Repo convention — see
-    // `core/tests/architecture/spawn-convention.test.ts`.
     windowsHide: true
   });
   child.unref();
@@ -89169,7 +90357,7 @@ var ReplayProviderRunner = class {
 };
 
 // src/session-catalog/store.ts
-import { randomBytes as randomBytes8, randomUUID as randomUUID43 } from "node:crypto";
+import { randomBytes as randomBytes8, randomUUID as randomUUID44 } from "node:crypto";
 import * as fs59 from "node:fs";
 import * as path119 from "node:path";
 init_atomic_write();
@@ -89520,7 +90708,7 @@ var SessionCatalogStore = class {
     if (!Number.isSafeInteger(entry.pid) || entry.pid <= 0)
       throw new TypeError("Invalid owner pid");
     const now = Date.now();
-    const leaseId = randomUUID43();
+    const leaseId = randomUUID44();
     const leaseSecret = randomBytes8(32).toString("hex");
     const expiresAt = now + boundedMs(leaseMs, SESSION_CATALOG_DEFAULT_LEASE_MS, MAX_LEASE_MS);
     this.db.prepare(`INSERT INTO session_leases(
@@ -89592,7 +90780,7 @@ var SessionCatalogStore = class {
       const catalog = this.db.prepare("SELECT 1 AS yes FROM sessions WHERE session_id=?").get(targetSessionId);
       if (!catalog && !fs59.existsSync(this.containedPath(`${targetSessionId}.jsonl`)))
         throw new Error(`Session not found: ${targetSessionId}`);
-      const reservationId = randomUUID43();
+      const reservationId = randomUUID44();
       const now = Date.now();
       const expiresAt = now + boundedMs(reservationMs, SESSION_CATALOG_DEFAULT_RESERVATION_MS, MAX_RESERVATION_MS);
       try {
@@ -89888,7 +91076,7 @@ var SessionCatalogStore = class {
         "SELECT 1 AS yes FROM resume_reservations WHERE target_session_id=? AND expires_at>?"
       ).get(sessionId, Date.now());
       if (reservation) throw conflict(`Session ${sessionId} is reserved for resume`);
-      const leaseId = randomUUID43();
+      const leaseId = randomUUID44();
       const now = Date.now();
       const expiresAt = now + boundedMs(leaseMs, 6e4, MAX_MAINTENANCE_MS);
       try {
@@ -90846,7 +92034,7 @@ import * as fs62 from "node:fs/promises";
 import * as path122 from "node:path";
 
 // src/session-registry-atomic-file.ts
-import { randomUUID as randomUUID44 } from "node:crypto";
+import { randomUUID as randomUUID45 } from "node:crypto";
 import * as fs61 from "node:fs/promises";
 import { hostname as hostname6 } from "node:os";
 import * as path121 from "node:path";
@@ -90919,7 +92107,7 @@ async function breakStaleLockVerified2(lockPath, verify) {
   return await breakLockAtomically2(lockPath) === true;
 }
 async function breakLockAtomically2(lockPath) {
-  const tombstone = `${lockPath}.stale-${randomUUID44()}.tmp`;
+  const tombstone = `${lockPath}.stale-${randomUUID45()}.tmp`;
   try {
     await fs61.rename(lockPath, tombstone);
   } catch {
@@ -90931,7 +92119,7 @@ async function breakLockAtomically2(lockPath) {
 async function writeAtomicFile(filePath, registry2) {
   const tmp = path121.join(
     path121.dirname(filePath),
-    `.${path121.basename(filePath)}.${randomUUID44().slice(0, 8)}.tmp`
+    `.${path121.basename(filePath)}.${randomUUID45().slice(0, 8)}.tmp`
   );
   let tmpPersisted = false;
   try {
@@ -91494,7 +92682,7 @@ var SessionRegistry = class {
 init_errors();
 init_atomic_write();
 init_error();
-import { randomUUID as randomUUID45 } from "node:crypto";
+import { randomUUID as randomUUID46 } from "node:crypto";
 import * as fs63 from "node:fs/promises";
 var FILE_VERSION = 1;
 var MAX_TEXT_LENGTH = 2e3;
@@ -91592,7 +92780,7 @@ var AnnotationsStore = class {
       });
     }
     const annotation = {
-      id: randomUUID45(),
+      id: randomUUID46(),
       sessionId: input.sessionId,
       atEventIndex: input.atEventIndex,
       authorId: input.authorId,
@@ -91945,7 +93133,7 @@ var InputHistoryStore = class {
 
 // src/storage/memory-backend.ts
 init_file_permissions();
-import { randomUUID as randomUUID46 } from "node:crypto";
+import { randomUUID as randomUUID47 } from "node:crypto";
 import * as fs65 from "node:fs/promises";
 import * as path124 from "node:path";
 
@@ -92173,7 +93361,7 @@ var FileMemoryBackend = class {
   }
   async remember(scope, entry, filePath) {
     const file = this.resolveFile(filePath, scope);
-    const id = `mem_${Date.now()}_${randomUUID46().slice(0, 8)}`;
+    const id = `mem_${Date.now()}_${randomUUID47().slice(0, 8)}`;
     const meta = formatMetadata(entry);
     const line = `- [${entry.ts}] ${id}${meta} ${entry.text.replace(/\n/g, " ")}
 `;
@@ -94187,7 +95375,7 @@ async function mutateTasks(filePath, sessionId, fn, events, traceId) {
 init_file_permissions();
 init_atomic_write();
 init_error();
-import { createHash as createHash39, randomUUID as randomUUID47 } from "node:crypto";
+import { createHash as createHash39, randomUUID as randomUUID48 } from "node:crypto";
 import * as fs70 from "node:fs/promises";
 var GENESIS_PREV = "0".repeat(64);
 var DEFAULT_FSYNC_EVERY = 100;
@@ -94232,7 +95420,7 @@ var ToolAuditLog = class {
           const tip = await this._resolveChainTip(input.sessionId, fp);
           const prevHash = tip.prevHash;
           const index = tip.nextIndex;
-          const id = randomUUID47();
+          const id = randomUUID48();
           const ts = (/* @__PURE__ */ new Date()).toISOString();
           const content = {
             id,
@@ -96773,7 +97961,7 @@ var DEFAULT_SPEC_TEMPLATE = {
 // src/worktree/worktree-manager.ts
 init_error();
 import { mkdir as mkdir35, readFile as readFile73 } from "node:fs/promises";
-import { join as join102, resolve as resolve56, sep as sep9 } from "node:path";
+import { join as join103, resolve as resolve56, sep as sep9 } from "node:path";
 
 // src/worktree/worktree-git.ts
 import { spawn as spawn13 } from "node:child_process";
@@ -97005,7 +98193,7 @@ var WorktreeManager = class {
     }
     const slug = this.makeSlug(opts.slugHint ?? ownerId);
     const branch = `wstack/ap/${slug}`;
-    const dir = join102(this.worktreesRoot(), slug);
+    const dir = join103(this.worktreesRoot(), slug);
     const absDir = resolve56(dir);
     const absRoot = resolve56(this.projectRoot);
     if (!absDir.startsWith(absRoot + sep9)) {
@@ -97396,7 +98584,7 @@ ${merged.stderr}`);
     const startMarker = /^(?:<{7,}(?: |$)|\|{7,}(?: |$))/m;
     for (const rel of paths) {
       try {
-        const content = (await readFile73(join102(this.projectRoot, rel), "utf8")).replace(/\r/g, "");
+        const content = (await readFile73(join103(this.projectRoot, rel), "utf8")).replace(/\r/g, "");
         const lines = content.split("\n");
         let seenStart = false;
         for (const line of lines) {
@@ -97440,7 +98628,7 @@ ${merged.stderr}`);
   }
   // ── internals ────────────────────────────────────────────────────────────
   worktreesRoot() {
-    return join102(this.projectRoot, ".wrongstack", "worktrees");
+    return join103(this.projectRoot, ".wrongstack", "worktrees");
   }
   async detectBaseBranch() {
     const head = await this.runGit(["rev-parse", "--abbrev-ref", "HEAD"], this.projectRoot);
@@ -97858,6 +99046,7 @@ export {
   QUEUE_MAX_ITEMS,
   QUEUE_MAX_ITEM_BYTES,
   QueueStore,
+  REASONING_EFFORT_LEVELS,
   REFACTOR_PLANNER_AGENT,
   REPORT_STORE_FILE,
   REVIEW_AGENTS,
@@ -98321,6 +99510,7 @@ export {
   isPrivateIPv6,
   isProjectId,
   isProvenDirective,
+  isReasoningEffort,
   isRetryableKind,
   isSafePathSegment,
   isSddError,
@@ -98395,6 +99585,7 @@ export {
   makeMailInboxTool,
   makeMailSendTool,
   makeMailboxTool,
+  makeMutationTestTool,
   makeQualityGateTool,
   makeRollUpTool,
   makeSpawnTool,
@@ -98609,6 +99800,8 @@ export {
   sanitizeModel,
   sanitizeNodeOptions,
   sanitizeRequest,
+  sanitizeTerminalPreview,
+  sanitizeTerminalText,
   sanitizeWireToolName,
   saveCompletedWorkCheckpoint,
   saveGoal,