@wrongstack/core 0.303.0 → 0.305.1

package/dist/coordination/index.js

@@ -1264,8 +1264,8 @@ function defaultFormatTaskInput(task) {
 }
 
 // src/coordination/agents/agent-prompts.ts
-import { readFileSync as readFileSync9, statSync as statSync2 } from "node:fs";
-import * as path10 from "node:path";
+import { readFileSync as readFileSync10, statSync as statSync2 } from "node:fs";
+import * as path12 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/utils/wstack-paths.ts
@@ -1408,8 +1408,8 @@ function resolveWstackPaths(opts) {
 }
 
 // src/coordination/agents/project-agent-identity.ts
-import { existsSync as existsSync4, readFileSync as readFileSync8 } from "node:fs";
-import * as path9 from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync9 } from "node:fs";
+import * as path11 from "node:path";
 
 // src/types/runtime-capability-manifest.ts
 var PLAYWRIGHT_ALIASES = {
@@ -1901,8 +1901,8 @@ function loadProjectAgentConfig(role, projectRoot) {
 }
 
 // src/coordination/agents/project-agent-consolidation.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2 } from "node:fs";
-import * as path5 from "node:path";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync as rmSync2 } from "node:fs";
+import * as path6 from "node:path";
 
 // src/coordination/agents/project-agent-learning-entries.ts
 function tokenOverlap(a, b) {
@@ -2040,6 +2040,21 @@ function normalizeForComparison(text) {
 }
 
 // src/coordination/agents/project-agent-learning-structured.ts
+function directiveTrials(entry) {
+  const count = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : 0;
+  const applied = count(entry.applied);
+  const wins = Math.min(applied, count(entry.wins));
+  return { applied, wins, losses: applied - wins };
+}
+function directiveUtility(entry) {
+  const { applied, wins } = directiveTrials(entry);
+  return (wins + 1) / (applied + 2);
+}
+var DIRECTIVE_PROVEN_MIN_APPLIED = 5;
+var DIRECTIVE_PROVEN_MIN_UTILITY = 0.7;
+function isProvenDirective(entry) {
+  return directiveTrials(entry).applied >= DIRECTIVE_PROVEN_MIN_APPLIED && directiveUtility(entry) >= DIRECTIVE_PROVEN_MIN_UTILITY;
+}
 function parseLearnedEntryStamp(entry) {
   const structuredMatch = entry.match(
     /<!--\s*learned-stamp:\s*category=([\w-]+);\s*capturedAt=([^;]+?)\s*-->/
@@ -2158,6 +2173,10 @@ function parseStructuredLearnedEntriesFromContent(raw, legacyEntries = splitLear
     const category = parseLearnedCategory(attributes["category"]) ?? "fact";
     const capturedAt = attributes["capturedAt"] ?? "";
     const skill = attributes["skill"];
+    const trials = directiveTrials({
+      applied: Number(attributes["applied"]),
+      wins: Number(attributes["wins"])
+    });
     const start = (stamp.index ?? 0) + stamp[0].length;
     const end = stamps[index + 1]?.index ?? raw.length;
     const parsed = parseEntryBody(raw.slice(start, end));
@@ -2169,7 +2188,8 @@ function parseStructuredLearnedEntriesFromContent(raw, legacyEntries = splitLear
       why: parsed.why || WHY_BY_CATEGORY[category],
       how: parsed.how,
       capturedAt,
-      ...skill ? { skill } : {}
+      ...skill ? { skill } : {},
+      ...trials.applied > 0 ? { applied: trials.applied, wins: trials.wins } : {}
     });
   }
   if (structured.length === 0) {
@@ -2193,17 +2213,31 @@ function parseStructuredLearnedEntriesFromContent(raw, legacyEntries = splitLear
 }
 function mergeStructuredEntries(existing, fresh) {
   const { what, why, how } = decomposeLearnedEntry(fresh.text, fresh.category);
+  const key = directiveKey(fresh.text);
+  const overlapping = existing.filter((entry) => tokenOverlap(entry.key, key) >= 0.55);
+  const proven = overlapping.find(
+    (entry) => entry.category === fresh.category && isProvenDirective(entry)
+  );
+  if (proven) return sortStructuredEntries([...existing]);
+  const ancestor = overlapping.filter((entry) => entry.category === fresh.category).sort((a, b) => directiveTrials(b).applied - directiveTrials(a).applied)[0];
+  const inherited = ancestor ? directiveTrials(ancestor) : { applied: 0, wins: 0 };
   const freshEntry = {
-    key: directiveKey(fresh.text),
+    key,
     category: fresh.category,
     what,
     why,
     how,
     capturedAt: fresh.capturedAt,
-    ...fresh.skill ? { skill: fresh.skill } : {}
+    ...fresh.skill ? { skill: fresh.skill } : {},
+    ...inherited.applied > 0 ? { applied: inherited.applied, wins: inherited.wins } : {}
   };
-  const merged = existing.filter((entry) => tokenOverlap(entry.key, freshEntry.key) < 0.55);
+  const merged = existing.filter(
+    (entry) => entry.category !== fresh.category || tokenOverlap(entry.key, key) < 0.55
+  );
   merged.push(freshEntry);
+  return sortStructuredEntries(merged);
+}
+function sortStructuredEntries(merged) {
   const order = {
     warning: 0,
     convention: 1,
@@ -2253,10 +2287,15 @@ function renderLearnedInstructions(role, entries, capturedAt) {
     sections.push(SECTION_TITLE[category]);
     sections.push("");
     for (const entry of list) {
+      const trials = directiveTrials(entry);
       const attributes = [
         `category=${entry.category}`,
         `capturedAt=${entry.capturedAt}`,
-        ...entry.skill ? [`skill=${entry.skill}`] : []
+        ...entry.skill ? [`skill=${entry.skill}`] : [],
+        // Zero counters are omitted so an entry with no track record renders
+        // exactly as it did before this field existed — the parse→render
+        // fixed point holds for every pre-existing buffer on disk.
+        ...trials.applied > 0 ? [`applied=${trials.applied}`, `wins=${trials.wins}`] : []
       ].join("; ");
       sections.push(`<!-- learned-stamp: ${attributes} -->`);
       sections.push(`- **${entry.what}**`);
@@ -2280,26 +2319,155 @@ function enforceLearnedBudget(entries, capturedAt, maxBytes, role = "agent") {
   const kept = [...entries];
   const dropped = [];
   const size = (list) => Buffer.byteLength(renderLearnedInstructions(role, list, capturedAt), "utf8");
+  const UTILITY_EPSILON = 1e-9;
   while (kept.length > 1 && size(kept) > maxBytes) {
     let victimIndex = 0;
     for (let i = 1; i < kept.length; i++) {
       const a = kept[i];
       const b = kept[victimIndex];
       const byPriority = DROP_PRIORITY[a.category] - DROP_PRIORITY[b.category];
-      if (byPriority < 0 || byPriority === 0 && a.capturedAt < b.capturedAt) victimIndex = i;
+      if (byPriority !== 0) {
+        if (byPriority < 0) victimIndex = i;
+        continue;
+      }
+      const byUtility = directiveUtility(a) - directiveUtility(b);
+      if (Math.abs(byUtility) > UTILITY_EPSILON) {
+        if (byUtility < 0) victimIndex = i;
+        continue;
+      }
+      if (a.capturedAt < b.capturedAt) victimIndex = i;
     }
     dropped.push(...kept.splice(victimIndex, 1));
   }
   return { kept, dropped };
 }
 
+// src/coordination/agents/project-agent-quarantine.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import * as path5 from "node:path";
+var QUARANTINE_MAX_BYTES = 64 * 1024;
+var RETIRED_MATCH_THRESHOLD = 0.55;
+function quarantinePath(role, projectRoot) {
+  return path5.join(roleDir(role, projectRoot), "quarantine.md");
+}
+function readTextOrEmpty(filePath) {
+  try {
+    return readFileSync3(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function appendQuarantine(role, retired, at, projectRoot) {
+  if (retired.length === 0) return;
+  const filePath = quarantinePath(role, projectRoot);
+  const existing = readTextOrEmpty(filePath);
+  const header = existing ? "" : `# Retired directives for \`${role}\`
+
+> Directives that were exercised repeatedly and kept correlating with
+> failure. They are no longer injected anywhere. Kept for audit \u2014 a directive
+> can be right about a project that has since changed.
+
+`;
+  const block = retired.map((entry) => {
+    const { applied, wins, losses } = directiveTrials(entry);
+    const attributes = [
+      `at=${at}`,
+      `category=${entry.category}`,
+      ...entry.skill ? [`skill=${entry.skill}`] : [],
+      `applied=${applied}`,
+      `wins=${wins}`
+    ].join("; ");
+    return [
+      `<!-- quarantined: ${attributes} -->`,
+      `- **${entry.what}**`,
+      `  - *Record:* ${wins} succeeded / ${losses} failed of ${applied} applied`,
+      ""
+    ].join("\n");
+  }).join("\n");
+  let next = `${existing}${header}${block}`;
+  if (Buffer.byteLength(next, "utf8") > QUARANTINE_MAX_BYTES) {
+    const marker = "<!-- quarantined:";
+    const overflow = Buffer.byteLength(next, "utf8") - QUARANTINE_MAX_BYTES;
+    const cut = next.indexOf(marker, overflow);
+    next = cut === -1 ? block : next.slice(cut);
+  }
+  writeTextAtomically(filePath, next);
+}
+function readQuarantinedDirectives(role, projectRoot) {
+  const raw = readTextOrEmpty(quarantinePath(role, projectRoot));
+  if (!raw) return [];
+  const out = [];
+  const stamps = [...raw.matchAll(/<!--\s*quarantined:\s*([^>]*?)\s*-->/g)];
+  for (const [index, stamp] of stamps.entries()) {
+    const attributes = {};
+    for (const part of (stamp[1] ?? "").split(";")) {
+      const eq = part.indexOf("=");
+      if (eq === -1) continue;
+      attributes[part.slice(0, eq).trim()] = part.slice(eq + 1).trim();
+    }
+    const start = (stamp.index ?? 0) + stamp[0].length;
+    const end = stamps[index + 1]?.index ?? raw.length;
+    const what = /^-\s+\*\*([\s\S]+?)\*\*\s*$/m.exec(raw.slice(start, end))?.[1]?.replace(/\s+/g, " ").trim();
+    if (!what) continue;
+    const skill = attributes["skill"];
+    out.push({ what, ...skill ? { skill } : {} });
+  }
+  return out;
+}
+function bareClaim(line) {
+  return line.replace(/^\s*[-*+]\s+/, "").replace(/^\s*\d+[.)]\s+/, "").replace(/\*\*/g, "").replace(/`/g, "").trim();
+}
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function scrubRetiredLines(text, retired) {
+  if (!text.trim() || retired.length === 0) return text;
+  const keys = retired.map((what) => normalizeForComparison(what));
+  const lines = text.split("\n");
+  const kept = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const claim = bareClaim(line);
+    if (claim.length >= MIN_INSTRUCTIVE_LENGTH && keys.some(
+      (key) => tokenOverlap(key, normalizeForComparison(claim)) >= RETIRED_MATCH_THRESHOLD
+    )) {
+      const base = indentOf(line);
+      while (i + 1 < lines.length) {
+        const next = lines[i + 1];
+        if (!next.trim() || indentOf(next) <= base) break;
+        i++;
+      }
+      continue;
+    }
+    kept.push(line);
+  }
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function hasDirectiveContent(text) {
+  return text.split("\n").some((line) => {
+    const trimmed = line.trimStart();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(">")) return false;
+    if (/^-{3,}\s*$/.test(trimmed)) return false;
+    if (/^\*[^*].*\*$/.test(trimmed)) return false;
+    return bareClaim(line).length >= MIN_INSTRUCTIVE_LENGTH;
+  });
+}
+function retiredDirectivesToWarnAbout(role, currentDirectives, projectRoot, skill) {
+  const currentKeys = currentDirectives.map((text) => normalizeForComparison(text));
+  return readQuarantinedDirectives(role, projectRoot).filter((entry) => skill ? entry.skill === skill : true).map((entry) => entry.what).filter(
+    (what) => !currentKeys.some(
+      (key) => tokenOverlap(key, normalizeForComparison(what)) >= RETIRED_MATCH_THRESHOLD
+    )
+  );
+}
+
 // src/coordination/agents/project-agent-consolidation.ts
 function learnedPath(role, projectRoot) {
-  return path5.join(roleDir(role, projectRoot), "learned.md");
+  return path6.join(roleDir(role, projectRoot), "learned.md");
 }
 function loadProjectAgentLearnedText(role, projectRoot) {
   try {
-    return readFileSync3(learnedPath(role, projectRoot), "utf8").trim();
+    return readFileSync4(learnedPath(role, projectRoot), "utf8").trim();
   } catch {
     return "";
   }
@@ -2309,28 +2477,27 @@ function readRawLearnedEntries(role, projectRoot) {
   return parseStructuredLearnedEntriesFromContent(raw, splitLearnedEntries(raw));
 }
 function consolidationPath(role, projectRoot) {
-  return path5.join(roleDir(role, projectRoot), "consolidated.md");
+  return path6.join(roleDir(role, projectRoot), "consolidated.md");
+}
+function consolidatedDocumentPath(role, projectRoot) {
+  return consolidationPath(assertProjectAgentRole(role), projectRoot);
 }
 function consolidationMetaPath(role, projectRoot) {
-  return path5.join(roleDir(role, projectRoot), "consolidation.json");
+  return path6.join(roleDir(role, projectRoot), "consolidation.json");
 }
 function archivePath(role, at, projectRoot) {
-  return path5.join(
-    roleDir(role, projectRoot),
-    "archive",
-    `learned-${at.replace(/[:.]/g, "-")}.md`
-  );
+  return path6.join(roleDir(role, projectRoot), "archive", `learned-${at.replace(/[:.]/g, "-")}.md`);
 }
 function loadProjectAgentConsolidated(role, projectRoot) {
   try {
-    return readFileSync3(consolidationPath(role, projectRoot), "utf8").trim();
+    return readFileSync4(consolidationPath(role, projectRoot), "utf8").trim();
   } catch {
     return "";
   }
 }
 function loadConsolidationMetadata(role, projectRoot) {
   try {
-    const raw = readFileSync3(consolidationMetaPath(role, projectRoot), "utf8");
+    const raw = readFileSync4(consolidationMetaPath(role, projectRoot), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && typeof parsed.consolidatedAt === "string" && typeof parsed.sourceEntryCount === "number") {
       return parsed;
@@ -2401,10 +2568,13 @@ function clearProjectAgentConsolidated(role, projectRoot) {
 function buildConsolidationInstruction(role, projectRoot) {
   const normalizedRole = assertProjectAgentRole(role);
   const entries = readRawLearnedEntries(normalizedRole, projectRoot);
-  const rawEntries = entries.map(
-    (entry) => entry.how ? `${entry.what}
-   Anchors: ${entry.how.split("\n").join(", ")}` : entry.what
-  );
+  const rawEntries = entries.map((entry) => {
+    const lines = [entry.what];
+    if (entry.how) lines.push(`   Anchors: ${entry.how.split("\n").join(", ")}`);
+    const { applied, wins } = directiveTrials(entry);
+    if (applied > 0) lines.push(`   Track record: applied ${applied}\xD7, ${wins} succeeded`);
+    return lines.join("\n");
+  });
   const existingConsolidation = loadProjectAgentConsolidated(normalizedRole, projectRoot);
   const rawBody = rawEntries.map((entry, i) => `### Entry ${i + 1}
 
@@ -2424,6 +2594,7 @@ ${entry}`).join("\n\n");
     "6. **Structured format.** Organize the content under clear markdown headings (##) by topic. Use bullet points for individual facts. Group by category (Conventions, Patterns, Warnings, Project Facts) when it helps scannability.",
     "7. **Preserve actionable anchors.** Keep exact file paths, command names, package names, and configuration values that make a directive concrete and runnable.",
     "8. **No filler.** Do not include meta-commentary about the consolidation process. The document should read as if it were always a single authoritative reference.",
+    "9. **Trust the track record over your own judgement of plausibility.** An entry may carry `Track record: applied N\xD7, M succeeded` \u2014 completed tasks that exercised it, and how many of those succeeded. Keep the ones that keep working, even when they read as obvious. An entry applied several times with few successes has been tested and has failed the test: drop it, or narrow it to the condition under which it actually holds. Entries with no track record are unproven rather than bad \u2014 judge them on merit, but do not let one displace a proven entry.",
     "",
     rawEntries.length > 0 ? `## Raw learned entries (${rawEntries.length} total)
 
@@ -2437,6 +2608,21 @@ ${rawBody}` : "## Raw learned entries\n\n(No raw entries yet \u2014 return an em
 ${existingConsolidation}`
     );
   }
+  const retired = retiredDirectivesToWarnAbout(
+    normalizedRole,
+    entries.map((entry) => entry.what),
+    projectRoot
+  );
+  if (retired.length > 0) {
+    sections.push(
+      "",
+      `## Retired \u2014 do not reinstate (${retired.length})
+
+These were exercised repeatedly and kept correlating with failed tasks. If the existing document above still states any of them, drop it.
+
+${retired.map((what) => `- ${what}`).join("\n")}`
+    );
+  }
   sections.push(
     "",
     "## Output",
@@ -2516,7 +2702,7 @@ var BUILT_IN_KNOWLEDGE_MANIFESTS = {
 };
 
 // src/coordination/agents/project-agent-learning-policy.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 var DEFAULT_LEARNING_POLICY = {
   enabled: true,
   lifetimeCaptureCount: 0
@@ -2524,23 +2710,26 @@ var DEFAULT_LEARNING_POLICY = {
 function loadProjectAgentLearningPolicy(role, projectRoot) {
   try {
     const parsed = JSON.parse(
-      readFileSync4(learningPolicyPath(role, projectRoot), "utf8")
+      readFileSync5(learningPolicyPath(role, projectRoot), "utf8")
     );
     return {
       enabled: parsed.enabled !== false,
       lifetimeCaptureCount: typeof parsed.lifetimeCaptureCount === "number" && Number.isInteger(parsed.lifetimeCaptureCount) && parsed.lifetimeCaptureCount >= 0 ? parsed.lifetimeCaptureCount : 0,
       ...typeof parsed.lastCaptureAt === "string" ? { lastCaptureAt: parsed.lastCaptureAt } : {},
-      ...parsed.lastCaptureSource === "automatic" || parsed.lastCaptureSource === "manual" || parsed.lastCaptureSource === "taught" ? { lastCaptureSource: parsed.lastCaptureSource } : {}
+      ...parsed.lastCaptureSource === "automatic" || parsed.lastCaptureSource === "manual" || parsed.lastCaptureSource === "taught" ? { lastCaptureSource: parsed.lastCaptureSource } : {},
+      ...typeof parsed.lastOptimizeAt === "string" ? { lastOptimizeAt: parsed.lastOptimizeAt } : {}
     };
   } catch {
     return { ...DEFAULT_LEARNING_POLICY };
   }
 }
 function updateProjectAgentLearningPolicy(role, patch, projectRoot) {
-  const current = loadProjectAgentLearningPolicy(role, projectRoot);
+  const defined = Object.fromEntries(
+    Object.entries(patch).filter(([, value]) => value !== void 0)
+  );
   const updated = {
-    ...current,
-    ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {}
+    ...loadProjectAgentLearningPolicy(role, projectRoot),
+    ...defined
   };
   writeTextAtomically(
     learningPolicyPath(role, projectRoot),
@@ -2549,14 +2738,20 @@ function updateProjectAgentLearningPolicy(role, patch, projectRoot) {
   );
   return updated;
 }
+function recordProjectAgentOptimizePass(role, projectRoot, at = (/* @__PURE__ */ new Date()).toISOString()) {
+  try {
+    updateProjectAgentLearningPolicy(role, { lastOptimizeAt: at }, projectRoot);
+  } catch {
+  }
+}
 
 // src/coordination/agents/project-agent-skill-layer.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync6, rmSync as rmSync3 } from "node:fs";
-import * as path7 from "node:path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync3 } from "node:fs";
+import * as path8 from "node:path";
 
 // src/coordination/agents/project-agent-profile.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5 } from "node:fs";
-import * as path6 from "node:path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync6 } from "node:fs";
+import * as path7 from "node:path";
 function slugifyProjectAgentRole(name) {
   const slug = name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+|[._-]+$/g, "").slice(0, 96);
   return assertProjectAgentRole(slug);
@@ -2564,7 +2759,7 @@ function slugifyProjectAgentRole(name) {
 function loadProjectAgentProfile(role, projectRoot) {
   try {
     const parsed = JSON.parse(
-      readFileSync5(projectAgentProfilePath(role, projectRoot), "utf8")
+      readFileSync6(projectAgentProfilePath(role, projectRoot), "utf8")
     );
     const normalizedRole = assertProjectAgentRole(parsed.role ?? role);
     const baseRole = assertProjectAgentRole(parsed.baseRole ?? "generic");
@@ -2635,7 +2830,7 @@ function createProjectAgent(input, projectRoot) {
     ""
   ].join("\n");
   mkdirSync3(dir, { recursive: true });
-  writeTextAtomically(path6.join(dir, "identity.md"), identity);
+  writeTextAtomically(path7.join(dir, "identity.md"), identity);
   writeTextAtomically(
     projectAgentProfilePath(role, projectRoot),
     `${JSON.stringify(profile, null, 2)}
@@ -2924,17 +3119,17 @@ function assertProjectSkillName(name) {
   return normalized;
 }
 function projectSkillsDir(role, projectRoot) {
-  return path7.join(roleDir(role, projectRoot), "skills");
+  return path8.join(roleDir(role, projectRoot), "skills");
 }
 function projectSkillAugmentationPath(role, skill, projectRoot) {
-  return path7.join(projectSkillsDir(role, projectRoot), `${assertProjectSkillName(skill)}.md`);
+  return path8.join(projectSkillsDir(role, projectRoot), `${assertProjectSkillName(skill)}.md`);
 }
 function projectSkillAffinityPath(role, projectRoot) {
-  return path7.join(projectSkillsDir(role, projectRoot), "affinity.json");
+  return path8.join(projectSkillsDir(role, projectRoot), "affinity.json");
 }
 function loadProjectSkillAugmentation(role, skill, projectRoot) {
   try {
-    return readFileSync6(projectSkillAugmentationPath(role, skill, projectRoot), "utf8").trim();
+    return readFileSync7(projectSkillAugmentationPath(role, skill, projectRoot), "utf8").trim();
   } catch {
     return "";
   }
@@ -2943,13 +3138,32 @@ function saveProjectSkillAugmentation(role, skill, content, projectRoot) {
   const filePath = projectSkillAugmentationPath(role, skill, projectRoot);
   const trimmed = content.trim();
   if (!trimmed) return filePath;
-  const bounded = Buffer.byteLength(trimmed, "utf8") > SKILL_AUGMENTATION_MAX_BYTES ? `${trimmed.slice(0, SKILL_AUGMENTATION_MAX_BYTES)}
-
-_(truncated at ${SKILL_AUGMENTATION_MAX_BYTES} bytes)_` : trimmed;
-  writeTextAtomically(filePath, `${bounded}
+  writeTextAtomically(filePath, `${boundAugmentation(trimmed)}
 `);
   return filePath;
 }
+function boundAugmentation(text) {
+  if (Buffer.byteLength(text, "utf8") <= SKILL_AUGMENTATION_MAX_BYTES) return text;
+  const notice = `
+
+_(truncated at ${SKILL_AUGMENTATION_MAX_BYTES} bytes)_`;
+  const lines = text.split("\n");
+  const title = lines[0] ?? "";
+  let budget = SKILL_AUGMENTATION_MAX_BYTES - Buffer.byteLength(`${title}
+${notice}`, "utf8") - Buffer.byteLength("\u2026\n", "utf8");
+  const tail = [];
+  for (let i = lines.length - 1; i > 0; i--) {
+    const cost = Buffer.byteLength(`${lines[i]}
+`, "utf8");
+    if (cost > budget) break;
+    tail.unshift(lines[i]);
+    budget -= cost;
+  }
+  if (tail.length === 0) return `${title.slice(0, SKILL_AUGMENTATION_MAX_BYTES)}${notice}`;
+  return `${title}
+\u2026
+${tail.join("\n").trimEnd()}${notice}`;
+}
 function clearProjectSkillAugmentation(role, skill, projectRoot) {
   const target = skill ? projectSkillAugmentationPath(role, skill, projectRoot) : projectSkillsDir(role, projectRoot);
   try {
@@ -2964,7 +3178,25 @@ function listProjectSkillAugmentations(role, projectRoot) {
     return [];
   }
 }
-function renderSkillAugmentation(role, skill, directives, updatedAt) {
+function renderSkillAugmentation(role, skill, directives, updatedAt, existing) {
+  const priorBody = stripAugmentationFooter(existing ?? "");
+  const priorLines = priorBody.split("\n").map((line) => normalizeForComparison(line.replace(/^[-*]\s+/, ""))).filter(Boolean);
+  const fresh = directives.filter(
+    (directive) => !priorLines.some((line) => tokenOverlap(line, normalizeForComparison(directive)) >= 0.55)
+  );
+  if (priorBody) {
+    if (fresh.length === 0) return `${(existing ?? "").trim()}
+`;
+    return [
+      priorBody,
+      "",
+      ...fresh.map((directive) => `- ${directive}`),
+      "",
+      "---",
+      `*Distilled ${updatedAt} \xB7 ${fresh.length} new directive${fresh.length === 1 ? "" : "s"}*`,
+      ""
+    ].join("\n");
+  }
   return [
     `# Project practice: \`${skill}\` (role: \`${role}\`)`,
     "",
@@ -2978,7 +3210,10 @@ function renderSkillAugmentation(role, skill, directives, updatedAt) {
     ""
   ].join("\n");
 }
-function buildSkillDistillInstruction(role, skill, directives, existing) {
+function stripAugmentationFooter(text) {
+  return text.replace(/\n*---\s*\n\*(?:Distilled|Truncated)[^\n]*\*\s*$/i, "").replace(/\n*_\(truncated at \d+ bytes\)_\s*$/i, "").trimEnd();
+}
+function buildSkillDistillInstruction(role, skill, directives, existing, retired = []) {
   const sections = [
     `You are refining the \`${skill}\` skill for the "${role}" agent **in this project**.`,
     "",
@@ -2992,6 +3227,7 @@ function buildSkillDistillInstruction(role, skill, directives, existing) {
     "4. **Merge, do not append.** Combine overlapping directives into one sharper rule. The output must be shorter than the input.",
     "5. **Structure.** Short `##` sections when it helps (e.g. Commands, Conventions, Pitfalls); bullets otherwise.",
     "6. **Budget.** Stay under 400 words. Drop the weakest directives rather than compressing everything into noise.",
+    "7. **Weigh the track record.** Some directives carry one, shown as `[applied N\xD7, M ok]` \u2014 the number of completed tasks that exercised the directive and how many of those succeeded. Lead with the ones that keep working. A directive applied several times with few successes has been tested and found wanting: drop it, or state the narrower condition under which it actually holds. A directive with no record is unproven, not bad \u2014 keep it if it is sound, but do not let it displace a proven one.",
     "",
     `## Directives captured for \`${skill}\` (${directives.length})`,
     "",
@@ -3000,6 +3236,16 @@ function buildSkillDistillInstruction(role, skill, directives, existing) {
   if (existing?.trim()) {
     sections.push("", "## Existing addendum (improve upon it)", "", existing.trim());
   }
+  if (retired.length > 0) {
+    sections.push(
+      "",
+      `## Retired \u2014 do not reinstate (${retired.length})`,
+      "",
+      "These were exercised repeatedly and kept correlating with failed tasks. If the existing addendum still states any of them, drop it.",
+      "",
+      ...retired.map((what) => `- ${what}`)
+    );
+  }
   sections.push(
     "",
     "## Output",
@@ -3025,7 +3271,7 @@ function loadSkillAffinity(role, projectRoot) {
   const normalizedRole = assertProjectAgentRole(role);
   try {
     const parsed = JSON.parse(
-      readFileSync6(projectSkillAffinityPath(normalizedRole, projectRoot), "utf8")
+      readFileSync7(projectSkillAffinityPath(normalizedRole, projectRoot), "utf8")
     );
     const entries = {};
     for (const [skill, entry] of Object.entries(parsed.entries ?? {})) {
@@ -3074,9 +3320,11 @@ function recordSkillLoad(role, skills, projectRoot) {
   });
 }
 function recordSkillOutcome(role, skills, ok, projectRoot) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   mutateAffinity(role, skills, projectRoot, (entry) => {
     if (ok) entry.succeeded += 1;
     else entry.failed += 1;
+    entry.lastUsedAt = now;
   });
 }
 function recordSkillLearned(role, skill, projectRoot) {
@@ -3090,24 +3338,30 @@ function setSkillPinned(role, skill, pinned, projectRoot) {
     else delete entry.pinned;
   });
 }
-function scoreSkillAffinity(entry) {
-  if (!entry) return 0;
-  if (entry.pinned) return Number.POSITIVE_INFINITY;
-  const outcomes = entry.succeeded + entry.failed;
-  const successRate = outcomes === 0 ? 0 : (entry.succeeded + 1) / (outcomes + 2);
-  return entry.learned * 2 + successRate * 3 + Math.min(entry.loaded, 10) * 0.1;
+var SKILL_EVIDENCE_HALF_LIFE_DAYS = 30;
+function scoreSkillAffinity(entry, now = Date.now()) {
+  const record = entry ?? EMPTY_ENTRY;
+  if (record.pinned) return Number.POSITIVE_INFINITY;
+  const outcomes = record.succeeded + record.failed;
+  const successRate = (record.succeeded + 1) / (outcomes + 2);
+  const ageDays = record.lastUsedAt ? (now - Date.parse(record.lastUsedAt)) / 864e5 : Number.NaN;
+  const recency = Number.isFinite(ageDays) ? 0.5 ** (Math.max(0, ageDays) / SKILL_EVIDENCE_HALF_LIFE_DAYS) : 1;
+  const evidence = (successRate - 0.5) * 4 * recency;
+  const exploration = 1 / Math.sqrt(1 + record.loaded);
+  return Math.log1p(record.learned) * 2 + evidence + exploration;
 }
 function rankRoleSkills(role, candidates, projectRoot, limit = DEFAULT_EAGER_SKILL_LIMIT) {
   const unique = [...new Set(candidates.filter(isProjectSkillName))];
   if (unique.length <= limit) return unique;
   const affinity = loadSkillAffinity(role, projectRoot);
   const augmented = new Set(listProjectSkillAugmentations(role, projectRoot));
+  const now = Date.now();
   return unique.map((skill, index) => ({
     skill,
     index,
     // An existing addendum is itself evidence the project developed this
     // skill, even when the affinity file was reset or hand-edited.
-    score: scoreSkillAffinity(affinity.entries[skill]) + (augmented.has(skill) ? 1 : 0)
+    score: scoreSkillAffinity(affinity.entries[skill], now) + (augmented.has(skill) ? 1 : 0)
   })).sort((a, b) => b.score === a.score ? a.index - b.index : b.score - a.score).slice(0, limit).map((item) => item.skill);
 }
 function resolveRoleSkillCandidates(role, projectRoot) {
@@ -3177,6 +3431,13 @@ function isTextBlock(b) {
 // src/coordination/agents/project-agent-optimizer.ts
 var DEFAULT_MAX_TOKENS = 8e3;
 var DEFAULT_TIMEOUT_MS = 12e4;
+function describeDirective(entry) {
+  const parts = [entry.what];
+  if (entry.how) parts.push(`(anchors: ${entry.how.split("\n").join(", ")})`);
+  const { applied, wins } = directiveTrials(entry);
+  if (applied > 0) parts.push(`[applied ${applied}\xD7, ${wins} ok]`);
+  return parts.join(" ");
+}
 function unwrapWholeDocumentFence(text) {
   const wholeDocFence = /^```(?:markdown|md)?[^\n]*\n([\s\S]*?)\n?```\s*$/i;
   const inner = wholeDocFence.exec(text.trim())?.[1];
@@ -3223,13 +3484,14 @@ async function optimizeProjectAgentLearning(role, projectRoot, options = {}) {
   for (const entry of entries) {
     if (!entry.skill) continue;
     const bucket = bySkill.get(entry.skill) ?? [];
-    bucket.push(entry.how ? `${entry.what} (anchors: ${entry.how.split("\n").join(", ")})` : entry.what);
+    bucket.push(describeDirective(entry));
     bySkill.set(entry.skill, bucket);
   }
   const at = (/* @__PURE__ */ new Date()).toISOString();
   const refreshed = [];
   for (const [skill, directives] of bySkill) {
-    let body = renderSkillAugmentation(normalizedRole, skill, directives, at);
+    const existing = loadProjectSkillAugmentation(normalizedRole, skill, projectRoot);
+    let body = renderSkillAugmentation(normalizedRole, skill, directives, at, existing);
     if (options.llm) {
       try {
         const synthesized = await complete(
@@ -3239,7 +3501,8 @@ async function optimizeProjectAgentLearning(role, projectRoot, options = {}) {
             normalizedRole,
             skill,
             directives,
-            loadProjectSkillAugmentation(normalizedRole, skill, projectRoot)
+            existing,
+            retiredDirectivesToWarnAbout(normalizedRole, directives, projectRoot, skill)
           ),
           options
         );
@@ -3252,6 +3515,7 @@ async function optimizeProjectAgentLearning(role, projectRoot, options = {}) {
   }
   const { instruction } = buildConsolidationInstruction(normalizedRole, projectRoot);
   if (!options.llm) {
+    recordProjectAgentOptimizePass(normalizedRole, projectRoot, at);
     return { ...base, status: "no-llm", skills: refreshed, instruction };
   }
   let content;
@@ -3266,6 +3530,7 @@ async function optimizeProjectAgentLearning(role, projectRoot, options = {}) {
     };
   }
   if (!content) {
+    recordProjectAgentOptimizePass(normalizedRole, projectRoot);
     return { ...base, status: "empty-synthesis", skills: refreshed, model: options.llm.model };
   }
   const prune = options.prune ?? true;
@@ -3284,6 +3549,7 @@ async function optimizeProjectAgentLearning(role, projectRoot, options = {}) {
       error: error instanceof Error ? error.message : "failed to persist consolidation"
     };
   }
+  recordProjectAgentOptimizePass(normalizedRole, projectRoot);
   return {
     ...base,
     status: "optimized",
@@ -3321,17 +3587,16 @@ function resolveAutoOptimizePolicy(overrides) {
 function evaluateAutoOptimize(role, projectRoot, policy, now = Date.now()) {
   if (!policy.enabled) return { eligible: false, reason: "disabled" };
   const normalizedRole = assertProjectAgentRole(role);
-  if (!loadProjectAgentLearningPolicy(normalizedRole, projectRoot).enabled) {
+  const learningPolicy = loadProjectAgentLearningPolicy(normalizedRole, projectRoot);
+  if (!learningPolicy.enabled) {
     return { eligible: false, reason: "learning-paused" };
   }
   const entries = readRawLearnedEntries(normalizedRole, projectRoot);
   if (entries.length < policy.minEntries) return { eligible: false, reason: "too-few-entries" };
   const meta = loadConsolidationMetadata(normalizedRole, projectRoot);
-  if (meta) {
-    const since = now - Date.parse(meta.consolidatedAt);
-    if (Number.isFinite(since) && since < policy.minIntervalMs) {
-      return { eligible: false, reason: "cooling-down" };
-    }
+  const lastPassAt = [meta?.consolidatedAt, learningPolicy.lastOptimizeAt].map((stamp) => stamp ? Date.parse(stamp) : Number.NaN).filter((value) => Number.isFinite(value));
+  if (lastPassAt.length > 0 && now - Math.max(...lastPassAt) < policy.minIntervalMs) {
+    return { eligible: false, reason: "cooling-down" };
   }
   const bytes = entries.reduce(
     (sum, entry) => sum + Buffer.byteLength(`${entry.what}${entry.why}${entry.how}`, "utf8"),
@@ -3472,26 +3737,130 @@ var LearningOptimizationScheduler = class {
   }
 };
 
+// src/coordination/agents/project-agent-directive-outcome.ts
+import * as path9 from "node:path";
+var DIRECTIVE_QUARANTINE_MIN_APPLIED = 8;
+var DIRECTIVE_QUARANTINE_MAX_UTILITY = 0.3;
+var MIN_ANCHOR_LENGTH = 6;
+var DISTINCTIVE_TOKEN_LENGTH = 6;
+var MIN_DISTINCTIVE_TOKENS = 5;
+var DISTINCTIVE_COVERAGE = 0.6;
+function learnedPath2(role, projectRoot) {
+  return path9.join(roleDir(role, projectRoot), "learned.md");
+}
+function directiveAnchors(entry) {
+  return entry.how.split("\n").map((line) => line.replace(/`/g, "").trim().toLowerCase()).filter((anchor) => anchor.length >= MIN_ANCHOR_LENGTH);
+}
+function distinctiveTokens(text) {
+  return [
+    ...new Set(
+      text.toLowerCase().replace(/[^\w\s./@-]/g, " ").split(/\s+/).map((token) => token.replace(/^[./@-]+/, "").replace(/[./@-]+$/, "")).filter((token) => token.length >= DISTINCTIVE_TOKEN_LENGTH)
+    )
+  ];
+}
+function directiveWasApplied(entry, report) {
+  const haystack = report.toLowerCase();
+  if (!haystack) return false;
+  const anchors = directiveAnchors(entry);
+  if (anchors.length > 0) {
+    return anchors.some((anchor) => haystack.includes(anchor));
+  }
+  const tokens = distinctiveTokens(entry.what);
+  if (tokens.length < MIN_DISTINCTIVE_TOKENS) return false;
+  const hits = tokens.filter((token) => haystack.includes(token)).length;
+  return hits >= MIN_DISTINCTIVE_TOKENS && hits / tokens.length >= DISTINCTIVE_COVERAGE;
+}
+function recordDirectiveOutcomes(role, report, succeeded, projectRoot) {
+  const normalizedRole = assertProjectAgentRole(role);
+  const empty = { role: normalizedRole, attributed: 0, quarantined: [] };
+  if (!report.trim()) return empty;
+  const entries = readRawLearnedEntries(normalizedRole, projectRoot);
+  if (entries.length === 0) return empty;
+  const updated = [];
+  const retired = [];
+  let attributed = 0;
+  for (const entry of entries) {
+    if (!directiveWasApplied(entry, report)) {
+      updated.push(entry);
+      continue;
+    }
+    attributed++;
+    const trials = directiveTrials(entry);
+    const next = {
+      ...entry,
+      applied: trials.applied + 1,
+      wins: trials.wins + (succeeded ? 1 : 0)
+    };
+    if (directiveTrials(next).applied >= DIRECTIVE_QUARANTINE_MIN_APPLIED && directiveUtility(next) < DIRECTIVE_QUARANTINE_MAX_UTILITY) {
+      retired.push(next);
+      continue;
+    }
+    updated.push(next);
+  }
+  if (attributed === 0) return empty;
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const newest = updated.map((entry) => entry.capturedAt).filter(Boolean).sort().pop() ?? at;
+  writeTextAtomically(
+    learnedPath2(normalizedRole, projectRoot),
+    renderLearnedInstructions(normalizedRole, updated, newest)
+  );
+  if (retired.length > 0) {
+    appendQuarantine(normalizedRole, retired, at, projectRoot);
+    scrubRetiredFromInjectedDocuments(normalizedRole, retired, projectRoot);
+  }
+  return {
+    role: normalizedRole,
+    attributed,
+    quarantined: retired.map((entry) => entry.what)
+  };
+}
+function scrubRetiredFromInjectedDocuments(role, retired, projectRoot) {
+  const texts = retired.map((entry) => entry.what);
+  for (const skill of new Set(retired.map((entry) => entry.skill).filter(Boolean))) {
+    try {
+      const current = loadProjectSkillAugmentation(role, skill, projectRoot);
+      if (!current) continue;
+      const scrubbed = scrubRetiredLines(current, texts);
+      if (scrubbed === current.trim()) continue;
+      if (!hasDirectiveContent(scrubbed)) {
+        clearProjectSkillAugmentation(role, skill, projectRoot);
+        continue;
+      }
+      writeTextAtomically(projectSkillAugmentationPath(role, skill, projectRoot), `${scrubbed}
+`);
+    } catch {
+    }
+  }
+  try {
+    const consolidated = loadProjectAgentConsolidated(role, projectRoot);
+    if (!consolidated) return;
+    const scrubbed = scrubRetiredLines(consolidated, texts);
+    if (scrubbed === consolidated.trim() || !hasDirectiveContent(scrubbed)) return;
+    writeTextAtomically(consolidatedDocumentPath(role, projectRoot), scrubbed);
+  } catch {
+  }
+}
+
 // src/coordination/agents/project-agent-files.ts
 import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   rmSync as rmSync4
 } from "node:fs";
-import * as path8 from "node:path";
+import * as path10 from "node:path";
 function updateProjectAgentLearned(role, content, projectRoot, mode = "append") {
   const dir = roleDir(role, projectRoot);
   mkdirSync4(dir, { recursive: true });
-  const filePath = path8.join(dir, "learned.md");
+  const filePath = path10.join(dir, "learned.md");
   if (mode === "replace") {
     writeTextAtomically(filePath, content);
     return filePath;
   }
   const existing = (() => {
     try {
-      return readFileSync7(filePath, "utf8");
+      return readFileSync8(filePath, "utf8");
     } catch {
       return "";
     }
@@ -3519,7 +3888,7 @@ function updateProjectAgentLearned(role, content, projectRoot, mode = "append")
 function updateProjectAgentIdentity(role, content, projectRoot) {
   const dir = roleDir(role, projectRoot);
   mkdirSync4(dir, { recursive: true });
-  const filePath = path8.join(dir, "identity.md");
+  const filePath = path10.join(dir, "identity.md");
   writeTextAtomically(filePath, content);
   return filePath;
 }
@@ -3527,7 +3896,7 @@ function updateProjectAgentConfig(role, config, projectRoot) {
   const validated = validateProjectAgentConfig(config);
   const dir = roleDir(role, projectRoot);
   mkdirSync4(dir, { recursive: true });
-  const filePath = path8.join(dir, "config.json");
+  const filePath = path10.join(dir, "config.json");
   writeTextAtomically(filePath, `${JSON.stringify(validated, null, 2)}
 `);
   return filePath;
@@ -3535,7 +3904,7 @@ function updateProjectAgentConfig(role, config, projectRoot) {
 function updateProjectAgentKnowledge(role, manifest, projectRoot) {
   const dir = roleDir(role, projectRoot);
   mkdirSync4(dir, { recursive: true });
-  const filePath = path8.join(dir, "knowledge.json");
+  const filePath = path10.join(dir, "knowledge.json");
   writeTextAtomically(filePath, `${JSON.stringify(manifest, null, 2)}
 `);
   return filePath;
@@ -3561,18 +3930,18 @@ function refreshProjectAgentIdentity(role, projectRoot) {
   const dir = roleDir(role, projectRoot);
   mkdirSync4(dir, { recursive: true });
   for (const file of ["learned.md", "identity.md", "consolidated.md", "consolidation.json"]) {
-    const fp = path8.join(dir, file);
+    const fp = path10.join(dir, file);
     try {
       rmSync4(fp, { force: true });
     } catch {
     }
   }
   writeTextAtomically(
-    path8.join(dir, "learned.md"),
+    path10.join(dir, "learned.md"),
     renderLearnedInstructions(role, [], (/* @__PURE__ */ new Date()).toISOString())
   );
   writeTextAtomically(
-    path8.join(dir, "identity.md"),
+    path10.join(dir, "identity.md"),
     `# Project identity for ${role}
 
 <!-- Describe how this agent should behave in the context of this project. -->
@@ -3585,7 +3954,7 @@ function listProjectAgentRoles(projectRoot) {
   try {
     return readdirSync3(dir).filter((name) => {
       if (!isProjectAgentRoleName(name)) return false;
-      const sub = path8.join(dir, name);
+      const sub = path10.join(dir, name);
       try {
         return [
           "learned.md",
@@ -3596,7 +3965,7 @@ function listProjectAgentRoles(projectRoot) {
           "profile.json",
           "consolidated.md",
           "consolidation.json"
-        ].some((file) => existsSync3(path8.join(sub, file)));
+        ].some((file) => existsSync3(path10.join(sub, file)));
       } catch {
         return false;
       }
@@ -3663,25 +4032,25 @@ function createProjectAgentRoster(baseRoster, projectRoot) {
   });
 }
 function loadProjectAgentIdentity(role, projectRoot) {
-  const identityPath = path9.join(roleDir(role, projectRoot), "identity.md");
+  const identityPath = path11.join(roleDir(role, projectRoot), "identity.md");
   try {
-    return readFileSync8(identityPath, "utf8").trim();
+    return readFileSync9(identityPath, "utf8").trim();
   } catch {
     return "";
   }
 }
 function loadProjectAgentLearned(role, projectRoot) {
-  const learnedPath2 = path9.join(roleDir(role, projectRoot), "learned.md");
+  const learnedPath3 = path11.join(roleDir(role, projectRoot), "learned.md");
   try {
-    return readFileSync8(learnedPath2, "utf8").trim();
+    return readFileSync9(learnedPath3, "utf8").trim();
   } catch {
     return "";
   }
 }
 function loadRoleKnowledgeManifest(role, projectRoot) {
-  const projectPath = path9.join(roleDir(role, projectRoot), "knowledge.json");
+  const projectPath = path11.join(roleDir(role, projectRoot), "knowledge.json");
   try {
-    const raw = readFileSync8(projectPath, "utf8");
+    const raw = readFileSync9(projectPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return BUILT_IN_KNOWLEDGE_MANIFESTS[role];
@@ -3822,7 +4191,7 @@ ${learnedContent}`);
     }
   }
   const effectiveProjectRoot = projectRoot || process.cwd();
-  const learnedFilePath = path9.join(
+  const learnedFilePath = path11.join(
     effectiveProjectRoot,
     ".wrongstack",
     "agents",
@@ -3849,6 +4218,8 @@ The file below stores **learning data for this project's "${role}" agent** \u201
 - **Self-contained** \u2014 understandable without the surrounding session context.
 - **Front-load concrete anchors** \u2014 commands in backticks, package names like \`@wrongstack/core\`, file paths like \`packages/core/src/.../foo.ts\`. The structured-list renderer extracts these as the "how" for the entry.
 
+**Your directives are scored against real outcomes.** After every task the runtime checks which stored directives were actually exercised \u2014 it matches their anchors against the report \u2014 and folds that task's success or failure into each one's record. A directive that keeps correlating with success outlives newer arrivals and survives rewording; one that has been exercised repeatedly and kept correlating with failure is retired and stops being injected. Two consequences for how you write them: anchors are what make a directive *measurable*, not just runnable, so an anchorless directive can never earn a record; and a directive you are unsure about costs nothing to write, because the loop will find out.
+
 **Tag the skill you are developing.** When a directive refines one of your skills, mark it: \`## LEARNED [skill: testing]\`. Tagged directives are distilled into that skill's project addendum, so the lesson arrives as part of the skill itself on every future run instead of as a loose fact. Untagged directives are routed automatically when the wording makes the target obvious, and stay role-level otherwise.
 
 **Bad** (session log \u2014 rejected at capture time):
@@ -3914,7 +4285,7 @@ ${additions}
 ${contextEnd}`;
 }
 function resolveCaptureKey(role, projectRoot) {
-  return `${path9.resolve(projectRoot ?? process.cwd())}\0${assertProjectAgentRole(role)}`;
+  return `${path11.resolve(projectRoot ?? process.cwd())}\0${assertProjectAgentRole(role)}`;
 }
 function canCaptureNewLearned(role, _existingSize, isManual, projectRoot) {
   if (isManual) return void 0;
@@ -3932,13 +4303,13 @@ function canCaptureNewLearned(role, _existingSize, isManual, projectRoot) {
 }
 function getProjectAgentLearnStats(role, projectRoot) {
   const dir = roleDir(role, projectRoot);
-  const learnedPath_ = path9.join(dir, "learned.md");
-  const identityPath_ = path9.join(dir, "identity.md");
-  const configPath_ = path9.join(dir, "config.json");
-  const knowledgePath_ = path9.join(dir, "knowledge.json");
+  const learnedPath_ = path11.join(dir, "learned.md");
+  const identityPath_ = path11.join(dir, "identity.md");
+  const configPath_ = path11.join(dir, "config.json");
+  const knowledgePath_ = path11.join(dir, "knowledge.json");
   let learnedText = "";
   try {
-    learnedText = readFileSync8(learnedPath_, "utf8");
+    learnedText = readFileSync9(learnedPath_, "utf8");
   } catch {
   }
   const entries = parseStructuredLearnedEntries(role, projectRoot);
@@ -3952,12 +4323,18 @@ function getProjectAgentLearnStats(role, projectRoot) {
   const lastTs = runtimeLastTs ?? (Number.isFinite(persistedLastTs) ? persistedLastTs : null);
   const cooldownRemaining = lastTs ? Math.max(0, CAPTURE_COOLDOWN_MS - (Date.now() - lastTs)) : 0;
   const freq = window.count;
+  const trials = entries.map((entry) => directiveTrials(entry));
+  const totalApplied = trials.reduce((sum, trial) => sum + trial.applied, 0);
+  const totalWins = trials.reduce((sum, trial) => sum + trial.wins, 0);
   return {
     role,
     exists,
     entryCount: entries.length,
     skills: skillAugmentations,
     skilledEntryCount: entries.filter((entry) => entry.skill).length,
+    appliedEntryCount: trials.filter((trial) => trial.applied > 0).length,
+    deadEntryCount: trials.filter((trial) => trial.applied === 0).length,
+    directiveHitRate: totalApplied > 0 ? totalWins / totalApplied : null,
     totalBytes: Buffer.byteLength(learnedText, "utf8"),
     lastCapture: lastTs ? new Date(lastTs).toISOString() : null,
     lastCaptureTimestamp: lastTs,
@@ -4130,7 +4507,7 @@ function captureLearnedFromAgentOutputDetailed(output, role, projectRoot, isManu
     normalizedRole
   );
   const newContent = renderLearnedInstructions(normalizedRole, budget.kept, nowIso);
-  writeTextAtomically(path9.join(roleDir(normalizedRole, projectRoot), "learned.md"), newContent);
+  writeTextAtomically(path11.join(roleDir(normalizedRole, projectRoot), "learned.md"), newContent);
   recordCaptureAttempt(key, now.getTime());
   for (const skill of new Set(routedSkills)) {
     try {
@@ -4138,16 +4515,14 @@ function captureLearnedFromAgentOutputDetailed(output, role, projectRoot, isManu
     } catch {
     }
   }
-  const nextPolicy = {
-    ...policy,
-    lifetimeCaptureCount: policy.lifetimeCaptureCount + captured,
-    lastCaptureAt: now.toISOString(),
-    lastCaptureSource: isManual ? "manual" : "automatic"
-  };
-  writeTextAtomically(
-    learningPolicyPath(normalizedRole, projectRoot),
-    `${JSON.stringify(nextPolicy, null, 2)}
-`
+  updateProjectAgentLearningPolicy(
+    normalizedRole,
+    {
+      lifetimeCaptureCount: policy.lifetimeCaptureCount + captured,
+      lastCaptureAt: now.toISOString(),
+      lastCaptureSource: isManual ? "manual" : "automatic"
+    },
+    projectRoot
   );
   return {
     role: normalizedRole,
@@ -4243,38 +4618,38 @@ function loadTechVersionPolicy() {
   return techVersionPolicyBody;
 }
 function policyCandidateDirs() {
-  const here = path10.dirname(fileURLToPath(import.meta.url));
+  const here = path12.dirname(fileURLToPath(import.meta.url));
   const profileInstructions = resolveWstackPaths({ projectRoot: process.cwd() }).globalInstructions;
   return [
-    path10.resolve(here, "../../../../instructions/agents"),
-    path10.resolve(here, "../../../instructions/agents"),
-    path10.resolve(here, "../../instructions/agents"),
-    path10.resolve(here, "../instructions/agents"),
-    path10.resolve(here, "instructions/agents"),
-    path10.join(profileInstructions, "agents"),
+    path12.resolve(here, "../../../../instructions/agents"),
+    path12.resolve(here, "../../../instructions/agents"),
+    path12.resolve(here, "../../instructions/agents"),
+    path12.resolve(here, "../instructions/agents"),
+    path12.resolve(here, "instructions/agents"),
+    path12.join(profileInstructions, "agents"),
     profileInstructions
   ].filter((dir, index, all) => all.indexOf(dir) === index);
 }
 function policyBody() {
-  const here = path10.dirname(fileURLToPath(import.meta.url));
+  const here = path12.dirname(fileURLToPath(import.meta.url));
   const roots = [
-    path10.resolve(here, "_policy/tech-version.md"),
-    path10.resolve(here, "../_policy/tech-version.md"),
-    path10.resolve(here, "../../../instructions/agents/_policy/tech-version.md"),
-    path10.resolve(here, "../../instructions/agents/_policy/tech-version.md"),
-    path10.resolve(here, "../instructions/agents/_policy/tech-version.md"),
-    path10.resolve(here, "../../../../instructions/agents/_policy/tech-version.md"),
-    path10.resolve(here, "instructions/agents/_policy/tech-version.md")
+    path12.resolve(here, "_policy/tech-version.md"),
+    path12.resolve(here, "../_policy/tech-version.md"),
+    path12.resolve(here, "../../../instructions/agents/_policy/tech-version.md"),
+    path12.resolve(here, "../../instructions/agents/_policy/tech-version.md"),
+    path12.resolve(here, "../instructions/agents/_policy/tech-version.md"),
+    path12.resolve(here, "../../../../instructions/agents/_policy/tech-version.md"),
+    path12.resolve(here, "instructions/agents/_policy/tech-version.md")
   ];
   for (const file of roots) {
     try {
-      return readFileSync9(file, "utf8").trim();
+      return readFileSync10(file, "utf8").trim();
     } catch {
     }
   }
   for (const dir of policyCandidateDirs()) {
     try {
-      return readFileSync9(path10.join(dir, "_policy", "tech-version.md"), "utf8").trim();
+      return readFileSync10(path12.join(dir, "_policy", "tech-version.md"), "utf8").trim();
     } catch {
     }
   }
@@ -4293,7 +4668,7 @@ function agentPrompt(id) {
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      resolved = readFileSync9(path10.join(dir, fileName), "utf8").trim();
+      resolved = readFileSync10(path12.join(dir, fileName), "utf8").trim();
       break;
     } catch {
     }
@@ -4319,16 +4694,16 @@ function agentPromptDirCandidates(envDir) {
   const candKey = `${envDir}\0${profileInstructions}`;
   const cached = candidateCache.get(candKey);
   if (cached !== void 0) return cached;
-  const here = path10.dirname(fileURLToPath(import.meta.url));
+  const here = path12.dirname(fileURLToPath(import.meta.url));
   const explicitDir = envDir || void 0;
   const candidates = [
-    ...explicitDir ? [path10.resolve(explicitDir)] : [],
-    path10.join(profileInstructions, "agents"),
-    path10.resolve(here, "../../../../instructions/agents"),
-    path10.resolve(here, "../../../instructions/agents"),
-    path10.resolve(here, "../../instructions/agents"),
-    path10.resolve(here, "../instructions/agents"),
-    path10.resolve(here, "instructions/agents")
+    ...explicitDir ? [path12.resolve(explicitDir)] : [],
+    path12.join(profileInstructions, "agents"),
+    path12.resolve(here, "../../../../instructions/agents"),
+    path12.resolve(here, "../../../instructions/agents"),
+    path12.resolve(here, "../../instructions/agents"),
+    path12.resolve(here, "../instructions/agents"),
+    path12.resolve(here, "instructions/agents")
   ];
   const ordered = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
   candidateCache.set(candKey, ordered);
@@ -4385,8 +4760,16 @@ var TOOLS = {
     "test",
     "mailbox"
   ],
-  /** Version control. */
-  vcs: ["read", "grep", "glob", "git", "diff"],
+  /**
+   * Version control.
+   *
+   * `mailbox` is in every preset on purpose: a subagent that hits a wall must
+   * be able to say so. This was the one preset without it, which left the `git`
+   * and `release` roles able to fail but not to ask — the two roles whose work
+   * most often needs a decision from the leader (force-push, tag collision,
+   * dirty tree) and least often has a safe default.
+   */
+  vcs: ["read", "grep", "glob", "git", "diff", "mailbox"],
   /** Dependency management + CVE audit. */
   deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
   /** Documentation authoring. */
@@ -7817,26 +8200,26 @@ var BrainMonitor = class {
   trackFileChurn(toolName, ok, input) {
     if (!this.signals.fileChurn) return;
     if (!ok || !this.fileEditTools.has(toolName.toLowerCase())) return;
-    const path38 = editedPath(input);
-    if (!path38) return;
+    const path40 = editedPath(input);
+    if (!path40) return;
     const now = Date.now();
-    const stamps = (this.editTimestamps.get(path38) ?? []).filter(
+    const stamps = (this.editTimestamps.get(path40) ?? []).filter(
       (t) => now - t <= this.fileChurnWindowMs
     );
     stamps.push(now);
     if (stamps.length >= this.fileChurnThreshold) {
-      this.editTimestamps.delete(path38);
+      this.editTimestamps.delete(path40);
       void this.engage("file_churn", {
-        question: `The file "${path38}" has been edited ${stamps.length} times within ${Math.round(this.fileChurnWindowMs / 6e4)} minutes \u2014 the agent may be oscillating (edit/revert loop) instead of converging. Should it be steered?`,
+        question: `The file "${path40}" has been edited ${stamps.length} times within ${Math.round(this.fileChurnWindowMs / 6e4)} minutes \u2014 the agent may be oscillating (edit/revert loop) instead of converging. Should it be steered?`,
         context: [
-          `File: ${path38}`,
+          `File: ${path40}`,
           `Edits in window: ${stamps.length}`,
           `Window: ${Math.round(this.fileChurnWindowMs / 1e3)}s`
         ].join("\n")
       });
       return;
     }
-    this.editTimestamps.set(path38, stamps);
+    this.editTimestamps.set(path40, stamps);
   }
   async engage(kind, input) {
     const last = this.lastEngagedAt.get(kind) ?? 0;
@@ -9416,7 +9799,7 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
 
 // src/coordination/commit-safety.ts
 import { spawn } from "node:child_process";
-import * as path12 from "node:path";
+import * as path14 from "node:path";
 
 // src/utils/child-env.ts
 var ALLOWED_KEYS = /* @__PURE__ */ new Set([
@@ -9556,7 +9939,7 @@ function buildChildEnv(optsOrSessionId) {
 
 // src/coordination/file-author-tracker.ts
 import * as fs2 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as path13 from "node:path";
 
 // src/utils/atomic-write.ts
 import {
@@ -9579,7 +9962,7 @@ var withFileLock = primitives.withFileLock;
 var DEFAULT_MAX_ENTRIES = 5e3;
 var LOG_FILENAME = "file-authors.json";
 function logPath(storageDir) {
-  return path11.join(storageDir, LOG_FILENAME);
+  return path13.join(storageDir, LOG_FILENAME);
 }
 async function loadLog(storageDir, projectRoot) {
   try {
@@ -9647,7 +10030,7 @@ async function assessCommitSafety(opts) {
   const foreignFiles = [];
   const unverifiedFiles = [];
   for (const rel of dirty) {
-    const abs = path12.resolve(topLevel, rel);
+    const abs = path14.resolve(topLevel, rel);
     const entry = authors.get(normPath(abs)) ?? authors.get(normPath(rel));
     if (!entry) {
       unverifiedFiles.push(rel);
@@ -9720,8 +10103,8 @@ async function loadAuthorMap(projectRoot, storageDirOverride) {
   const map = /* @__PURE__ */ new Map();
   for (const e of log.entries) {
     map.set(normPath(e.filePath), e);
-    if (!path12.isAbsolute(e.filePath)) {
-      map.set(normPath(path12.resolve(projectRoot, e.filePath)), e);
+    if (!path14.isAbsolute(e.filePath)) {
+      map.set(normPath(path14.resolve(projectRoot, e.filePath)), e);
     }
   }
   return map;
@@ -9793,7 +10176,7 @@ function runGit(args, cwd, signal) {
 // src/coordination/delegate-tool.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import * as fsp3 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as path15 from "node:path";
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
@@ -9851,6 +10234,14 @@ var SHADOW_AGENT = {
 };
 var CRITIC_AGENT = defineAgent("critic", "Critic");
 var GENERIC_AGENT = defineAgent("generic", "Generic Project Agent");
+function withDispatchMetadata(definition) {
+  const summary = definition.capability?.summary?.trim();
+  if (!summary) return definition.config;
+  return {
+    ...definition.config,
+    dispatch: { summary, keywords: [...definition.capability.keywords ?? []] }
+  };
+}
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
   "bug-hunter": BUG_HUNTER_AGENT,
@@ -9860,7 +10251,7 @@ var FLEET_ROSTER = {
   generic: GENERIC_AGENT,
   "shadow-agent": SHADOW_AGENT,
   ...Object.fromEntries(
-    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
+    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, withDispatchMetadata(d)])
   )
 };
 var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
@@ -10456,13 +10847,13 @@ async function readSubagentPartial(opts, subagentId) {
   if (!opts.sessionsRoot) return void 0;
   const candidates = [];
   if (opts.directorRunId) {
-    candidates.push(path13.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+    candidates.push(path15.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
       const entries = await fsp3.readdir(opts.sessionsRoot, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          candidates.push(path13.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+          candidates.push(path15.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
         }
       }
     } catch {
@@ -11011,7 +11402,7 @@ var DirectorStateCheckpoint = class {
 
 // src/coordination/checkpoint-wiring.ts
 import * as fsp5 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as path16 from "node:path";
 async function appendSessionEvent(host, event) {
   if (!host.sessionWriter) return;
   try {
@@ -11059,7 +11450,7 @@ async function writeManifest(host) {
     }),
     usage: host.usage.snapshot()
   };
-  await fsp5.mkdir(path14.dirname(host.manifestPath), { recursive: true });
+  await fsp5.mkdir(path16.dirname(host.manifestPath), { recursive: true });
   await atomicWrite(host.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
   return host.manifestPath;
 }
@@ -11716,9 +12107,6 @@ import {
   updateTaskAssignment
 } from "@wrongstack/kanban";
 
-// src/coordination/director-kanban-queue-helpers.ts
-import { describeKanbanBoundary } from "@wrongstack/kanban";
-
 // src/coordination/director-input-helpers.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 function stringArray2(value) {
@@ -11739,6 +12127,7 @@ function instantiateRosterConfig2(role, base) {
 }
 
 // src/coordination/director-kanban-queue-helpers.ts
+import { describeKanbanBoundary } from "@wrongstack/kanban";
 function normalizeKanbanQueueInput(input) {
   const raw = input ?? {};
   return {
@@ -11907,8 +12296,8 @@ function ensureKanbanTool(tools) {
 }
 
 // src/utils/instruction-file.ts
-import { readFileSync as readFileSync10, statSync as statSync3 } from "node:fs";
-import * as path15 from "node:path";
+import { readFileSync as readFileSync11, statSync as statSync3 } from "node:fs";
+import * as path17 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
 var rootCandidates;
@@ -11918,7 +12307,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync10(path15.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync11(path17.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -11934,11 +12323,11 @@ function renderInstructionTemplate(template, values) {
 }
 function instructionRootCandidates() {
   if (rootCandidates !== void 0) return rootCandidates;
-  const here = path15.dirname(fileURLToPath2(import.meta.url));
+  const here = path17.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path15.resolve(here, "../../instructions"),
-    path15.resolve(here, "../instructions"),
-    path15.resolve(here, "instructions")
+    path17.resolve(here, "../../instructions"),
+    path17.resolve(here, "../instructions"),
+    path17.resolve(here, "instructions")
   ];
   rootCandidates = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
   return rootCandidates;
@@ -12073,378 +12462,336 @@ function makeLLMClassifier(complete2) {
   };
 }
 
-// src/coordination/director-quality-gate-tool.ts
+// src/coordination/director-basic-tools.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
-function makeQualityGateTool(director, roster) {
+function makeAssignTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", minLength: 1, description: "Target subagent id. Required." },
+      description: {
+        type: "string",
+        minLength: 1,
+        description: "The task in natural language \u2014 what you want this subagent to do."
+      },
+      maxToolCalls: {
+        type: "number",
+        minimum: 1,
+        description: "Optional per-task tool-call budget override."
+      },
+      timeoutMs: { type: "number", minimum: 1, description: "Optional per-task timeout in ms." }
+    },
+    required: ["subagentId", "description"]
+  };
   return {
-    name: "quality_gate",
-    description: "Run a first-class implementation quality gate. It can await implementer task ids, spawn independent verifier/reviewer agents, summarize their verdicts, and optionally send must-fix feedback back to an implementer until the gate passes or the repair-attempt limit is reached.",
-    usageHint: "Use after code-changing work. Provide implementerTaskIds when available. Add repairSubagentId to iterate fixes automatically. Verdict only passes when every enabled reviewer/verifier explicitly passes.",
+    name: "assign_task",
+    description: "Queue a task on a previously spawned subagent. NON-BLOCKING: returns a `taskId` IMMEDIATELY \u2014 the subagent processes the task on its next iteration with its own LLM budget. The `taskId` is the durable handle for retrieving the result later via `await_tasks`, `roll_up`, or `ask_result`. Many `assign_task` calls can be in flight in parallel against the same or different subagents. This is the primary tool for fan-out work; do NOT use `delegate` to spawn multiple investigations sequentially.",
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const task = {
+        id: randomUUID8(),
+        description: i.description,
+        subagentId: i.subagentId,
+        maxToolCalls: i.maxToolCalls,
+        timeoutMs: i.timeoutMs
+      };
+      const taskId = await director.assign(task);
+      return { taskId, subagentId: i.subagentId };
+    }
+  };
+}
+function makeAwaitTasksTool(director) {
+  return {
+    name: "await_tasks",
+    description: 'Block until one or more `taskId`s complete, then return their results. The subagents keep running in the background \u2014 only the leader\'s iteration pauses, which is the point: this is the correct tool to retrieve a result you started earlier with `assign_task`. mode:"all" (default) blocks until EVERY named task completes. mode:"any" returns as soon as AT LEAST ONE completes \u2014 use it for independent tasks so you can handle each finisher immediately (reassign work, spawn helpers) instead of idling on the slowest; call again with the returned `pending` ids to pick up the next finisher. The pattern "fan out via assign_task, then await_tasks({mode:\'any\'})" is the async replacement for serial `delegate` calls.',
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
-        task: {
-          type: "string",
-          description: "Original implementation task or acceptance goal being gated."
-        },
-        implementerTaskIds: {
+        taskIds: {
           type: "array",
           items: { type: "string" },
-          description: "Optional completed or in-flight implementer task ids to await and include as implementation evidence."
+          description: "One or more task ids returned by `assign_task`."
         },
-        repairSubagentId: {
+        mode: {
           type: "string",
-          description: "Optional implementer subagent id. When set and the gate fails, quality_gate assigns a repair task with reviewer/verifier feedback and reruns the gate."
+          enum: ["all", "any"],
+          description: '"all" (default): block until every task completes. "any": return on the first completion with the rest listed as pending.'
         },
-        maxRepairAttempts: {
+        timeoutMs: {
           type: "number",
-          minimum: 0,
-          maximum: 5,
-          description: "Maximum automatic repair iterations. Default: 2 when repairSubagentId is set, otherwise 0."
-        },
-        targets: {
-          type: "array",
-          items: { type: "string" },
-          description: "Files, packages, or paths that reviewer/verifier should focus on."
-        },
-        commands: {
-          type: "array",
-          items: { type: "string" },
-          description: 'Verification commands that should pass, e.g. ["pnpm --filter @wrongstack/core typecheck"].'
-        },
-        expected: {
-          type: "string",
-          description: "Expected behavior or acceptance criteria."
-        },
-        evidence: {
-          type: "string",
-          description: "Known implementation notes, diff summary, or commands already run."
-        },
-        reviewer: {
-          type: "boolean",
-          description: "Whether to run the reviewer lane. Default true."
-        },
-        verifier: {
-          type: "boolean",
-          description: "Whether to run the verifier lane. Default true."
+          minimum: 1,
+          description: 'mode:"any" only \u2014 return {timedOut:true, completed:[]} if nothing completes within this window instead of blocking.'
+        }
+      },
+      required: ["taskIds"]
+    },
+    async execute(input) {
+      const i = input;
+      if (i.mode === "any") {
+        const r = await director.awaitTasksAny(
+          i.taskIds,
+          i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : void 0
+        );
+        return {
+          mode: "any",
+          completed: r.completed,
+          pending: r.pending,
+          ...r.timedOut ? { timedOut: true } : {},
+          ...r.pending.length > 0 ? {
+            hint: 'Handle the completed results now. Re-call await_tasks with the pending ids (mode:"any") for the next finisher \u2014 or assign new work to the now-idle subagent first.'
+          } : {}
+        };
+      }
+      const results = await director.awaitTasks(i.taskIds);
+      return { results };
+    }
+  };
+}
+function makeAskTool(director) {
+  return {
+    name: "ask_subagent",
+    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        subagentId: {
+          type: "string",
+          minLength: 1,
+          description: "Subagent to ask. Must be a previously spawned id."
         },
+        question: { type: "string", minLength: 1, description: "The question or instruction." },
         timeoutMs: {
           type: "number",
           minimum: 1,
-          description: "Optional per reviewer/verifier/repair task timeout."
-        },
-        reviewerWorktree: {
-          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
-          description: "Reviewer worktree override. Default off because reviewer is read-only."
-        },
-        verifierWorktree: {
-          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
-          description: "Verifier worktree override. Default auto so test artifacts stay isolated when fleet policy wants it."
+          description: "Optional timeout in ms (default 30s)."
         }
-      }
+      },
+      required: ["subagentId", "question"]
     },
     async execute(input) {
-      const i = normalizeQualityGateInput(input);
-      const runReviewer = i.reviewer !== false;
-      const runVerifier = i.verifier !== false;
-      if (!runReviewer && !runVerifier) {
+      const i = input;
+      try {
+        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
+        const stored = director.largeAnswerStore.storeAnswer(answer);
+        if (stored.inline) {
+          return { ok: true, answer: stored.summary };
+        }
         return {
-          verdict: "inconclusive",
-          passed: false,
-          error: "quality_gate requires reviewer, verifier, or both."
+          ok: true,
+          answer: stored.summary,
+          _answerKey: stored.key,
+          _hint: "Response was large and stored. Use ask_result with the key to retrieve it."
         };
+      } catch (err) {
+        return { ok: false, error: toErrorMessage(err) };
       }
-      const implementerResults = i.implementerTaskIds && i.implementerTaskIds.length > 0 ? await director.awaitTasks(i.implementerTaskIds) : [];
-      const maxRepairAttempts = clampRepairAttempts(
-        i.maxRepairAttempts ?? (i.repairSubagentId ? 2 : 0)
-      );
-      const repairResults = [];
-      const attempts = [];
-      for (let attempt = 1; ; attempt++) {
-        const gateTaskIds = [];
-        const taskRoleById = /* @__PURE__ */ new Map();
-        if (runVerifier) {
-          const subagentId = await director.spawn(
-            makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
-          );
-          const taskId = await director.assign({
-            id: randomUUID8(),
-            subagentId,
-            description: buildVerifierTask(i, {
-              attempt,
-              implementerResults,
-              repairResults,
-              priorAttempts: attempts
-            }),
-            timeoutMs: i.timeoutMs
-          });
-          gateTaskIds.push(taskId);
-          taskRoleById.set(taskId, "verifier");
-        }
-        if (runReviewer) {
-          const subagentId = await director.spawn(
-            makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
-          );
-          const taskId = await director.assign({
-            id: randomUUID8(),
-            subagentId,
-            description: buildReviewerTask(i, {
-              attempt,
-              implementerResults,
-              repairResults,
-              priorAttempts: attempts
-            }),
-            timeoutMs: i.timeoutMs
-          });
-          gateTaskIds.push(taskId);
-          taskRoleById.set(taskId, "reviewer");
-        }
-        const gateResults = await director.awaitTasks(gateTaskIds);
-        const reports = gateResults.map((r) => assessRoleResult(taskRoleById.get(r.taskId), r));
-        const assessment = assessQualityGate(reports);
-        attempts.push({ attempt, reports, ...assessment });
-        if (assessment.passed || !i.repairSubagentId || attempt > maxRepairAttempts) {
-          return {
-            verdict: assessment.verdict,
-            passed: assessment.passed,
-            attempts,
-            repairAttemptsUsed: repairResults.length,
-            implementerResults: implementerResults.map(summarizeTaskResult),
-            nextAction: assessment.passed ? "accept" : i.repairSubagentId && attempt > maxRepairAttempts ? "manual_intervention_or_raise_repair_limit" : "inspect_failures"
-          };
-        }
-        const repairTaskId = await director.assign({
-          id: randomUUID8(),
-          subagentId: i.repairSubagentId,
-          description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
-          timeoutMs: i.timeoutMs
-        });
-        const [repairResult] = await director.awaitTasks([repairTaskId]);
-        if (repairResult) repairResults.push(repairResult);
-        if (repairResult?.status !== "success") {
-          return {
-            verdict: "fail",
-            passed: false,
-            attempts,
-            repairAttemptsUsed: repairResults.length,
-            repairResult: repairResult ? summarizeTaskResult(repairResult) : void 0,
-            implementerResults: implementerResults.map(summarizeTaskResult),
-            nextAction: "repair_failed"
-          };
+    }
+  };
+}
+function makeAskResultTool(director) {
+  return {
+    name: "ask_result",
+    description: "Retrieve a large `ask_subagent` response that was stored out-of-context (>2K chars). Returns the full stored value.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          minLength: 1,
+          description: "The `_answerKey` returned by `ask_subagent` for a large response."
         }
+      },
+      required: ["key"]
+    },
+    async execute(input) {
+      const i = input;
+      const value = director.largeAnswerStore.retrieveAnswer(i.key);
+      if (value === void 0) {
+        return {
+          ok: false,
+          error: `No stored answer found for key "${i.key}" \u2014 it may have been cleared or the key is invalid.`
+        };
       }
+      return { ok: true, value };
     }
   };
 }
-function normalizeQualityGateInput(input) {
-  const raw = input ?? {};
+function makeRollUpTool(director) {
   return {
-    task: typeof raw.task === "string" ? raw.task : void 0,
-    implementerTaskIds: stringArray2(raw.implementerTaskIds),
-    repairSubagentId: typeof raw.repairSubagentId === "string" && raw.repairSubagentId.trim() ? raw.repairSubagentId.trim() : void 0,
-    maxRepairAttempts: typeof raw.maxRepairAttempts === "number" ? raw.maxRepairAttempts : void 0,
-    targets: stringArray2(raw.targets),
-    commands: stringArray2(raw.commands),
-    expected: typeof raw.expected === "string" ? raw.expected : void 0,
-    evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
-    reviewer: typeof raw.reviewer === "boolean" ? raw.reviewer : void 0,
-    verifier: typeof raw.verifier === "boolean" ? raw.verifier : void 0,
-    timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : void 0,
-    reviewerWorktree: normalizeWorktreeOverride(raw.reviewerWorktree),
-    verifierWorktree: normalizeWorktreeOverride(raw.verifierWorktree)
+    name: "roll_up",
+    description: "Aggregate completed task results into a single formatted summary.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Completed task ids to aggregate."
+        },
+        style: {
+          type: "string",
+          enum: ["markdown", "json"],
+          description: "Output flavor \u2014 markdown (default) or json."
+        }
+      },
+      required: ["taskIds"]
+    },
+    async execute(input) {
+      const i = input;
+      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
+      return { summary, count: i.taskIds.length };
+    }
   };
 }
-function clampRepairAttempts(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(5, Math.floor(value)));
-}
-function makeQualityGateSubagentConfig(role, roster, worktree) {
-  const base = roster?.[role] ?? getAgentDefinition(role)?.config ?? { name: role, role };
+function makeTerminateTool(director) {
   return {
-    ...instantiateRosterConfig2(role, base),
-    worktree
+    name: "terminate_subagent",
+    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
+    permission: "auto",
+    mutating: true,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema: {
+      type: "object",
+      properties: { subagentId: { type: "string", description: "Subagent to abort." } },
+      required: ["subagentId"]
+    },
+    async execute(input) {
+      const i = input;
+      await director.terminate(i.subagentId);
+      return { ok: true };
+    }
   };
 }
-function buildVerifierTask(input, state) {
-  return [
-    "Run the independent verification gate for this implementation.",
-    "Return Markdown with `## Verdict` and make the first verdict word exactly `pass`, `fail`, or `blocked`.",
-    "Do not edit code. Run the smallest meaningful command set and include exact failures.",
-    "",
-    `Gate attempt: ${state.attempt}`,
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.commands?.length ? `Required or suggested commands:
-${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    input.evidence ? `Known evidence:
-${input.evidence}` : void 0,
-    taskResultsBlock("Implementer results", state.implementerResults),
-    taskResultsBlock("Repair results so far", state.repairResults),
-    priorAttemptsBlock(state.priorAttempts)
-  ].filter((part) => !!part).join("\n\n");
-}
-function buildReviewerTask(input, state) {
-  return [
-    "Run independent code review for this implementation.",
-    "Return Markdown with `## Verdict` and make the first verdict phrase exactly `approve`, `request changes`, or `needs verification`.",
-    "Do not edit code. Treat missing proof, vague tests, and uncertainty as blocking until verifier evidence exists.",
-    "",
-    `Gate attempt: ${state.attempt}`,
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    input.evidence ? `Known evidence:
-${input.evidence}` : void 0,
-    taskResultsBlock("Implementer results", state.implementerResults),
-    taskResultsBlock("Repair results so far", state.repairResults),
-    priorAttemptsBlock(state.priorAttempts)
-  ].filter((part) => !!part).join("\n\n");
-}
-function buildRepairTask(input, attempt, attemptNumber) {
-  return [
-    `Repair the implementation after quality gate attempt ${attemptNumber} failed.`,
-    "Address every must-fix item. Run relevant checks before returning.",
-    "Do not claim done unless verifier/reviewer feedback is resolved.",
-    "",
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.commands?.length ? `Commands expected to pass:
-${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    attempt.mustFix.length ? `Must fix:
-${attempt.mustFix.map((f) => `- ${f}`).join("\n")}` : void 0,
-    attempt.uncertaintyFlags.length ? `Uncertainty flags to resolve:
-${attempt.uncertaintyFlags.map((f) => `- ${f}`).join("\n")}` : void 0,
-    `Reviewer/verifier reports:
-${attempt.reports.map((r) => `### ${r.role} (${r.verdict})
-${r.summary}`).join("\n\n")}`
-  ].filter((part) => !!part).join("\n\n");
-}
-function taskResultsBlock(title, results) {
-  if (results.length === 0) return void 0;
-  return `${title}:
-${results.map((r) => `### ${r.subagentId}/${r.taskId}
-${summarizeTaskResult(r).summary}`).join("\n\n")}`;
-}
-function priorAttemptsBlock(attempts) {
-  if (attempts.length === 0) return void 0;
-  return `Prior quality gate attempts:
-${attempts.map(
-    (a) => `### Attempt ${a.attempt}
-${a.reports.map((r) => `- ${r.role}: ${r.verdict}${r.error ? ` (${r.error})` : ""}`).join("\n")}`
-  ).join("\n\n")}`;
-}
-function summarizeTaskResult(result) {
-  const text = typeof result.result === "string" ? result.result : result.result !== void 0 ? JSON.stringify(result.result, null, 2) : "";
-  const error = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
+function makeTerminateAllTool(director) {
   return {
-    taskId: result.taskId,
-    subagentId: result.subagentId,
-    status: result.status,
-    summary: excerpt(text || error || "(no output)", 4e3),
-    error
+    name: "terminate_all",
+    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
+    permission: "auto",
+    mutating: true,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      await director.terminateAll();
+      return {
+        ok: true,
+        message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.`
+      };
+    }
   };
 }
-function assessRoleResult(role, result) {
-  const resolvedRole = role ?? (result.subagentId.includes("review") ? "reviewer" : "verifier");
-  const summary = summarizeTaskResult(result);
-  const text = summary.summary;
-  const uncertaintyFlags = extractSection(text, "Uncertainty Flags");
-  if (result.status !== "success") {
-    return {
-      role: resolvedRole,
-      subagentId: result.subagentId,
-      taskId: result.taskId,
-      status: result.status,
-      verdict: "fail",
-      summary: text,
-      uncertaintyFlags,
-      error: summary.error ?? result.status
-    };
-  }
+function makeFleetTool(director) {
   return {
-    role: resolvedRole,
-    subagentId: result.subagentId,
-    taskId: result.taskId,
-    status: result.status,
-    verdict: parseQualityVerdict(resolvedRole, text),
-    summary: text,
-    uncertaintyFlags
-  };
-}
-function assessQualityGate(reports) {
-  const mustFix = [];
-  const uncertaintyFlags = [];
-  let hasFail = false;
-  let hasInconclusive = false;
-  for (const report of reports) {
-    if (report.verdict === "fail") hasFail = true;
-    if (report.verdict === "inconclusive") hasInconclusive = true;
-    const blocking = extractSection(report.summary, "Must Fix") || extractSection(report.summary, "Failures") || extractSection(report.summary, "Verification Gaps");
-    if (blocking) mustFix.push(`${report.role}: ${excerpt(blocking, 1e3)}`);
-    if (report.uncertaintyFlags) {
-      uncertaintyFlags.push(`${report.role}: ${excerpt(report.uncertaintyFlags, 1e3)}`);
-    }
-    if (report.error) mustFix.push(`${report.role}: ${report.error}`);
-  }
-  if (hasFail) return { verdict: "fail", passed: false, mustFix, uncertaintyFlags };
-  if (hasInconclusive || reports.length === 0) {
-    return { verdict: "inconclusive", passed: false, mustFix, uncertaintyFlags };
-  }
-  return { verdict: "pass", passed: true, mustFix, uncertaintyFlags };
-}
-function parseQualityVerdict(role, text) {
-  const normalized = text.toLowerCase();
-  const verdictBlock = normalized.match(/(?:^|\n)\s*(?:#+\s*)?verdict\b[^\n]*(?:\n|:|-)?([\s\S]{0,500})/)?.[0] ?? normalized.slice(0, 1e3);
-  if (role === "reviewer") {
-    if (/\b(request\s+changes|needs\s+verification|reject|rejected|fail|failed|blocked)\b/.test(
-      verdictBlock
-    )) {
-      return "fail";
-    }
-    if (/\b(approve|approved|pass|passed)\b/.test(verdictBlock)) return "pass";
-    if (sectionHasBlockingContent(text, "Must Fix") || sectionHasBlockingContent(text, "Verification Gaps")) {
-      return "fail";
+    name: "fleet",
+    description: 'Fleet observation tool. Use `action` to select what you need: "status" \u2014 snapshot of all subagents + coordinator counts + pending tasks; "usage" \u2014 token + cost breakdown per subagent and totals; "health" \u2014 per-subagent budget pressure, last activity, and status; "session" \u2014 read a subagent\'s JSONL transcript (requires subagentId).',
+    usageHint: 'action: "status" (default) | "usage" | "health" | "session".\nFor "session", pass subagentId (required) and optional tail (trailing JSONL lines).',
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["status", "usage", "health", "session"],
+          description: "Observation to retrieve (default: status)."
+        },
+        subagentId: {
+          type: "string",
+          description: 'Subagent id (required for action: "session").'
+        },
+        tail: {
+          type: "number",
+          description: 'Number of trailing JSONL lines (action: "session" only). Omit for the full transcript.'
+        }
+      }
+    },
+    async execute(input) {
+      const i = input ?? {};
+      const action = i.action ?? "status";
+      switch (action) {
+        case "status": {
+          const base = director.status();
+          const fm = director.fleetManager;
+          const stats = fm?.getFleetStats();
+          const fleetStatus = fm?.getFleetStatus();
+          return {
+            action: "status",
+            subagents: base.subagents,
+            coordinatorStats: stats ? {
+              total: stats.total,
+              running: stats.running,
+              idle: stats.idle,
+              stopped: stats.stopped
+            } : void 0,
+            pending: fleetStatus?.pending ?? [],
+            usage: fm?.snapshot()
+          };
+        }
+        case "usage": {
+          return { action: "usage", ...director.snapshot() };
+        }
+        case "health": {
+          const status = director.status();
+          const snapshot = director.snapshot();
+          const subagents = status.subagents ?? [];
+          const perSubagent = snapshot.perSubagent ?? {};
+          return {
+            action: "health",
+            subagents: subagents.map((s) => {
+              const usage = perSubagent[s.id];
+              return {
+                id: s.id,
+                status: s.status,
+                lastEventAt: usage?.lastEventAt,
+                budgetPressure: {
+                  iterations: usage?.iterations,
+                  toolCalls: usage?.toolCalls,
+                  costUsd: usage?.cost
+                }
+              };
+            })
+          };
+        }
+        case "session": {
+          const subagentId = i.subagentId;
+          if (!subagentId) {
+            return {
+              action: "session",
+              error: 'fleet: subagentId is required for action: "session"'
+            };
+          }
+          const result = await director.readSession(subagentId, i.tail);
+          if (!result) {
+            return {
+              action: "session",
+              error: `fleet: transcript unavailable for "${subagentId}". Is sessionsRoot configured?`
+            };
+          }
+          return { action: "session", ...result };
+        }
+        default:
+          return {
+            error: `fleet: unknown action "${action}". Valid: status, usage, health, session.`
+          };
+      }
     }
-    return "inconclusive";
-  }
-  if (/\b(fail|failed|blocked|red)\b/.test(verdictBlock)) return "fail";
-  if (/\b(pass|passed|green|approve|approved)\b/.test(verdictBlock)) return "pass";
-  if (sectionHasBlockingContent(text, "Failures")) return "fail";
-  return "inconclusive";
-}
-function sectionHasBlockingContent(text, heading) {
-  const section = extractSection(text, heading);
-  if (!section) return false;
-  return !/^\s*(none|n\/a|no\b|no issues|empty|\(none\))\s*\.?\s*$/i.test(section.trim());
-}
-function extractSection(text, heading) {
-  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(
-    `(?:^|\\n)\\s*#{1,6}\\s*${escaped}\\s*\\n([\\s\\S]*?)(?=\\n\\s*#{1,6}\\s+|$)`,
-    "i"
-  );
-  const match = text.match(pattern);
-  const body = match?.[1]?.trim();
-  return body ? body : void 0;
-}
-function excerpt(text, max) {
-  if (text.length <= max) return text;
-  return `${text.slice(0, max - 20).trimEnd()}
-...(truncated)`;
+  };
 }
 
 // src/coordination/director-collab-tools.ts
@@ -12565,336 +12912,378 @@ function makeWorkCompleteTool(director) {
   };
 }
 
-// src/coordination/director-basic-tools.ts
+// src/coordination/director-quality-gate-tool.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-function makeAssignTool(director) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      subagentId: { type: "string", minLength: 1, description: "Target subagent id. Required." },
-      description: {
-        type: "string",
-        minLength: 1,
-        description: "The task in natural language \u2014 what you want this subagent to do."
-      },
-      maxToolCalls: {
-        type: "number",
-        minimum: 1,
-        description: "Optional per-task tool-call budget override."
-      },
-      timeoutMs: { type: "number", minimum: 1, description: "Optional per-task timeout in ms." }
-    },
-    required: ["subagentId", "description"]
-  };
+function makeQualityGateTool(director, roster) {
   return {
-    name: "assign_task",
-    description: "Queue a task on a previously spawned subagent. NON-BLOCKING: returns a `taskId` IMMEDIATELY \u2014 the subagent processes the task on its next iteration with its own LLM budget. The `taskId` is the durable handle for retrieving the result later via `await_tasks`, `roll_up`, or `ask_result`. Many `assign_task` calls can be in flight in parallel against the same or different subagents. This is the primary tool for fan-out work; do NOT use `delegate` to spawn multiple investigations sequentially.",
+    name: "quality_gate",
+    description: "Run a first-class implementation quality gate. It can await implementer task ids, spawn independent verifier/reviewer agents, summarize their verdicts, and optionally send must-fix feedback back to an implementer until the gate passes or the repair-attempt limit is reached.",
+    usageHint: "Use after code-changing work. Provide implementerTaskIds when available. Add repairSubagentId to iterate fixes automatically. Verdict only passes when every enabled reviewer/verifier explicitly passes.",
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
-    inputSchema,
-    async execute(input) {
-      const i = input;
-      const task = {
-        id: randomUUID9(),
-        description: i.description,
-        subagentId: i.subagentId,
-        maxToolCalls: i.maxToolCalls,
-        timeoutMs: i.timeoutMs
-      };
-      const taskId = await director.assign(task);
-      return { taskId, subagentId: i.subagentId };
-    }
-  };
-}
-function makeAwaitTasksTool(director) {
-  return {
-    name: "await_tasks",
-    description: 'Block until one or more `taskId`s complete, then return their results. The subagents keep running in the background \u2014 only the leader\'s iteration pauses, which is the point: this is the correct tool to retrieve a result you started earlier with `assign_task`. mode:"all" (default) blocks until EVERY named task completes. mode:"any" returns as soon as AT LEAST ONE completes \u2014 use it for independent tasks so you can handle each finisher immediately (reassign work, spawn helpers) instead of idling on the slowest; call again with the returned `pending` ids to pick up the next finisher. The pattern "fan out via assign_task, then await_tasks({mode:\'any\'})" is the async replacement for serial `delegate` calls.',
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
-        taskIds: {
+        task: {
+          type: "string",
+          description: "Original implementation task or acceptance goal being gated."
+        },
+        implementerTaskIds: {
           type: "array",
           items: { type: "string" },
-          description: "One or more task ids returned by `assign_task`."
+          description: "Optional completed or in-flight implementer task ids to await and include as implementation evidence."
         },
-        mode: {
+        repairSubagentId: {
           type: "string",
-          enum: ["all", "any"],
-          description: '"all" (default): block until every task completes. "any": return on the first completion with the rest listed as pending.'
+          description: "Optional implementer subagent id. When set and the gate fails, quality_gate assigns a repair task with reviewer/verifier feedback and reruns the gate."
+        },
+        maxRepairAttempts: {
+          type: "number",
+          minimum: 0,
+          maximum: 5,
+          description: "Maximum automatic repair iterations. Default: 2 when repairSubagentId is set, otherwise 0."
+        },
+        targets: {
+          type: "array",
+          items: { type: "string" },
+          description: "Files, packages, or paths that reviewer/verifier should focus on."
+        },
+        commands: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Verification commands that should pass, e.g. ["pnpm --filter @wrongstack/core typecheck"].'
+        },
+        expected: {
+          type: "string",
+          description: "Expected behavior or acceptance criteria."
+        },
+        evidence: {
+          type: "string",
+          description: "Known implementation notes, diff summary, or commands already run."
+        },
+        reviewer: {
+          type: "boolean",
+          description: "Whether to run the reviewer lane. Default true."
+        },
+        verifier: {
+          type: "boolean",
+          description: "Whether to run the verifier lane. Default true."
         },
         timeoutMs: {
           type: "number",
           minimum: 1,
-          description: 'mode:"any" only \u2014 return {timedOut:true, completed:[]} if nothing completes within this window instead of blocking.'
+          description: "Optional per reviewer/verifier/repair task timeout."
+        },
+        reviewerWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Reviewer worktree override. Default off because reviewer is read-only."
+        },
+        verifierWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Verifier worktree override. Default auto so test artifacts stay isolated when fleet policy wants it."
         }
-      },
-      required: ["taskIds"]
+      }
     },
     async execute(input) {
-      const i = input;
-      if (i.mode === "any") {
-        const r = await director.awaitTasksAny(
-          i.taskIds,
-          i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : void 0
-        );
+      const i = normalizeQualityGateInput(input);
+      const runReviewer = i.reviewer !== false;
+      const runVerifier = i.verifier !== false;
+      if (!runReviewer && !runVerifier) {
         return {
-          mode: "any",
-          completed: r.completed,
-          pending: r.pending,
-          ...r.timedOut ? { timedOut: true } : {},
-          ...r.pending.length > 0 ? {
-            hint: 'Handle the completed results now. Re-call await_tasks with the pending ids (mode:"any") for the next finisher \u2014 or assign new work to the now-idle subagent first.'
-          } : {}
+          verdict: "inconclusive",
+          passed: false,
+          error: "quality_gate requires reviewer, verifier, or both."
         };
       }
-      const results = await director.awaitTasks(i.taskIds);
-      return { results };
-    }
-  };
-}
-function makeAskTool(director) {
-  return {
-    name: "ask_subagent",
-    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge.",
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        subagentId: {
-          type: "string",
-          minLength: 1,
-          description: "Subagent to ask. Must be a previously spawned id."
-        },
-        question: { type: "string", minLength: 1, description: "The question or instruction." },
-        timeoutMs: {
-          type: "number",
-          minimum: 1,
-          description: "Optional timeout in ms (default 30s)."
+      const implementerResults = i.implementerTaskIds && i.implementerTaskIds.length > 0 ? await director.awaitTasks(i.implementerTaskIds) : [];
+      const maxRepairAttempts = clampRepairAttempts(
+        i.maxRepairAttempts ?? (i.repairSubagentId ? 2 : 0)
+      );
+      const repairResults = [];
+      const attempts = [];
+      for (let attempt = 1; ; attempt++) {
+        const gateTaskIds = [];
+        const taskRoleById = /* @__PURE__ */ new Map();
+        if (runVerifier) {
+          const subagentId = await director.spawn(
+            makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
+          );
+          const taskId = await director.assign({
+            id: randomUUID9(),
+            subagentId,
+            description: buildVerifierTask(i, {
+              attempt,
+              implementerResults,
+              repairResults,
+              priorAttempts: attempts
+            }),
+            timeoutMs: i.timeoutMs
+          });
+          gateTaskIds.push(taskId);
+          taskRoleById.set(taskId, "verifier");
         }
-      },
-      required: ["subagentId", "question"]
-    },
-    async execute(input) {
-      const i = input;
-      try {
-        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
-        const stored = director.largeAnswerStore.storeAnswer(answer);
-        if (stored.inline) {
-          return { ok: true, answer: stored.summary };
+        if (runReviewer) {
+          const subagentId = await director.spawn(
+            makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
+          );
+          const taskId = await director.assign({
+            id: randomUUID9(),
+            subagentId,
+            description: buildReviewerTask(i, {
+              attempt,
+              implementerResults,
+              repairResults,
+              priorAttempts: attempts
+            }),
+            timeoutMs: i.timeoutMs
+          });
+          gateTaskIds.push(taskId);
+          taskRoleById.set(taskId, "reviewer");
+        }
+        const gateResults = await director.awaitTasks(gateTaskIds);
+        const reports = gateResults.map((r) => assessRoleResult(taskRoleById.get(r.taskId), r));
+        const assessment = assessQualityGate(reports);
+        attempts.push({ attempt, reports, ...assessment });
+        if (assessment.passed || !i.repairSubagentId || attempt > maxRepairAttempts) {
+          return {
+            verdict: assessment.verdict,
+            passed: assessment.passed,
+            attempts,
+            repairAttemptsUsed: repairResults.length,
+            implementerResults: implementerResults.map(summarizeTaskResult),
+            nextAction: assessment.passed ? "accept" : i.repairSubagentId && attempt > maxRepairAttempts ? "manual_intervention_or_raise_repair_limit" : "inspect_failures"
+          };
+        }
+        const repairTaskId = await director.assign({
+          id: randomUUID9(),
+          subagentId: i.repairSubagentId,
+          description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
+          timeoutMs: i.timeoutMs
+        });
+        const [repairResult] = await director.awaitTasks([repairTaskId]);
+        if (repairResult) repairResults.push(repairResult);
+        if (repairResult?.status !== "success") {
+          return {
+            verdict: "fail",
+            passed: false,
+            attempts,
+            repairAttemptsUsed: repairResults.length,
+            repairResult: repairResult ? summarizeTaskResult(repairResult) : void 0,
+            implementerResults: implementerResults.map(summarizeTaskResult),
+            nextAction: "repair_failed"
+          };
         }
-        return {
-          ok: true,
-          answer: stored.summary,
-          _answerKey: stored.key,
-          _hint: "Response was large and stored. Use ask_result with the key to retrieve it."
-        };
-      } catch (err) {
-        return { ok: false, error: toErrorMessage(err) };
       }
     }
   };
 }
-function makeAskResultTool(director) {
+function normalizeQualityGateInput(input) {
+  const raw = input ?? {};
   return {
-    name: "ask_result",
-    description: "Retrieve a large `ask_subagent` response that was stored out-of-context (>2K chars). Returns the full stored value.",
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        key: {
-          type: "string",
-          minLength: 1,
-          description: "The `_answerKey` returned by `ask_subagent` for a large response."
-        }
-      },
-      required: ["key"]
-    },
-    async execute(input) {
-      const i = input;
-      const value = director.largeAnswerStore.retrieveAnswer(i.key);
-      if (value === void 0) {
-        return {
-          ok: false,
-          error: `No stored answer found for key "${i.key}" \u2014 it may have been cleared or the key is invalid.`
-        };
-      }
-      return { ok: true, value };
-    }
+    task: typeof raw.task === "string" ? raw.task : void 0,
+    implementerTaskIds: stringArray2(raw.implementerTaskIds),
+    repairSubagentId: typeof raw.repairSubagentId === "string" && raw.repairSubagentId.trim() ? raw.repairSubagentId.trim() : void 0,
+    maxRepairAttempts: typeof raw.maxRepairAttempts === "number" ? raw.maxRepairAttempts : void 0,
+    targets: stringArray2(raw.targets),
+    commands: stringArray2(raw.commands),
+    expected: typeof raw.expected === "string" ? raw.expected : void 0,
+    evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
+    reviewer: typeof raw.reviewer === "boolean" ? raw.reviewer : void 0,
+    verifier: typeof raw.verifier === "boolean" ? raw.verifier : void 0,
+    timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : void 0,
+    reviewerWorktree: normalizeWorktreeOverride(raw.reviewerWorktree),
+    verifierWorktree: normalizeWorktreeOverride(raw.verifierWorktree)
   };
 }
-function makeRollUpTool(director) {
+function clampRepairAttempts(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(5, Math.floor(value)));
+}
+function makeQualityGateSubagentConfig(role, roster, worktree) {
+  const base = roster?.[role] ?? getAgentDefinition(role)?.config ?? { name: role, role };
   return {
-    name: "roll_up",
-    description: "Aggregate completed task results into a single formatted summary.",
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        taskIds: {
-          type: "array",
-          items: { type: "string" },
-          description: "Completed task ids to aggregate."
-        },
-        style: {
-          type: "string",
-          enum: ["markdown", "json"],
-          description: "Output flavor \u2014 markdown (default) or json."
-        }
-      },
-      required: ["taskIds"]
-    },
-    async execute(input) {
-      const i = input;
-      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
-      return { summary, count: i.taskIds.length };
-    }
+    ...instantiateRosterConfig2(role, base),
+    worktree
   };
 }
-function makeTerminateTool(director) {
+function buildVerifierTask(input, state) {
+  return [
+    "Run the independent verification gate for this implementation.",
+    "Return Markdown with `## Verdict` and make the first verdict word exactly `pass`, `fail`, or `blocked`.",
+    "Do not edit code. Run the smallest meaningful command set and include exact failures.",
+    "",
+    `Gate attempt: ${state.attempt}`,
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.commands?.length ? `Required or suggested commands:
+${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    input.evidence ? `Known evidence:
+${input.evidence}` : void 0,
+    taskResultsBlock("Implementer results", state.implementerResults),
+    taskResultsBlock("Repair results so far", state.repairResults),
+    priorAttemptsBlock(state.priorAttempts)
+  ].filter((part) => !!part).join("\n\n");
+}
+function buildReviewerTask(input, state) {
+  return [
+    "Run independent code review for this implementation.",
+    "Return Markdown with `## Verdict` and make the first verdict phrase exactly `approve`, `request changes`, or `needs verification`.",
+    "Do not edit code. Treat missing proof, vague tests, and uncertainty as blocking until verifier evidence exists.",
+    "",
+    `Gate attempt: ${state.attempt}`,
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    input.evidence ? `Known evidence:
+${input.evidence}` : void 0,
+    taskResultsBlock("Implementer results", state.implementerResults),
+    taskResultsBlock("Repair results so far", state.repairResults),
+    priorAttemptsBlock(state.priorAttempts)
+  ].filter((part) => !!part).join("\n\n");
+}
+function buildRepairTask(input, attempt, attemptNumber) {
+  return [
+    `Repair the implementation after quality gate attempt ${attemptNumber} failed.`,
+    "Address every must-fix item. Run relevant checks before returning.",
+    "Do not claim done unless verifier/reviewer feedback is resolved.",
+    "",
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.commands?.length ? `Commands expected to pass:
+${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    attempt.mustFix.length ? `Must fix:
+${attempt.mustFix.map((f) => `- ${f}`).join("\n")}` : void 0,
+    attempt.uncertaintyFlags.length ? `Uncertainty flags to resolve:
+${attempt.uncertaintyFlags.map((f) => `- ${f}`).join("\n")}` : void 0,
+    `Reviewer/verifier reports:
+${attempt.reports.map((r) => `### ${r.role} (${r.verdict})
+${r.summary}`).join("\n\n")}`
+  ].filter((part) => !!part).join("\n\n");
+}
+function taskResultsBlock(title, results) {
+  if (results.length === 0) return void 0;
+  return `${title}:
+${results.map((r) => `### ${r.subagentId}/${r.taskId}
+${summarizeTaskResult(r).summary}`).join("\n\n")}`;
+}
+function priorAttemptsBlock(attempts) {
+  if (attempts.length === 0) return void 0;
+  return `Prior quality gate attempts:
+${attempts.map(
+    (a) => `### Attempt ${a.attempt}
+${a.reports.map((r) => `- ${r.role}: ${r.verdict}${r.error ? ` (${r.error})` : ""}`).join("\n")}`
+  ).join("\n\n")}`;
+}
+function summarizeTaskResult(result) {
+  const text = typeof result.result === "string" ? result.result : result.result !== void 0 ? JSON.stringify(result.result, null, 2) : "";
+  const error = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
   return {
-    name: "terminate_subagent",
-    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
-    permission: "auto",
-    mutating: true,
-    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
-    inputSchema: {
-      type: "object",
-      properties: { subagentId: { type: "string", description: "Subagent to abort." } },
-      required: ["subagentId"]
-    },
-    async execute(input) {
-      const i = input;
-      await director.terminate(i.subagentId);
-      return { ok: true };
-    }
+    taskId: result.taskId,
+    subagentId: result.subagentId,
+    status: result.status,
+    summary: excerpt(text || error || "(no output)", 4e3),
+    error
   };
 }
-function makeTerminateAllTool(director) {
+function assessRoleResult(role, result) {
+  const resolvedRole = role ?? (result.subagentId.includes("review") ? "reviewer" : "verifier");
+  const summary = summarizeTaskResult(result);
+  const text = summary.summary;
+  const uncertaintyFlags = extractSection(text, "Uncertainty Flags");
+  if (result.status !== "success") {
+    return {
+      role: resolvedRole,
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      status: result.status,
+      verdict: "fail",
+      summary: text,
+      uncertaintyFlags,
+      error: summary.error ?? result.status
+    };
+  }
   return {
-    name: "terminate_all",
-    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
-    permission: "auto",
-    mutating: true,
-    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      await director.terminateAll();
-      return {
-        ok: true,
-        message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.`
-      };
+    role: resolvedRole,
+    subagentId: result.subagentId,
+    taskId: result.taskId,
+    status: result.status,
+    verdict: parseQualityVerdict(resolvedRole, text),
+    summary: text,
+    uncertaintyFlags
+  };
+}
+function assessQualityGate(reports) {
+  const mustFix = [];
+  const uncertaintyFlags = [];
+  let hasFail = false;
+  let hasInconclusive = false;
+  for (const report of reports) {
+    if (report.verdict === "fail") hasFail = true;
+    if (report.verdict === "inconclusive") hasInconclusive = true;
+    const blocking = extractSection(report.summary, "Must Fix") || extractSection(report.summary, "Failures") || extractSection(report.summary, "Verification Gaps");
+    if (blocking) mustFix.push(`${report.role}: ${excerpt(blocking, 1e3)}`);
+    if (report.uncertaintyFlags) {
+      uncertaintyFlags.push(`${report.role}: ${excerpt(report.uncertaintyFlags, 1e3)}`);
+    }
+    if (report.error) mustFix.push(`${report.role}: ${report.error}`);
+  }
+  if (hasFail) return { verdict: "fail", passed: false, mustFix, uncertaintyFlags };
+  if (hasInconclusive || reports.length === 0) {
+    return { verdict: "inconclusive", passed: false, mustFix, uncertaintyFlags };
+  }
+  return { verdict: "pass", passed: true, mustFix, uncertaintyFlags };
+}
+function parseQualityVerdict(role, text) {
+  const normalized = text.toLowerCase();
+  const verdictBlock = normalized.match(/(?:^|\n)\s*(?:#+\s*)?verdict\b[^\n]*(?:\n|:|-)?([\s\S]{0,500})/)?.[0] ?? normalized.slice(0, 1e3);
+  if (role === "reviewer") {
+    if (/\b(request\s+changes|needs\s+verification|reject|rejected|fail|failed|blocked)\b/.test(
+      verdictBlock
+    )) {
+      return "fail";
     }
-  };
-}
-function makeFleetTool(director) {
-  return {
-    name: "fleet",
-    description: 'Fleet observation tool. Use `action` to select what you need: "status" \u2014 snapshot of all subagents + coordinator counts + pending tasks; "usage" \u2014 token + cost breakdown per subagent and totals; "health" \u2014 per-subagent budget pressure, last activity, and status; "session" \u2014 read a subagent\'s JSONL transcript (requires subagentId).',
-    usageHint: 'action: "status" (default) | "usage" | "health" | "session".\nFor "session", pass subagentId (required) and optional tail (trailing JSONL lines).',
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        action: {
-          type: "string",
-          enum: ["status", "usage", "health", "session"],
-          description: "Observation to retrieve (default: status)."
-        },
-        subagentId: {
-          type: "string",
-          description: 'Subagent id (required for action: "session").'
-        },
-        tail: {
-          type: "number",
-          description: 'Number of trailing JSONL lines (action: "session" only). Omit for the full transcript.'
-        }
-      }
-    },
-    async execute(input) {
-      const i = input ?? {};
-      const action = i.action ?? "status";
-      switch (action) {
-        case "status": {
-          const base = director.status();
-          const fm = director.fleetManager;
-          const stats = fm?.getFleetStats();
-          const fleetStatus = fm?.getFleetStatus();
-          return {
-            action: "status",
-            subagents: base.subagents,
-            coordinatorStats: stats ? {
-              total: stats.total,
-              running: stats.running,
-              idle: stats.idle,
-              stopped: stats.stopped
-            } : void 0,
-            pending: fleetStatus?.pending ?? [],
-            usage: fm?.snapshot()
-          };
-        }
-        case "usage": {
-          return { action: "usage", ...director.snapshot() };
-        }
-        case "health": {
-          const status = director.status();
-          const snapshot = director.snapshot();
-          const subagents = status.subagents ?? [];
-          const perSubagent = snapshot.perSubagent ?? {};
-          return {
-            action: "health",
-            subagents: subagents.map((s) => {
-              const usage = perSubagent[s.id];
-              return {
-                id: s.id,
-                status: s.status,
-                lastEventAt: usage?.lastEventAt,
-                budgetPressure: {
-                  iterations: usage?.iterations,
-                  toolCalls: usage?.toolCalls,
-                  costUsd: usage?.cost
-                }
-              };
-            })
-          };
-        }
-        case "session": {
-          const subagentId = i.subagentId;
-          if (!subagentId) {
-            return {
-              action: "session",
-              error: 'fleet: subagentId is required for action: "session"'
-            };
-          }
-          const result = await director.readSession(subagentId, i.tail);
-          if (!result) {
-            return {
-              action: "session",
-              error: `fleet: transcript unavailable for "${subagentId}". Is sessionsRoot configured?`
-            };
-          }
-          return { action: "session", ...result };
-        }
-        default:
-          return {
-            error: `fleet: unknown action "${action}". Valid: status, usage, health, session.`
-          };
-      }
+    if (/\b(approve|approved|pass|passed)\b/.test(verdictBlock)) return "pass";
+    if (sectionHasBlockingContent(text, "Must Fix") || sectionHasBlockingContent(text, "Verification Gaps")) {
+      return "fail";
     }
-  };
+    return "inconclusive";
+  }
+  if (/\b(fail|failed|blocked|red)\b/.test(verdictBlock)) return "fail";
+  if (/\b(pass|passed|green|approve|approved)\b/.test(verdictBlock)) return "pass";
+  if (sectionHasBlockingContent(text, "Failures")) return "fail";
+  return "inconclusive";
+}
+function sectionHasBlockingContent(text, heading) {
+  const section = extractSection(text, heading);
+  if (!section) return false;
+  return !/^\s*(none|n\/a|no\b|no issues|empty|\(none\))\s*\.?\s*$/i.test(section.trim());
+}
+function extractSection(text, heading) {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:^|\\n)\\s*#{1,6}\\s*${escaped}\\s*\\n([\\s\\S]*?)(?=\\n\\s*#{1,6}\\s+|$)`,
+    "i"
+  );
+  const match = text.match(pattern);
+  const body = match?.[1]?.trim();
+  return body ? body : void 0;
+}
+function excerpt(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 20).trimEnd()}
+...(truncated)`;
 }
 
 // src/coordination/director-tools.ts
@@ -12929,13 +13318,13 @@ function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
     properties: {
-      role: {
+      description: {
         type: "string",
-        description: "Roster role id. When set, the spawn uses the matching config from the roster and ignores other fields."
+        description: "What the subagent has to do, in free form. PREFER THIS over `role`: the dispatcher scores it against the capability metadata of every agent in the roster and picks the specialist, which is more reliable than recalling a role id from a list of 77. Only reach for `role` when you are certain which one you want."
       },
-      description: {
+      role: {
         type: "string",
-        description: "Free-form task description. When `role` is not set, the director uses the smart dispatcher to route this to the best-matching catalog agent. Use this when you don't know the exact role name."
+        description: "Roster role id. When set, the spawn uses the matching config from the roster, ignores other fields, and SKIPS DISPATCH ENTIRELY \u2014 so a half-remembered id silently costs you the specialist. Prefer `description` unless the id is certain."
       },
       name: {
         type: "string",
@@ -12981,7 +13370,7 @@ function makeSpawnTool(director, roster) {
   return {
     name: "spawn_subagent",
     description: "Create a new subagent under this director (own LLM context, own budget). NON-BLOCKING: returns a `subagentId` immediately without triggering any model call. Pair with `assign_task` to send work and `await_tasks` to retrieve the result later \u2014 this is the async-delegation pattern that lets the leader keep working while the subagent runs in its own context.",
-    usageHint: "Pass `role` (matches the roster), `description` (smart dispatch to best agent), or `name` + `provider`/`model`. Returns `{ subagentId }`. Use this instead of `delegate` when you want to fan out to multiple subagents or keep the leader unblocked while work runs in parallel.",
+    usageHint: "Pass `description` (what the work is \u2014 dispatched to the best-matching specialist), or `role` when you are certain of the id, or `name` + `provider`/`model`. Returns `{ subagentId }`. The roster is deep and specialised: there is very likely an agent built for this exact job, so describe the work rather than defaulting to a generalist. Use this instead of `delegate` when you want to fan out to multiple subagents or keep the leader unblocked while work runs in parallel.",
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
@@ -13485,8 +13874,9 @@ function composeDirectorPrompt(parts = {}) {
   const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
   if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
   if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
-    sections.push(`Available roles you can spawn:
-${parts.rosterSummary.trim()}`);
+    sections.push(
+      "Roles you can spawn. This roster is deep and specialised \u2014 before handing work to a generalist, look for the agent built for exactly this job, and prefer describing the work (`description`) over recalling an id (`role`) so the dispatcher can find it:\n" + parts.rosterSummary.trim()
+    );
   }
   if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
     sections.push(parts.basePrompt.trim());
@@ -13523,37 +13913,47 @@ ${parts.skills.trim()}`);
   }
   return sections.join("\n\n");
 }
+var ROSTER_SUMMARY_MAX_CHARS = 150;
+function nameAddsInformation(roleId, name) {
+  const flatten = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return flatten(name) !== flatten(roleId);
+}
 function rosterSummaryFromConfigs(roster) {
   const lines = [];
   for (const [roleId, cfg] of Object.entries(roster)) {
     const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
-    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
+    const label = nameAddsInformation(roleId, cfg.name) ? ` (${cfg.name})` : "";
+    const capability = cfg.dispatch?.summary?.trim() || // Fallback headline: a role prompt that opens with a markdown heading
+    // would otherwise render as "# Generic Project Agent", which reads as
+    // formatting rather than as a capability.
+    (cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").replace(/^#+\s*/, "").trim() : "");
+    const headline = capability.length > ROSTER_SUMMARY_MAX_CHARS ? `${capability.slice(0, ROSTER_SUMMARY_MAX_CHARS - 1).trimEnd()}\u2026` : capability;
     const tail = headline ? ` \u2014 ${headline}` : "";
-    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
+    lines.push(`- ${roleId}${label}${tag}${tail}`);
   }
   return lines.join("\n");
 }
 
 // src/coordination/director-session.ts
 import * as fsp18 from "node:fs/promises";
-import * as path28 from "node:path";
+import * as path30 from "node:path";
 
 // src/storage/session-store.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
 import * as fsp17 from "node:fs/promises";
-import * as path27 from "node:path";
+import * as path29 from "node:path";
 
 // src/session-catalog/client.ts
 import { spawn as spawn2 } from "node:child_process";
 import * as fs3 from "node:fs";
 import * as net from "node:net";
-import * as path17 from "node:path";
+import * as path19 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/session-catalog/endpoint.ts
 import { createHash as createHash2 } from "node:crypto";
 import * as os2 from "node:os";
-import * as path16 from "node:path";
+import * as path18 from "node:path";
 
 // src/session-catalog/protocol.ts
 var SESSION_CATALOG_PROTOCOL_VERSION = 1;
@@ -13566,7 +13966,7 @@ function encodeSessionCatalogMessage(message) {
 // src/session-catalog/endpoint.ts
 var SESSION_CATALOG_METADATA_FILE = ".session-catalog-server.json";
 function normalizedPath(value) {
-  const resolved = path16.resolve(value);
+  const resolved = path18.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function sessionCatalogProjectServerKey(projectDir) {
@@ -13577,10 +13977,10 @@ function sessionCatalogProjectServerEndpoint(projectDir) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-session-catalog-v${SESSION_CATALOG_PROTOCOL_VERSION}-${key}`;
   }
-  return path16.join(os2.tmpdir(), `wssc-v${SESSION_CATALOG_PROTOCOL_VERSION}`, `${key}.sock`);
+  return path18.join(os2.tmpdir(), `wssc-v${SESSION_CATALOG_PROTOCOL_VERSION}`, `${key}.sock`);
 }
 function sessionCatalogProjectServerMetadataPath(projectDir) {
-  return path16.join(projectDir, SESSION_CATALOG_METADATA_FILE);
+  return path18.join(projectDir, SESSION_CATALOG_METADATA_FILE);
 }
 
 // src/session-catalog/client.ts
@@ -13615,7 +14015,7 @@ function resolveSessionCatalogProjectServerUrl(moduleUrl = import.meta.url, exis
   return availability.kind === "available" ? availability.url : null;
 }
 function normalize2(value) {
-  const resolved = path17.resolve(value);
+  const resolved = path19.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function delay(ms) {
@@ -14060,18 +14460,32 @@ function ulid(seedTime = Date.now()) {
 }
 
 // src/utils/session-scoped-path.ts
-import * as path18 from "node:path";
+import * as path20 from "node:path";
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path18.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path18.relative(path18.resolve(dir), resolved);
-  if (rel.startsWith("..") || path18.isAbsolute(rel)) {
+  const resolved = path20.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path20.relative(path20.resolve(dir), resolved);
+  if (rel.startsWith("..") || path20.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
 }
+var SESSION_SIDECAR_JSONL_SUFFIXES = [
+  ".replay.jsonl",
+  ".audit.jsonl",
+  ".annotations.jsonl"
+];
+var RESERVED_SESSION_JSONL_NAMES = /* @__PURE__ */ new Set([
+  "_index.jsonl",
+  "_mailbox.jsonl"
+]);
+function isSessionTranscriptFileName(name) {
+  if (!name.endsWith(".jsonl")) return false;
+  if (RESERVED_SESSION_JSONL_NAMES.has(name)) return false;
+  return !SESSION_SIDECAR_JSONL_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
 function invalid(sessionId) {
   return new FsError({
     message: `Invalid sessionId: ${sessionId}`,
@@ -14089,7 +14503,7 @@ function truncate3(s, max) {
 // src/storage/file-session-writer.ts
 import { closeSync, createReadStream as createReadStream2, fsyncSync, openSync, writeSync } from "node:fs";
 import * as fsp7 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as path21 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
 // src/storage/session-workspace-checkpoints.ts
@@ -14355,7 +14769,7 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path19.join(opts.dir, `${path19.basename(id)}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path21.join(opts.dir, `${path21.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
     this.checkpointCas = opts.checkpointCas;
@@ -15247,7 +15661,7 @@ var FileSessionWriter = class _FileSessionWriter {
 import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash3, randomUUID as randomUUID11 } from "node:crypto";
 import * as fsp8 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as path22 from "node:path";
 
 // src/storage/storage-concurrency.ts
 async function mapWithConcurrency(items, concurrency, mapper) {
@@ -15278,13 +15692,13 @@ function sha256(content) {
   return createHash3("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative4 = path20.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path20.isAbsolute(relative4);
+  const relative4 = path22.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path22.isAbsolute(relative4);
 }
 function normalizeRelative(input) {
-  if (!input || path20.isAbsolute(input)) return null;
+  if (!input || path22.isAbsolute(input)) return null;
   const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
-  const resolved = path20.posix.normalize(normalized);
+  const resolved = path22.posix.normalize(normalized);
   if (!resolved || resolved === "." || resolved === ".." || resolved.startsWith("../")) return null;
   return resolved;
 }
@@ -15299,8 +15713,8 @@ var SessionCheckpointCas = class {
   projectRoot;
   runGit;
   constructor(opts) {
-    this.rootDir = path20.resolve(opts.rootDir);
-    this.projectRoot = path20.resolve(opts.projectRoot);
+    this.rootDir = path22.resolve(opts.rootDir);
+    this.projectRoot = path22.resolve(opts.projectRoot);
     this.runGit = opts.runGit ?? defaultRunGit;
   }
   async capture(_sessionId, _promptIndex) {
@@ -15325,7 +15739,7 @@ var SessionCheckpointCas = class {
       relativePaths,
       CAPTURE_CONCURRENCY,
       async (relative4) => {
-        const absolute = path20.resolve(this.projectRoot, ...relative4.split("/"));
+        const absolute = path22.resolve(this.projectRoot, ...relative4.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
           unresolved.push({ path: relative4, reason: "path escapes project root" });
           return null;
@@ -15334,8 +15748,8 @@ var SessionCheckpointCas = class {
           const stat10 = await fsp8.lstat(absolute);
           if (stat10.isSymbolicLink()) {
             const linkTarget = await fsp8.readlink(absolute);
-            const resolvedLink = path20.resolve(path20.dirname(absolute), linkTarget);
-            if (path20.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
+            const resolvedLink = path22.resolve(path22.dirname(absolute), linkTarget);
+            if (path22.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
                 path: relative4,
                 reason: "symlink target escapes project root"
@@ -15397,7 +15811,7 @@ var SessionCheckpointCas = class {
     };
   }
   async materialize(checkpoint, targetRoot) {
-    const target = path20.resolve(targetRoot);
+    const target = path22.resolve(targetRoot);
     if (target === this.projectRoot) {
       throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
     }
@@ -15437,10 +15851,10 @@ var SessionCheckpointCas = class {
       try {
         const output = await this.safeOutputPath(target, realTarget, entry.path);
         if (entry.state === "symlink") {
-          if (path20.isAbsolute(entry.linkTarget)) {
+          if (path22.isAbsolute(entry.linkTarget)) {
             throw new Error("absolute symlink target refused");
           }
-          const resolvedLink = path20.resolve(path20.dirname(output), entry.linkTarget);
+          const resolvedLink = path22.resolve(path22.dirname(output), entry.linkTarget);
           if (!isInside(target, resolvedLink)) throw new Error("symlink target escapes checkpoint root");
         }
         prepared.push({
@@ -15468,7 +15882,7 @@ var SessionCheckpointCas = class {
           await fsp8.unlink(output).catch((err) => {
             if (err.code !== "ENOENT") throw err;
           });
-          await fsp8.mkdir(path20.dirname(output), { recursive: true });
+          await fsp8.mkdir(path22.dirname(output), { recursive: true });
           await fsp8.symlink(entry.linkTarget, output);
           writtenFiles.push(entry.path);
           continue;
@@ -15485,15 +15899,15 @@ var SessionCheckpointCas = class {
   }
   objectPath(hash) {
     if (!HASH_RE.test(hash)) throw new Error(`Invalid CAS object hash: ${hash}`);
-    return path20.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
+    return path22.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
   }
   manifestPath(hash) {
     if (!HASH_RE.test(hash)) throw new Error(`Invalid checkpoint manifest hash: ${hash}`);
-    return path20.join(this.rootDir, "manifests", `${hash}.json`);
+    return path22.join(this.rootDir, "manifests", `${hash}.json`);
   }
   async putBlob(hash, content) {
     const target = this.objectPath(hash);
-    await fsp8.mkdir(path20.dirname(target), { recursive: true });
+    await fsp8.mkdir(path22.dirname(target), { recursive: true });
     try {
       const existing = await fsp8.readFile(target);
       if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
@@ -15501,9 +15915,9 @@ var SessionCheckpointCas = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    const temp = path20.join(
-      path20.dirname(target),
-      `.${path20.basename(target)}.${process.pid}.${randomUUID11()}.tmp`
+    const temp = path22.join(
+      path22.dirname(target),
+      `.${path22.basename(target)}.${process.pid}.${randomUUID11()}.tmp`
     );
     let handle;
     try {
@@ -15564,7 +15978,7 @@ var SessionCheckpointCas = class {
   async safeOutputPath(target, realTarget, relative4) {
     const normalized = normalizeRelative(relative4);
     if (!normalized) throw new Error("invalid relative path");
-    const output = path20.resolve(target, ...normalized.split("/"));
+    const output = path22.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
     let probe = output;
     for (; ; ) {
@@ -15574,7 +15988,7 @@ var SessionCheckpointCas = class {
         return output;
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
-        const parent = path20.dirname(probe);
+        const parent = path22.dirname(probe);
         if (parent === probe) throw err;
         probe = parent;
       }
@@ -15638,13 +16052,13 @@ function generateSessionId(startedAt, _model) {
 }
 
 // src/storage/session-id-resolver.ts
-import * as path21 from "node:path";
+import * as path23 from "node:path";
 function resolveSessionId(query, candidateIds) {
   const normalized = query.trim();
   if (!normalized) return { status: "missing", query: normalized };
   const uniqueIds = [...new Set(candidateIds)];
   if (uniqueIds.includes(normalized)) return { status: "resolved", id: normalized };
-  const leaf = (id) => path21.posix.basename(id.replace(/\\/g, "/"));
+  const leaf = (id) => path23.posix.basename(id.replace(/\\/g, "/"));
   const exactLeafMatches = uniqueIds.filter((id) => leaf(id) === normalized);
   if (exactLeafMatches.length === 1) {
     return { status: "resolved", id: exactLeafMatches[0] };
@@ -15695,13 +16109,13 @@ function scrubPersistedSessionSummary(summary, scrubber2) {
 // src/storage/session-resume-validation.ts
 import { createHash as createHash4 } from "node:crypto";
 import * as fsp9 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as path24 from "node:path";
 var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative4 = path22.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path22.isAbsolute(relative4);
+  const relative4 = path24.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path24.isAbsolute(relative4);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -15712,7 +16126,7 @@ function latestObservations(events, projectRoot) {
     if (event.type !== "file_observation" || typeof event.path !== "string" || event.path.length === 0 || typeof event.hash !== "string" || !/^[a-f\d]{64}$/i.test(event.hash)) {
       continue;
     }
-    const normalized = path22.resolve(projectRoot, event.path);
+    const normalized = path24.resolve(projectRoot, event.path);
     latest.set(normalized, {
       path: normalized,
       hash: event.hash.toLowerCase(),
@@ -15770,7 +16184,7 @@ async function validateOne(observation, lexicalRoot, realRoot) {
   }
 }
 async function validateResumeFileObservations(events, projectRoot) {
-  const lexicalRoot = path22.resolve(projectRoot);
+  const lexicalRoot = path24.resolve(projectRoot);
   const realRoot = await fsp9.realpath(lexicalRoot).catch(() => lexicalRoot);
   const observations = latestObservations(events, lexicalRoot);
   const results = await mapWithConcurrency(
@@ -15784,11 +16198,20 @@ async function validateResumeFileObservations(events, projectRoot) {
     staleFiles: results.filter((entry) => entry !== null)
   };
 }
+var RESUME_NOTICE_HEADERS = [
+  "[SESSION RESUME FILE VALIDATION]",
+  "[SESSION RESUME INTERRUPTED WORK]"
+];
+function isResumeNoticeMessage(message) {
+  if (message.role !== "system" || typeof message.content !== "string") return false;
+  return RESUME_NOTICE_HEADERS.some((header) => message.content === header || message.content.startsWith(`${header}
+`));
+}
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
-  const root = path22.resolve(projectRoot);
+  const root = path24.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative4 = path22.relative(root, entry.path);
+    const relative4 = path24.relative(root, entry.path);
     const display = isInside2(root, entry.path) ? relative4 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
@@ -15813,22 +16236,22 @@ function formatInterruptedToolNotice(pendingToolUseCount) {
 
 // src/storage/session-store/delete-session-artifacts.ts
 import * as fsp10 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path26 from "node:path";
 
 // src/storage/session-store/paths.ts
-import * as path23 from "node:path";
+import * as path25 from "node:path";
 function sessionPath(storeDir, id, ext) {
   return sessionScopedPath(storeDir, id, ext);
 }
 function shardManifestPath(storeDir, shardKey) {
-  return shardKey ? path23.join(storeDir, shardKey, "_manifest.json") : path23.join(storeDir, "_manifest.json");
+  return shardKey ? path25.join(storeDir, shardKey, "_manifest.json") : path25.join(storeDir, "_manifest.json");
 }
 function shardKeyForSessionId(id) {
-  const dirName = path23.dirname(id);
+  const dirName = path25.dirname(id);
   return dirName === "." ? "" : dirName;
 }
 async function ensureShardDir(storeDir, id) {
-  const dirPath = path23.dirname(sessionScopedPath(storeDir, id, ""));
+  const dirPath = path25.dirname(sessionScopedPath(storeDir, id, ""));
   await ensureDir(dirPath);
   return dirPath;
 }
@@ -15839,9 +16262,9 @@ async function deleteSessionArtifacts({
   id,
   jsonlPath
 }) {
-  const shardDir = path24.dirname(jsonlPath);
-  const base = path24.basename(id);
-  const sessDir = path24.join(shardDir, base);
+  const shardDir = path26.dirname(jsonlPath);
+  const base = path26.basename(id);
+  const sessDir = path26.join(shardDir, base);
   const deletions = [
     fsp10.unlink(jsonlPath),
     fsp10.unlink(sessionPath(rootDir, id, ".summary.json")),
@@ -15894,13 +16317,10 @@ async function assertSessionCanBeDeleted(sessionId, isSessionInUse) {
 function shouldSkipSessionDirectoryEntry(name) {
   return name.startsWith(".") && name !== ".wrongstack" || name === "shared" || name === "subagents" || name === "attachments";
 }
-function isSessionJsonlFileName(name) {
-  return name.endsWith(".jsonl") && name !== "_index.jsonl";
-}
 
 // src/storage/session-store/directory-session-files.ts
 import * as fsp11 from "node:fs/promises";
-import * as path25 from "node:path";
+import * as path27 from "node:path";
 function sessionIdForFile(prefix, name) {
   const base = name.replace(/\.jsonl$/, "");
   return prefix ? `${prefix}/${base}` : base;
@@ -15921,13 +16341,13 @@ async function collectSessionFiles(dir, prefix = "", depth = 0) {
     if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
     if (entry.isDirectory()) {
       dirEntries.push(entry);
-    } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
-      files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path25.join(dir, entry.name) });
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
+      files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path27.join(dir, entry.name) });
     }
   }
   const childFileArrays = await Promise.all(
     dirEntries.map(
-      (entry) => collectSessionFiles(path25.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
+      (entry) => collectSessionFiles(path27.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
     )
   );
   return [...childFileArrays.flat(), ...files];
@@ -15945,13 +16365,13 @@ async function collectSessionIds(dir, prefix = "", depth = 0) {
     if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
     if (entry.isDirectory()) {
       dirEntries.push(entry);
-    } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
       fileIds.push(sessionIdForFile(prefix, entry.name));
     }
   }
   const childIdArrays = await Promise.all(
     dirEntries.map(
-      (entry) => collectSessionIds(path25.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
+      (entry) => collectSessionIds(path27.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
     )
   );
   return [...childIdArrays.flat(), ...fileIds];
@@ -16047,13 +16467,13 @@ function inheritsIntoFork(event) {
 
 // src/storage/session-store/fork-session.ts
 async function forkSession(host, id, opts = {}) {
-  const parent = await host.load(id);
-  let boundary = parent.events.length - 1;
+  const parentEvents = await host.readRawEvents(id);
+  let boundary = parentEvents.length - 1;
   let targetCheckpoint;
   if (opts.checkpointPromptIndex !== void 0) {
     boundary = -1;
-    for (let i = 0; i < parent.events.length; i++) {
-      const event = parent.events[i];
+    for (let i = 0; i < parentEvents.length; i++) {
+      const event = parentEvents[i];
       if (event?.type === "checkpoint" && event.promptIndex === opts.checkpointPromptIndex) {
         boundary = i;
         targetCheckpoint = event;
@@ -16063,15 +16483,18 @@ async function forkSession(host, id, opts = {}) {
       throw new Error(`Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`);
     }
   }
-  const parentPrefix = parent.events.slice(0, boundary + 1);
+  const parentPrefix = parentEvents.slice(0, boundary + 1);
   const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
   const checkpointHash = createHash5("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
   const inherited = parentPrefix.filter(inheritsIntoFork);
+  const start = parentEvents.find(
+    (event) => event.type === "session_start"
+  );
   const writer = await host.create({
     id: "",
-    title: parent.metadata.title,
-    model: parent.metadata.model,
-    provider: parent.metadata.provider
+    title: "",
+    model: start?.model,
+    provider: start?.provider
   });
   try {
     await writer.append({
@@ -16177,6 +16600,17 @@ var SessionLoadCache = class {
     this.entries.clear();
     this.bytes = 0;
   }
+  /**
+   * A hit hands back fresh `messages` / `events` arrays over the cached
+   * contents.
+   *
+   * The entry outlives every caller, and callers treat what they get as their
+   * own: `resume()` passes `messages` straight into a live conversation, and
+   * anything walking `events` may splice it. Returning the cached arrays
+   * themselves let one caller's edit rewrite what the next one loads. The
+   * elements are still shared — copying them would defeat the cache — so
+   * entries remain read-only *contents* behind private containers.
+   */
   getFresh(id, stat10, full) {
     const cached = this.entries.get(id);
     if (!cached || cached.mtimeMs !== stat10.mtimeMs || cached.size !== stat10.size) {
@@ -16184,8 +16618,11 @@ var SessionLoadCache = class {
     }
     this.entries.delete(id);
     this.entries.set(id, cached);
-    if (full) return cached.data;
-    return { ...cached.data, messages: [] };
+    return {
+      ...cached.data,
+      messages: full ? [...cached.data.messages] : [],
+      events: [...cached.data.events]
+    };
   }
   set(id, stat10, data) {
     this.delete(id);
@@ -16374,6 +16811,9 @@ function stripSnapshotPayload(event) {
   event.messagesOmitted = event.messages.length;
   event.messages = [];
 }
+function isStrippedSnapshot(event) {
+  return event.messages.length === 0 && typeof event.messagesOmitted === "number" && event.messagesOmitted > 0;
+}
 function isSessionEventLike(value) {
   return value !== null && typeof value === "object" && typeof value.type === "string" && typeof value.ts === "string";
 }
@@ -16403,7 +16843,12 @@ function replaySessionEvent(params) {
       emitDamaged(params, `Ignored malformed message_updated event at index ${ev.index}`);
     }
   } else if (ev.type === "messages_replaced" && ev.version === 1) {
-    if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored messages_replaced event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
       exactJournalActive = true;
     } else {
       emitDamaged(params, "Ignored malformed messages_replaced event");
@@ -16419,9 +16864,16 @@ function replaySessionEvent(params) {
       emitDamaged(params, `Ignored malformed messages_dropped event (count ${String(ev.count)})`);
     }
   } else if (ev.type === "context_snapshot") {
-    if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored context_snapshot event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
       emitDamaged(params, "Ignored malformed context_snapshot event");
     }
+  } else if (ev.type === "messages_replaced" || ev.type === "message_appended" || ev.type === "message_updated" || ev.type === "messages_dropped") {
+    emitDamaged(params, `Ignored ${ev.type} event with unsupported version`);
   } else if (!exactJournalActive && ev.type === "user_input") {
     openToolUses.clear();
     messages.push({ role: "user", content: ev.content, ts: ev.ts });
@@ -16472,15 +16924,15 @@ function emitDamaged(params, detail) {
 
 // src/storage/session-store/prune-helpers.ts
 import * as fsp13 from "node:fs/promises";
-import * as path26 from "node:path";
+import * as path28 from "node:path";
 function isPrunableSessionJsonl(name) {
-  return name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
+  return isSessionTranscriptFileName(name);
 }
 async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   const cutoff = Date.now() - maxAgeDays * 864e5;
   let deleted = 0;
   const pruneFile = async (dir, name, prefix) => {
-    const jsonlPath = path26.join(dir, name);
+    const jsonlPath = path28.join(dir, name);
     try {
       const stat10 = await fsp13.stat(jsonlPath);
       if (stat10.mtimeMs >= cutoff) return;
@@ -16499,7 +16951,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
       continue;
     }
     if (!entry.isDirectory()) continue;
-    const dateDir = path26.join(storeDir, entry.name);
+    const dateDir = path28.join(storeDir, entry.name);
     const files = await fsp13.readdir(dateDir, { withFileTypes: true }).catch(() => []);
     for (const file of files) {
       if (!file.isFile() || !isPrunableSessionJsonl(file.name)) continue;
@@ -16508,7 +16960,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dateDir = path26.join(storeDir, entry.name);
+    const dateDir = path28.join(storeDir, entry.name);
     try {
       const remaining = await fsp13.readdir(dateDir);
       if (remaining.length === 0) {
@@ -16861,9 +17313,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
-    this.projectRoot = opts.projectRoot ? path27.resolve(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? path29.resolve(opts.projectRoot) : void 0;
     this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
-      rootDir: path27.join(this.dir, "_cas"),
+      rootDir: path29.join(this.dir, "_cas"),
       projectRoot: this.projectRoot
     }) : void 0;
     this.events = opts.events;
@@ -16874,7 +17326,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.onAppendBatch = opts.onAppendBatch;
     const builtRuntime = import.meta.url.includes("/dist/");
     this.catalogClient = this.projectRoot && (builtRuntime || process.env["WRONGSTACK_SESSION_CATALOG_FORCE"] === "1") && resolveSessionCatalogProjectServerUrl() ? new SessionCatalogProjectClient({
-      projectDir: path27.dirname(this.dir),
+      projectDir: path29.dirname(this.dir),
       projectRoot: this.projectRoot
     }) : void 0;
   }
@@ -16906,7 +17358,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   // ── Storage event helpers ───────────────────────────────────────────────────
   /** Absolute path to the session index file. */
   get indexFile() {
-    return path27.join(this.dir, "_index.jsonl");
+    return path29.join(this.dir, "_index.jsonl");
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
@@ -16997,6 +17449,21 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async fork(id, opts = {}) {
     return forkSession(this, id, opts);
   }
+  /**
+   * Implements {@link SessionForkHost.readRawEvents} — the parent stream a fork
+   * inherits, unmodified.
+   *
+   * Deliberately NOT `load()`: that loader empties superseded snapshot payloads
+   * in place and front-drops events past its retention budget, both of which
+   * are correct for reconstructing a conversation and wrong for copying a
+   * journal prefix into a child. Streaming with an accept-everything predicate
+   * keeps the scrubbing contract (`searchEvents` scrubs each line the same way
+   * `load()` does) without either transformation.
+   */
+  async readRawEvents(id) {
+    const hits = await this.searchEvents(id, () => true);
+    return hits.map((hit) => hit.event);
+  }
   /**
    * Capture the deterministic post-tool workspace identity through the store-owned CAS.
    */
@@ -17085,14 +17552,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
         ts: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
+    const carriedMessages = data.messages.filter((message) => !isResumeNoticeMessage(message));
     const resumedData = {
       ...data,
       ...resumeValidation ? { resumeValidation } : {},
-      ...noticeMessages.length > 0 ? { messages: [...data.messages, ...noticeMessages] } : {}
+      messages: [...carriedMessages, ...noticeMessages]
     };
     let handle;
     try {
-      handle = await fsp17.open(file, "a", 384);
+      handle = await openSessionForAppend(file);
     } catch (err) {
       emitSessionStoreError(this.events, canonicalId, file, "resume", toErrorMessage(err), false);
       throw new Error(
@@ -17119,7 +17587,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
           // Shard directory (sessions/<date>/) — must match create() so the
           // .summary.json sidecar lands next to the JSONL instead of the
           // sessions root (where summaryFor() would never find it).
-          dir: path27.dirname(file),
+          dir: path29.dirname(file),
           filePath: file,
           secretScrubber: this.secretScrubber,
           checkpointCas: this.checkpointCas,
@@ -17271,10 +17739,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = criteria.limit ?? 100;
     if (this.catalogClient) {
       const records = await this.catalogClient.call("list_catalog", {
-        limit: Math.min(1e3, Math.max(limit, 100)),
-        ...criteria.titleContains ? { search: criteria.titleContains } : {}
+        limit,
+        ...criteria
       });
-      return this.scrubSummaries(records).filter((summary) => matchesSessionFilter(summary, criteria)).slice(0, limit);
+      return this.scrubSummaries(records);
     }
     try {
       const indexed = await this.readIndex();
@@ -17499,11 +17967,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return shardKeys;
   }
   async readOrBuildShardManifest(shardKey) {
-    const cached = this.shardManifestCache.get(shardKey);
-    if (cached) return cached;
     const manifestPath = this.shardManifestPath(shardKey);
+    const cached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
+    if (cached) return cached;
     return withFileLock(manifestPath, async () => {
-      const lockedCached = this.shardManifestCache.get(shardKey);
+      const lockedCached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
       if (lockedCached) return lockedCached;
       const entry = await readOrBuildShardManifestEntry({
         shardKey,
@@ -17514,12 +17982,40 @@ var DefaultSessionStore = class _DefaultSessionStore {
         summaryHeaderFor: (ref) => this.summaryHeaderFor(ref),
         summaryFor: (id) => this.summaryFor(id)
       });
-      this.shardManifestCache.set(shardKey, entry);
+      try {
+        const stat10 = await fsp17.stat(manifestPath);
+        this.shardManifestCache.set(shardKey, {
+          entry,
+          mtimeMs: stat10.mtimeMs,
+          size: stat10.size,
+          ino: stat10.ino
+        });
+      } catch {
+        this.shardManifestCache.delete(shardKey);
+      }
       return entry;
     });
   }
+  /**
+   * Shard manifests are invalidated by other store processes via atomic
+   * delete/rebuild. Validate the in-memory projection against the persisted
+   * file so one long-lived process cannot retain another process's stale view.
+   */
+  async freshShardManifestCacheEntry(shardKey, manifestPath) {
+    const cached = this.shardManifestCache.get(shardKey);
+    if (!cached) return void 0;
+    try {
+      const stat10 = await fsp17.stat(manifestPath);
+      if (stat10.mtimeMs === cached.mtimeMs && stat10.size === cached.size && stat10.ino === cached.ino) {
+        return cached.entry;
+      }
+    } catch {
+    }
+    this.shardManifestCache.delete(shardKey);
+    return void 0;
+  }
   async collectSessionFilesInShard(shardKey) {
-    const dir = shardKey ? path27.join(this.dir, shardKey) : this.dir;
+    const dir = shardKey ? path29.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
     return shardKey ? entries.filter((entry) => entry.id.startsWith(`${shardKey}/`)) : entries.filter((entry) => !entry.id.includes("/"));
   }
@@ -17797,6 +18293,23 @@ var DefaultSessionStore = class _DefaultSessionStore {
     });
   }
 };
+async function openSessionForAppend(file) {
+  const handle = await fsp17.open(file, "a+", 384);
+  try {
+    const stat10 = await handle.stat();
+    if (stat10.size > 0) {
+      const tail = Buffer.allocUnsafe(1);
+      const { bytesRead } = await handle.read(tail, 0, 1, stat10.size - 1);
+      if (bytesRead === 1 && tail[0] !== 10) {
+        await handle.appendFile("\n", "utf8");
+      }
+    }
+    return handle;
+  } catch (err) {
+    await handle.close().catch(() => void 0);
+    throw err;
+  }
+}
 
 // src/coordination/director-session.ts
 function makeDirectorSessionFactory(opts) {
@@ -17806,9 +18319,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path28.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path30.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path28.join(opts.sessionsRoot, runId);
+    dir = path30.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -17832,7 +18345,7 @@ function makeDirectorSessionFactory(opts) {
 }
 async function readDirectorSubagentSession(args) {
   if (!args.sessionsRoot) return null;
-  const filePath = path28.join(args.sessionsRoot, args.directorRunId, `${args.subagentId}.jsonl`);
+  const filePath = path30.join(args.sessionsRoot, args.directorRunId, `${args.subagentId}.jsonl`);
   let raw;
   try {
     raw = await fsp18.readFile(filePath, "utf8");
@@ -18286,12 +18799,97 @@ var FallbackProfileManager = class {
     return this.resolveRefs([ref], exclude);
   }
   /**
-   * Resolve every usable configured target as an uncapped last-resort chain.
+   * Resolve every usable configured target as a bounded last-resort chain.
    * Normal smart defaults stay bounded; callers append this only after the
-   * preferred chain and only when automatic fallback is enabled.
+   * preferred chain and only when automatic fallback is enabled. The cap
+   * ({@link MAX_LAST_RESORT_CANDIDATES}) prevents a config with many providers
+   * from producing a degenerate chain of doomed requests during a systemic
+   * outage — by this point the smart default, bridge, and default profile
+   * have already failed.
    */
   resolveAllConfigured(exclude) {
-    return this.smartDefault(exclude, Number.POSITIVE_INFINITY);
+    return this.smartDefault(exclude, this.lastResortCap());
+  }
+  /**
+   * Effective cap for the last-resort append. Reads the user-configurable
+   * {@link Config.fallbackMaxLastResortCandidates} when set and valid;
+   * otherwise falls back to the compiled-in default
+   * {@link MAX_LAST_RESORT_CANDIDATES}.
+   */
+  lastResortCap() {
+    const configured = this.config.fallbackMaxLastResortCandidates;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured >= 0) {
+      return Math.floor(configured);
+    }
+    return MAX_LAST_RESORT_CANDIDATES;
+  }
+  /**
+   * Build the complete fallback candidate chain shared by the agent-loop
+   * extension and the one-shot orchestrator. Centralizes the bridge → primary →
+   * selected → default-profile → all-configured ladder and the fromExplicitSource
+   * gate so both consumers produce identical ordering and depth semantics.
+   *
+   * Layering (each step deduped against all prior):
+   *  1. Bridge (emergency continuity route).
+   *  2. Configured primary, when the live context drifted from it.
+   *  3. The selected chain (explicit refs → named profile → smart default),
+   *     via {@link resolveEffective}.
+   *  4. The "default" profile — extra depth, ONLY when the chain was auto-derived.
+   *  5. Every other configured provider — last resort, ONLY when the chain was
+   *     auto-derived AND `effectiveFallbackAuto` is true.
+   *
+   * Returns the empty chain when `closedWorld` is true and no explicit
+   * refs/profile resolved — a model allowlist never leaks to unlisted models.
+   *
+   * @internal caller-aware options (primary, closedWorld) are accepted because
+   *   the agent loop has context the manager does not own; the resolution
+   *   pipeline itself is identical for both callers.
+   */
+  resolveCandidates(current, opts = {}) {
+    const configuredPrimary = opts.primary ?? {
+      providerId: this.config.provider,
+      model: this.config.model
+    };
+    const configFallbackAuto = this.config.fallbackAuto;
+    const effectiveFallbackAuto = configFallbackAuto !== void 0 && configFallbackAuto !== null ? configFallbackAuto : !opts.closedWorld;
+    const explicitRefs = opts.fallbackModels ?? this.config.fallbackModels;
+    const explicitUsable = explicitRefs !== void 0 && explicitRefs.length > 0 && this.resolveRefs(explicitRefs, current).length > 0;
+    const profileUsable = opts.fallbackProfile !== void 0 && this.hasProfile(opts.fallbackProfile) && this.resolve(opts.fallbackProfile, { exclude: current }).length > 0;
+    const fromExplicitSource = explicitUsable || profileUsable;
+    const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? this.resolveRefs(explicitRefs, current) : opts.fallbackProfile ? this.resolve(opts.fallbackProfile, { exclude: current }) : FREEZER_EMPTY : this.resolveEffective({
+      fallbackModels: explicitRefs,
+      fallbackProfile: opts.fallbackProfile,
+      fallbackAuto: effectiveFallbackAuto,
+      exclude: current
+    });
+    const candidates = [];
+    if (opts.closedWorld) {
+      candidates.push(...selectedChain);
+    } else {
+      candidates.push(...this.resolveBridge(current));
+      if (!(configuredPrimary.providerId === current.providerId && configuredPrimary.model === current.model)) {
+        candidates.push({
+          providerId: configuredPrimary.providerId,
+          model: configuredPrimary.model,
+          providerSwitched: configuredPrimary.providerId !== current.providerId
+        });
+      }
+      candidates.push(...selectedChain);
+      if (!fromExplicitSource && effectiveFallbackAuto && opts.fallbackProfile !== "default") {
+        candidates.push(...this.resolve("default", { exclude: current }));
+      }
+      if (!fromExplicitSource && effectiveFallbackAuto) {
+        const cap = this.lastResortCap();
+        if (cap > 0) {
+          const usedKeys = new Set(
+            candidates.map((c) => `${c.providerId}/${c.model}`)
+          );
+          const lastResort = this.smartDefault(current, Number.POSITIVE_INFINITY).filter((c) => !usedKeys.has(`${c.providerId}/${c.model}`)).slice(0, cap);
+          candidates.push(...lastResort);
+        }
+      }
+    }
+    return dedupeChain(candidates, current);
   }
   // ── Provider availability (read-only) ──────────────────────────────────
   checkProvider(providerId) {
@@ -18415,7 +19013,20 @@ var FallbackProfileManager = class {
     );
   }
 };
+var MAX_LAST_RESORT_CANDIDATES = 12;
 var FREEZER_EMPTY = Object.freeze([]);
+function dedupeChain(entries, current) {
+  const seen = /* @__PURE__ */ new Set();
+  const currentKey = `${current.providerId}/${current.model}`;
+  return Object.freeze(
+    entries.filter((entry) => {
+      const key = `${entry.providerId}/${entry.model}`;
+      if (key === currentKey || seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    })
+  );
+}
 
 // src/core/fallback-model.ts
 function fallbackProfileChain(config, profileName) {
@@ -21054,7 +21665,7 @@ var Director = class _Director {
 // src/coordination/fleet-manager.ts
 import { randomUUID as randomUUID15 } from "node:crypto";
 import * as fsp20 from "node:fs/promises";
-import * as path29 from "node:path";
+import * as path31 from "node:path";
 var FleetManager = class {
   /** The fleet-wide event bus. */
   fleet;
@@ -21387,7 +21998,7 @@ var FleetManager = class {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp20.mkdir(path29.dirname(this.manifestPath), { recursive: true });
+    await fsp20.mkdir(path31.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -21550,7 +22161,7 @@ var FleetManager = class {
 };
 
 // src/coordination/remote-mailbox.ts
-import * as path33 from "node:path";
+import * as path35 from "node:path";
 
 // src/coordination/mailbox-constants.ts
 var HQ_MAILBOX_SNAPSHOT_MIN_INTERVAL_MS = 1e4;
@@ -21560,13 +22171,13 @@ var UNREAD_CHECK_MIN_INTERVAL_MS = 1e3;
 import { spawn as spawn5 } from "node:child_process";
 import * as fs4 from "node:fs";
 import * as net2 from "node:net";
-import * as path31 from "node:path";
+import * as path33 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/coordination/mailbox-project-server-endpoint.ts
 import { createHash as createHash6 } from "node:crypto";
 import * as os3 from "node:os";
-import * as path30 from "node:path";
+import * as path32 from "node:path";
 
 // src/coordination/mailbox-project-server-protocol.ts
 var MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION = 4;
@@ -21599,7 +22210,7 @@ function encodeMailboxProjectServerMessage(message) {
 // src/coordination/mailbox-project-server-endpoint.ts
 var MAILBOX_PROJECT_SERVER_METADATA_FILE = ".mailbox-server.json";
 function normalizeLocalPath(value) {
-  const resolved = path30.resolve(value);
+  const resolved = path32.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function mailboxProjectServerKey(projectDir) {
@@ -21610,14 +22221,14 @@ function mailboxProjectServerEndpoint(projectDir) {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\wrongstack-mailbox-v${MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION}-${key}`;
   }
-  return path30.join(
+  return path32.join(
     os3.tmpdir(),
     `wsmb-v${MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION}`,
     `${key}.sock`
   );
 }
 function mailboxProjectServerMetadataPath(projectDir) {
-  return path30.join(path30.resolve(projectDir), MAILBOX_PROJECT_SERVER_METADATA_FILE);
+  return path32.join(path32.resolve(projectDir), MAILBOX_PROJECT_SERVER_METADATA_FILE);
 }
 
 // src/coordination/mailbox-project-server-client.ts
@@ -21628,7 +22239,7 @@ var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
 var AUTH_RETRY_DELAY_MS = 150;
 var AUTH_RETRY_MAX_ATTEMPTS = 13;
 function normalizePath(value) {
-  const resolved = path31.resolve(value);
+  const resolved = path33.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function resolveProjectServerUrl() {
@@ -21656,7 +22267,7 @@ function isUnauthorizedMailboxError(error) {
 var MailboxProjectServerConnection = class {
   constructor(projectDir) {
     this.projectDir = projectDir;
-    this.projectDir = path31.resolve(projectDir);
+    this.projectDir = path33.resolve(projectDir);
     this.endpoint = mailboxProjectServerEndpoint(this.projectDir);
     this.state = {
       status: isMailboxProjectServerAvailable() ? "offline" : "unavailable",
@@ -22334,9 +22945,9 @@ var CredentialVerifyThrottle = class {
 var credentialVerifyThrottle = new CredentialVerifyThrottle();
 
 // src/coordination/global-mailbox-paths.ts
-import * as path32 from "node:path";
+import * as path34 from "node:path";
 function resolveProjectDir(projectRoot, globalRoot) {
-  return path32.join(globalRoot, "projects", projectSlug(projectRoot));
+  return path34.join(globalRoot, "projects", projectSlug(projectRoot));
 }
 
 // src/coordination/sqlite-mailbox.ts
@@ -22386,8 +22997,8 @@ var RemoteMailbox = class {
       hqPublisher,
       eventEmitter
     } : optionsOrProjectDir;
-    this.projectDir = path33.resolve(options.projectDir);
-    this.messagePath = path33.join(this.projectDir, SQLITE_MAILBOX_FILE);
+    this.projectDir = path35.resolve(options.projectDir);
+    this.messagePath = path35.join(this.projectDir, SQLITE_MAILBOX_FILE);
     this.registryPath = this.messagePath;
     this.clientRegistryPath = this.messagePath;
     this.events = options.events;
@@ -22633,7 +23244,7 @@ var RemoteMailbox = class {
       this.hqEventPending.clear();
       return;
     }
-    const mailboxId = `${path33.basename(this.projectDir)}:mailbox`;
+    const mailboxId = `${path35.basename(this.projectDir)}:mailbox`;
     const inFlight = this.query({ includeDeleted: true, limit: 100 }).then((messages) => {
       const message = messages.find((candidate) => candidate.id === event.messageId);
       const action = event.type === "message.sent" ? "message.sent" : "message.updated";
@@ -22656,7 +23267,7 @@ var RemoteMailbox = class {
     if (!publisher || !event.startsWith("mailbox.agent_") && !event.startsWith("mailbox.client_")) {
       return;
     }
-    const mailboxId = `${path33.basename(this.projectDir)}:mailbox`;
+    const mailboxId = `${path35.basename(this.projectDir)}:mailbox`;
     const record = typeof payload === "object" && payload !== null ? payload : {};
     const agentId = typeof record["agentId"] === "string" ? record["agentId"] : void 0;
     const action = event === "mailbox.agent_registered" ? "agent.registered" : event === "mailbox.agent_heartbeat" ? "agent.heartbeat" : event === "mailbox.agent_deregistered" ? "agent.deregistered" : void 0;
@@ -22679,7 +23290,7 @@ function createProjectMailbox(options) {
   return new RemoteMailbox(options);
 }
 function getSharedProjectMailbox(projectDir, events, hqPublisher) {
-  const key = path33.resolve(projectDir);
+  const key = path35.resolve(projectDir);
   let projectCache = sharedRemoteMailboxes.get(key);
   if (!projectCache) {
     projectCache = {
@@ -25047,16 +25658,16 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     throw validationError(`routePath must not start with '?' (got ${JSON.stringify(routePath)})`);
   }
   const queryIndex = url.indexOf("?");
-  const path38 = queryIndex === -1 ? url : url.slice(0, queryIndex);
+  const path40 = queryIndex === -1 ? url : url.slice(0, queryIndex);
   if (actor !== void 0) {
-    const requiredCapability = requiredCredentialCapability(method, path38);
+    const requiredCapability = requiredCredentialCapability(method, path40);
     if (requiredCapability === void 0) {
       writeJson(response, 403, {
-        error: { code: "FORBIDDEN", message: `credential access is not permitted for ${method} ${path38}` }
+        error: { code: "FORBIDDEN", message: `credential access is not permitted for ${method} ${path40}` }
       });
       return;
     }
-    if (path38 !== "/mailbox/send" && !hasMailboxCapability(actor, requiredCapability)) {
+    if (path40 !== "/mailbox/send" && !hasMailboxCapability(actor, requiredCapability)) {
       writeJson(response, 403, {
         error: {
           code: "FORBIDDEN",
@@ -25066,7 +25677,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
       return;
     }
   }
-  if (method === "POST" && path38 === "/mailbox/send") {
+  if (method === "POST" && path40 === "/mailbox/send") {
     const input = validateSend(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) {
       const requiredCapability = requiredSendCapability(input.type);
@@ -25084,7 +25695,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 201, await mailbox.send(input));
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/query") {
+  if (method === "POST" && path40 === "/mailbox/query") {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -25104,7 +25715,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { data: projected, count: projected.length });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/check") {
+  if (method === "POST" && path40 === "/mailbox/check") {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -25138,7 +25749,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { data: projected, count: projected.length });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/ack") {
+  if (method === "POST" && path40 === "/mailbox/ack") {
     const input = validateAck(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) {
       input.readerId = actor.actorId;
@@ -25152,7 +25763,7 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { updated: projectedAck });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/ack-many") {
+  if (method === "POST" && path40 === "/mailbox/ack-many") {
     const input = validateAckMany(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) {
       const requestedIds = new Set(input.acks.map((ack) => ack.messageId));
@@ -25170,54 +25781,54 @@ async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, me
     writeJson(response, 200, { updated: projectedMany, count: projectedMany.length });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/unread-count") {
+  if (method === "POST" && path40 === "/mailbox/unread-count") {
     const body = await readJsonBody(request, maxBodyBytes);
     const count = actor === void 0 ? await mailbox.unreadCount(requireString2(body, "forAgentId")) : await unreadCountForActor(mailbox, actor);
     writeJson(response, 200, { count });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/agents/register") {
+  if (method === "POST" && path40 === "/mailbox/agents/register") {
     const input = validateAgentRegistration(await readJsonBody(request, maxBodyBytes), actor);
     await mailbox.registerAgent(input);
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/agents/heartbeat") {
+  if (method === "POST" && path40 === "/mailbox/agents/heartbeat") {
     const input = validateAgentHeartbeat(await readJsonBody(request, maxBodyBytes), actor?.actorId);
     if (actor !== void 0) input.agentId = actor.actorId;
     await mailbox.heartbeat(input);
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/register-client") {
+  if (method === "POST" && path40 === "/mailbox/register-client") {
     await mailbox.registerClient(
       validateClientRegistration(await readJsonBody(request, maxBodyBytes))
     );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/heartbeat") {
+  if (method === "POST" && path40 === "/mailbox/heartbeat") {
     await mailbox.clientHeartbeat(
       validateClientHeartbeat(await readJsonBody(request, maxBodyBytes))
     );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && path38 === "/mailbox/purge-clients") {
+  if (method === "POST" && path40 === "/mailbox/purge-clients") {
     writeJson(response, 200, { ok: true, purged: await mailbox.purgeClients() });
     return;
   }
-  if (method === "GET" && path38 === "/mailbox/agents") {
+  if (method === "GET" && path40 === "/mailbox/agents") {
     const agents = await mailbox.getAgentStatuses();
     writeJson(response, 200, { data: agents, count: agents.length });
     return;
   }
-  if (method === "GET" && path38 === "/mailbox/agents/online") {
+  if (method === "GET" && path40 === "/mailbox/agents/online") {
     const agents = await mailbox.getOnlineAgents();
     writeJson(response, 200, { data: agents, count: agents.length });
     return;
   }
-  if (method === "GET" && path38 === "/mailbox/events" && eventEmitter) {
+  if (method === "GET" && path40 === "/mailbox/events" && eventEmitter) {
     const queryContext = parseSinceMs(url, defaultMaxAgeMs);
     if ("error" in queryContext) {
       writeJson(response, 400, { error: queryContext.error });
@@ -25326,25 +25937,25 @@ function requiredSendCapability(type) {
   }
   return "mail.send.informational";
 }
-function requiredCredentialCapability(method, path38) {
-  if (method === "POST" && path38 === "/mailbox/send") return "mail.send.informational";
-  if (method === "POST" && (path38 === "/mailbox/query" || path38 === "/mailbox/check")) {
+function requiredCredentialCapability(method, path40) {
+  if (method === "POST" && path40 === "/mailbox/send") return "mail.send.informational";
+  if (method === "POST" && (path40 === "/mailbox/query" || path40 === "/mailbox/check")) {
     return "mail.read.self";
   }
-  if (method === "POST" && (path38 === "/mailbox/ack" || path38 === "/mailbox/ack-many")) {
+  if (method === "POST" && (path40 === "/mailbox/ack" || path40 === "/mailbox/ack-many")) {
     return "mail.ack.self";
   }
-  if (method === "POST" && path38 === "/mailbox/unread-count") return "mail.read.self";
-  if (method === "POST" && path38 === "/mailbox/agents/register") {
+  if (method === "POST" && path40 === "/mailbox/unread-count") return "mail.read.self";
+  if (method === "POST" && path40 === "/mailbox/agents/register") {
     return "mail.presence.register.self";
   }
-  if (method === "POST" && path38 === "/mailbox/agents/heartbeat") {
+  if (method === "POST" && path40 === "/mailbox/agents/heartbeat") {
     return "mail.presence.heartbeat.self";
   }
-  if (method === "GET" && (path38 === "/mailbox/agents" || path38 === "/mailbox/agents/online")) {
+  if (method === "GET" && (path40 === "/mailbox/agents" || path40 === "/mailbox/agents/online")) {
     return "mail.presence.read";
   }
-  if (method === "GET" && path38 === "/mailbox/events") return "mail.events.self";
+  if (method === "GET" && path40 === "/mailbox/events") return "mail.events.self";
   return void 0;
 }
 function extractEventTimestamp(event) {
@@ -25547,11 +26158,11 @@ var NULL_FLEET_BUS = new FleetBus();
 
 // src/coordination/package-author-tracker.ts
 import * as fs5 from "node:fs/promises";
-import * as path34 from "node:path";
+import * as path36 from "node:path";
 var DEFAULT_MAX_ENTRIES2 = 1e4;
 var LOG_FILENAME2 = "package-authors.json";
 function logPath2(storageDir) {
-  return path34.join(storageDir, LOG_FILENAME2);
+  return path36.join(storageDir, LOG_FILENAME2);
 }
 async function loadLog2(storageDir, projectRoot) {
   try {
@@ -25573,7 +26184,7 @@ async function saveLog2(storageDir, log) {
 `);
 }
 function detectEcosystem(manifestPath) {
-  const name = path34.win32.basename(manifestPath).toLowerCase();
+  const name = path36.win32.basename(manifestPath).toLowerCase();
   if (name === "package.json") return "npm";
   if (name === "go.mod") return "go";
   if (name === "cargo.toml") return "cargo";
@@ -26456,12 +27067,12 @@ import { randomBytes as randomBytes2 } from "node:crypto";
 import * as fsp21 from "node:fs/promises";
 import { execFile } from "node:child_process";
 import * as os4 from "node:os";
-import * as path35 from "node:path";
+import * as path37 from "node:path";
 var MAILBOX_BRIDGE_LOCK_FILENAME = ".mailbox-bridge.lock";
 var MAILBOX_BRIDGE_TOKEN_FILENAME = ".mailbox.token";
 async function acquireOrJoin(opts) {
-  const lockPath = path35.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path35.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path37.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path37.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const inspected = await readLockForInspection(lockPath);
   if (inspected.kind === "live") {
     const existing = inspected.lock;
@@ -26489,8 +27100,8 @@ async function acquireOrJoin(opts) {
   return { kind: "acquired", lock: tentative, tokenPath };
 }
 async function finalize(projectDir, tentative, boundPort) {
-  const lockPath = path35.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path35.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path37.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path37.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const finalized = {
     ...tentative,
     port: boundPort,
@@ -26501,8 +27112,8 @@ async function finalize(projectDir, tentative, boundPort) {
   return finalized;
 }
 async function release(projectDir, generation) {
-  const lockPath = path35.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path35.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path37.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path37.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   try {
     const raw = await fsp21.readFile(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -26536,7 +27147,7 @@ async function readLockForInspection(lockPath) {
   return { kind: "live", lock: parsed };
 }
 async function readLiveLock(projectDir) {
-  const lockPath = path35.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const lockPath = path37.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
   const result = await readLockForInspection(lockPath);
   if (result.kind === "live") {
     return { kind: "live", lock: result.lock };
@@ -26547,7 +27158,7 @@ async function readLiveLock(projectDir) {
   return { kind: "absent" };
 }
 async function atomicWriteJson(targetPath, value) {
-  const dir = path35.dirname(targetPath);
+  const dir = path37.dirname(targetPath);
   await fsp21.mkdir(dir, { recursive: true });
   const tmp = `${targetPath}.tmp.${process.pid}.${randomBytes2(4).toString("hex")}`;
   const body = JSON.stringify(value, null, 2) + "\n";
@@ -26710,8 +27321,8 @@ function extractManifestPath(msg) {
   }
   return void 0;
 }
-function isManifestFile(path38) {
-  const name = pathBasename(path38).toLowerCase();
+function isManifestFile(path40) {
+  const name = pathBasename(path40).toLowerCase();
   const manifests = [
     "package.json",
     "package-lock.json",
@@ -27005,7 +27616,7 @@ var AdaptiveConcurrencyController = class {
 // src/coordination/agent-monitor.ts
 import { createReadStream as createReadStream5 } from "node:fs";
 import * as fs6 from "node:fs/promises";
-import * as path36 from "node:path";
+import * as path38 from "node:path";
 import { createInterface as createInterface5 } from "node:readline";
 var AgentMonitorService = class _AgentMonitorService {
   _fleetBus;
@@ -27109,7 +27720,7 @@ var AgentMonitorService = class _AgentMonitorService {
     return this.getAllSessions();
   }
   async _readTranscriptFile(subagentId) {
-    const file = path36.join(this._transcriptsDir, subagentId, "transcript.jsonl");
+    const file = path38.join(this._transcriptsDir, subagentId, "transcript.jsonl");
     const accessible = await fs6.access(file).then(() => true).catch(() => false);
     if (!accessible) return [];
     const out = [];
@@ -27450,12 +28061,12 @@ var AgentMonitorService = class _AgentMonitorService {
     this._writeDrain = drain;
   }
   async _appendToFile(subagentId, line) {
-    const dir = path36.join(this._transcriptsDir, subagentId);
+    const dir = path38.join(this._transcriptsDir, subagentId);
     if (!this._ensuredDirs.has(dir)) {
       await fs6.mkdir(dir, { recursive: true });
       this._ensuredDirs.add(dir);
     }
-    const filePath = path36.join(dir, "transcript.jsonl");
+    const filePath = path38.join(dir, "transcript.jsonl");
     try {
       await fs6.appendFile(filePath, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
     } catch (error) {
@@ -27848,7 +28459,7 @@ import { randomUUID as randomUUID20 } from "node:crypto";
 // src/coordination/knowledge-graph.ts
 import { randomUUID as randomUUID18 } from "node:crypto";
 import * as fsp22 from "node:fs/promises";
-import * as path37 from "node:path";
+import * as path39 from "node:path";
 var DEFAULT_MAX_NODES = 2e3;
 var MAX_SUBSCRIPTIONS = 1e3;
 var MAX_PENDING_DELIVERIES_PER_SUBSCRIPTION = 1e3;
@@ -27883,8 +28494,8 @@ var KnowledgeGraph = class _KnowledgeGraph {
     return this.index;
   }
   constructor(sessionDir, maxNodes = DEFAULT_MAX_NODES, compactEveryWrites = Math.max(1e3, maxNodes * 4)) {
-    this.filePath = path37.join(sessionDir, "_knowledge_graph");
-    this.graphFilePath = path37.join(this.filePath, "graph.jsonl");
+    this.filePath = path39.join(sessionDir, "_knowledge_graph");
+    this.graphFilePath = path39.join(this.filePath, "graph.jsonl");
     this.maxNodes = maxNodes;
     this.compactEveryWrites = Math.max(1, Math.floor(compactEveryWrites));
   }
@@ -30285,6 +30896,8 @@ export {
   DEFAULT_SUBAGENT_BASELINE,
   DELIVERY_AGENTS,
   DEPENDENCY_FILE_PATTERNS,
+  DIRECTIVE_QUARANTINE_MAX_UTILITY,
+  DIRECTIVE_QUARANTINE_MIN_APPLIED,
   DISCOVERY_AGENTS,
   DOMAIN_AGENTS,
   DefaultBrainArbiter,
@@ -30380,6 +30993,7 @@ export {
   collabPauseMiddleware,
   composeDirectorPrompt,
   composeSubagentPrompt,
+  consolidatedDocumentPath,
   createAgentMonitorService,
   createDelegateTool,
   createLedgerGuardBrainArbiter,
@@ -30392,6 +31006,9 @@ export {
   credentialVerifyThrottle,
   detectEcosystem,
   detectLearnedConflicts,
+  directiveTrials,
+  directiveUtility,
+  directiveWasApplied,
   dispatchAgent,
   evaluateAutoOptimize,
   finalize,
@@ -30409,6 +31026,7 @@ export {
   isMailboxLeader,
   isMailboxMessageVisibleTo,
   isMailboxProjectServerAvailable,
+  isProvenDirective,
   isValidMatrixKey,
   listProjectAgentLearnedEntries,
   listProjectAgentRoles,
@@ -30424,6 +31042,8 @@ export {
   loadRoleKnowledgeManifest,
   loadSkillAffinity,
   mailboxIdentityBase,
+  mailboxProjectServerEndpoint,
+  mailboxProjectServerMetadataPath,
   mailboxSessionTag,
   makeAgentSubagentRunner,
   makeAskResultTool,
@@ -30456,10 +31076,13 @@ export {
   parseMailboxQueryInput,
   parseMailboxSendInput,
   phaseForRole,
+  quarantinePath,
   rankRoleSkills,
   readLiveLock,
+  readQuarantinedDirectives,
   readRawLearnedEntries,
   readSubagentStructuredReport,
+  recordDirectiveOutcomes,
   recordFileAction,
   recordPackageAction,
   recordSkillLoad,
@@ -30482,6 +31105,7 @@ export {
   resolveRoleSkillCandidates,
   resolveSubagentModelTarget,
   resolveSubagentWorktreeDecision,
+  retiredDirectivesToWarnAbout,
   roleNeedsIndependentReviewModel,
   rosterSummaryFromConfigs,
   routeDirectiveToSkill,
@@ -30489,6 +31113,8 @@ export {
   saveProjectAgentConsolidated,
   saveProjectSkillAugmentation,
   scoreAgents,
+  scoreSkillAffinity,
+  scrubRetiredLines,
   sessionRecipient,
   setSkillPinned,
   slugifyProjectAgentRole,