@wrongstack/core 0.309.0 → 0.309.1

package/dist/coordination/index.js

@@ -8599,6 +8599,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" },
@@ -8689,8 +8697,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",
@@ -8807,6 +8815,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(text, chunkStart, proposedEnd) {
+  const head = text.slice(chunkStart, proposedEnd);
+  const lastBegin = head.lastIndexOf("-----BEGIN ");
+  if (lastBegin === -1) return proposedEnd;
+  const fromBegin = text.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(text.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 ? text.length : chunkStart + lastBegin + lineEnd + 1;
+  return Math.max(proposedEnd, end);
+}
 var PATTERN_ANCHORS = [
   ...new Set(
     PATTERNS.flatMap(
@@ -8843,6 +8872,7 @@ var DefaultSecretScrubber = class {
           }
         }
         end = safe === -1 ? end : safe + 1;
+        end = extendChunkBoundaryPastPem(text, i, end);
       }
       out.push(this.scrubOne(text.slice(i, end)));
       i = end;
@@ -10547,11 +10577,13 @@ var CHAOS_MONKEY_AGENT = {
   tools: [...TOOLS.build],
   skillNames: ["testing", "typescript-strict"],
   spawnBudgetExempt: true,
-  // Follow fleet worktree policy (NOT 'required'): mutation targets are
-  // often freshly written and uncommitted — a worktree spawned from HEAD
-  // would not contain them and every mutant would drift. Callers pass
-  // `worktree: 'off'` in the mutation_test input for uncommitted targets.
-  worktree: "auto",
+  // 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"
@@ -11726,16 +11758,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);
         })
       );
@@ -11743,8 +11773,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);
         })
       );
@@ -11857,9 +11886,18 @@ 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: randomUUID6(),
@@ -14384,24 +14422,29 @@ var TOKEN_PATTERNS = [
     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;"
+    replace: () => "return null;",
+    endpointsInCode: true
   }
 ];
 function planMutations(file, source, opts = {}) {
   const maxPerFile = opts.maxPerFile ?? 25;
   const out = [];
   const lines = source.split("\n");
+  const masks = computeLineMasks(source);
   for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
     const line = lines[lineIdx];
     const t = line.trim();
-    if (t.startsWith("//") || t.startsWith("*") || t.startsWith("/*")) continue;
+    if (t.startsWith("//")) continue;
+    const codeRanges = masks[lineIdx];
+    const inCode = (start) => codeRanges.some(([s, e]) => start >= s && start < e);
     for (const pattern of TOKEN_PATTERNS) {
       pattern.regex.lastIndex = 0;
       let m;
       while ((m = pattern.regex.exec(line)) !== null) {
         const token = m.groups?.["op"] ?? m[0];
         const tokenStart = m.index + m[0].indexOf(token);
-        if (isMasked(line, tokenStart, token.length)) continue;
+        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;
@@ -14420,19 +14463,179 @@ function planMutations(file, source, opts = {}) {
   }
   return out.slice(0, maxPerFile);
 }
-function isMasked(line, start, len) {
-  let inSingle = false;
-  let inDouble = false;
-  for (let i = 0; i < start; i++) {
-    const c = line[i];
-    const prev = i > 0 ? line[i - 1] : void 0;
-    if (c === "'" && prev !== "\\") inSingle = !inSingle;
-    else if (c === '"' && prev !== "\\") inDouble = !inDouble;
-    if (!inSingle && !inDouble && c === "/" && prev === "/") return true;
+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++;
   }
-  if (inSingle || inDouble) return true;
-  const window = line.slice(start, start + len);
-  return /['"]/.test(window);
+  while (i < line.length && /[a-z]/.test(line[i])) i++;
+  return i;
 }
 function parseMutationReport(text) {
   const candidates = [];
@@ -14483,7 +14686,7 @@ function normalizeMutantEntry(value) {
   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") {
+  if (!id || status !== "killed" && status !== "survived" && status !== "skipped" && status !== "killed-by-hang") {
     return void 0;
   }
   return {
@@ -14539,7 +14742,7 @@ function makeMutationTestTool(director, roster, opts = {}) {
         },
         chaosWorktree: {
           anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
-          description: "Worktree override for the chaos agent. Use 'off' when targets are uncommitted \u2014 a worktree from HEAD would not contain them."
+          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: {
@@ -14561,8 +14764,16 @@ function makeMutationTestTool(director, roster, opts = {}) {
           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(roster, i.chaosWorktree ?? "off")
+        makeChaosConfig(chaosBase, i.chaosWorktree ?? chaosBase.worktree ?? "off")
       );
       const chaosTaskId = await director.assign({
         id: randomUUID11(),
@@ -14580,6 +14791,7 @@ function makeMutationTestTool(director, roster, opts = {}) {
       );
       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({
@@ -14601,7 +14813,7 @@ function makeMutationTestTool(director, roster, opts = {}) {
         }
         const survivorPlan = plan.filter((p) => current.some((s) => s.id === p.id));
         const rerunSubagentId = await director.spawn(
-          makeChaosConfig(roster, i.chaosWorktree ?? "off")
+          makeChaosConfig(chaosBase, i.chaosWorktree ?? chaosBase.worktree ?? "off")
         );
         const rerunTaskId = await director.assign({
           id: randomUUID11(),
@@ -14611,29 +14823,36 @@ function makeMutationTestTool(director, roster, opts = {}) {
         });
         const [rerunResult] = await director.awaitTasks([rerunTaskId]);
         const passN = collectOutcomes(rerunResult, survivorPlan);
-        const stillSurviving = passN.filter((m) => m.status === "survived" || m.status === "skipped");
+        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) => current.some((c) => c.id === m.id)).map((m) => m.id)
+          suspectedEquivalent: stillSurviving.filter((m) => m.status === "survived" && current.some((c) => c.id === m.id)).map((m) => m.id)
         });
-        current = stillSurviving.filter((m) => m.status === "survived");
-        if (passN.every((m) => m.status === "skipped")) break;
+        current = stillSurviving;
       }
-      const finalSurvivors = current;
+      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 score = plan.length === 0 ? 0 : pass1.filter((m) => m.status === "killed").length / plan.length;
-      const verdict = verifiedCount === 0 ? "inconclusive" : finalSurvivors.length === 0 ? skippedCount > 0 ? "partial" : "pass" : score >= 0.8 ? "partial" : "fail";
+      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) => m.status === "killed").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 })),
@@ -14641,7 +14860,11 @@ function makeMutationTestTool(director, roster, opts = {}) {
         strengthenAttempts: attempts.length,
         attempts,
         chaosTaskId,
-        nextAction: finalSurvivors.length === 0 ? "accept" : attempts.length >= maxAttempts && i.repairSubagentId ? "manual_review_survivors" : "strengthen_tests"
+        // 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"
       };
     }
   };
@@ -14657,7 +14880,7 @@ function normalizeMutationTestInput(input) {
     maxPerFile: typeof raw["maxPerFile"] === "number" ? raw["maxPerFile"] : void 0,
     maxStrengthenAttempts: typeof raw["maxStrengthenAttempts"] === "number" ? raw["maxStrengthenAttempts"] : void 0,
     repairSubagentId: typeof raw["repairSubagentId"] === "string" && raw["repairSubagentId"].trim() ? raw["repairSubagentId"].trim() : void 0,
-    chaosWorktree: raw["chaosWorktree"] ?? void 0,
+    chaosWorktree: normalizeWorktreeOverride(raw["chaosWorktree"]),
     timeoutMs: typeof raw["timeoutMs"] === "number" ? raw["timeoutMs"] : void 0,
     reportOnly: raw["reportOnly"] === true
   };
@@ -14679,8 +14902,7 @@ function buildPlan(i, projectRoot) {
   }
   return plan;
 }
-function makeChaosConfig(roster, worktree) {
-  const base = roster?.[CHAOS_ROLE] ?? getAgentDefinition(CHAOS_ROLE)?.config ?? { name: "Chaos Monkey", role: CHAOS_ROLE };
+function makeChaosConfig(base, worktree) {
   return { ...instantiateRosterConfig2(CHAOS_ROLE, base), worktree };
 }
 function buildChaosTask(plan, i, pass, priorSurvivors) {
@@ -14696,7 +14918,7 @@ ${priorSurvivors.map((s) => `- ${s.id} (${s.kind} @ ${s.file}:${s.line})`).join(
     "For each mutant, in order:",
     "1. Apply ONLY that mutation at its exact (file, line, column).",
     `2. Run the test command: ${i.testCommand}${i.cwd ? ` (cwd: ${i.cwd})` : ""}`,
-    "3. Record killed (tests failed \u2014 quote first failing assertion) or survived (suite green).",
+    "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:",
@@ -14708,23 +14930,49 @@ ${priorSurvivors.map((s) => `- ${s.id} (${s.kind} @ ${s.file}:${s.line})`).join(
   ].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 these SURVIVING mutants die (attempt ${attempt}).`,
-    "",
-    "Each survivor below was a deliberate sabotage of production code that the current suite did NOT catch:",
-    ...survivors.map((s) => `- ${s.id} | ${s.file}:${s.line} | ${s.kind}${s.evidence ? ` | ${s.evidence}` : ""}`),
+    `Strengthen the tests so the mutants below die (attempt ${attempt}).`,
     "",
-    `Test command that must fail under each mutant: ${i.testCommand}`,
+    ...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 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."
+    "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 planned = new Set(plan.map((p) => p.id));
-    const matched = fromText.filter((m) => planned.has(m.id));
-    if (matched.length > 0) return matched;
+    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,
@@ -14735,6 +14983,9 @@ function collectOutcomes(result, plan) {
     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 text = typeof result?.result === "string" ? result.result : void 0;
   if (!text) return [];
@@ -22612,6 +22863,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) {
@@ -22677,6 +22929,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;
@@ -22833,7 +23092,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;
@@ -22898,7 +23163,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) {
@@ -22984,6 +23249,7 @@ var Director = class _Director {
     this.resolveSpawnModel(config);
     const subagentId = await spawn4(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;
   }
@@ -23037,6 +23303,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()) {
@@ -23095,6 +23362,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(),
@@ -23147,9 +23415,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(

package/dist/coordination/mutation-engine.d.ts

@@ -45,8 +45,10 @@ export interface PlanMutationsOptions {
  * Plan mutations for one file's source text.
  *
  * The scan is line-by-line with the file's own line splits preserved so ids
- * stay (line, column) anchored. Mutations inside comments and string
- * literals are filtered out by `isMasked` below.
+ * stay (line, column) anchored. Mutations inside comments, string literals,
+ * and template literals (single- or multi-line, interpolation contents
+ * excepted) are filtered out by the cross-line scanner `computeLineMasks`
+ * below.
  */
 export declare function planMutations(file: string, source: string, opts?: PlanMutationsOptions): MutationPlanItem[];
 /**
@@ -66,7 +68,7 @@ export declare function parseMutationReport(text: string): {
         file: string;
         line: number;
         kind: string;
-        status: 'killed' | 'survived' | 'skipped';
+        status: 'killed' | 'survived' | 'skipped' | 'killed-by-hang';
         evidence?: string | undefined;
     }>;
     summary?: string | undefined;