@wrongstack/core 0.303.0 → 0.305.1

package/dist/coordination/agents/index.js

@@ -1,6 +1,6 @@
 // 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
@@ -143,8 +143,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/security/capabilities.ts
 var ToolCapabilities = {
@@ -777,8 +777,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) {
@@ -916,6 +916,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*-->/
@@ -1034,6 +1049,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));
@@ -1045,7 +1064,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) {
@@ -1069,17 +1089,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,
@@ -1129,10 +1163,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}**`);
@@ -1156,26 +1195,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 "";
   }
@@ -1185,28 +1353,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;
@@ -1277,10 +1444,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}
 
@@ -1300,6 +1470,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)
 
@@ -1313,6 +1484,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",
@@ -1392,7 +1578,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
@@ -1400,23 +1586,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),
@@ -1425,14 +1614,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);
@@ -1440,7 +1635,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");
@@ -1511,7 +1706,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)}
@@ -1826,17 +2021,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 "";
   }
@@ -1845,13 +2040,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 {
@@ -1866,7 +2080,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}\`)`,
     "",
@@ -1880,7 +2112,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**.`,
     "",
@@ -1894,6 +2129,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})`,
     "",
@@ -1902,6 +2138,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",
@@ -1927,7 +2173,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 ?? {})) {
@@ -1976,9 +2222,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) {
@@ -1992,24 +2240,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) {
@@ -2079,6 +2333,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];
@@ -2125,13 +2386,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(
@@ -2141,7 +2403,8 @@ async function optimizeProjectAgentLearning(role, projectRoot, options = {}) {
             normalizedRole,
             skill,
             directives,
-            loadProjectSkillAugmentation(normalizedRole, skill, projectRoot)
+            existing,
+            retiredDirectivesToWarnAbout(normalizedRole, directives, projectRoot, skill)
           ),
           options
         );
@@ -2154,6 +2417,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;
@@ -2168,6 +2432,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;
@@ -2186,6 +2451,7 @@ async function optimizeProjectAgentLearning(role, projectRoot, options = {}) {
       error: error instanceof Error ? error.message : "failed to persist consolidation"
     };
   }
+  recordProjectAgentOptimizePass(normalizedRole, projectRoot);
   return {
     ...base,
     status: "optimized",
@@ -2223,17 +2489,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"),
@@ -2374,26 +2639,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 "";
     }
@@ -2421,7 +2790,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;
 }
@@ -2429,7 +2798,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;
@@ -2437,7 +2806,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;
@@ -2463,18 +2832,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. -->
@@ -2487,7 +2856,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",
@@ -2498,7 +2867,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;
       }
@@ -2565,25 +2934,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];
@@ -2724,7 +3093,7 @@ ${learnedContent}`);
     }
   }
   const effectiveProjectRoot = projectRoot || process.cwd();
-  const learnedFilePath = path9.join(
+  const learnedFilePath = path11.join(
     effectiveProjectRoot,
     ".wrongstack",
     "agents",
@@ -2751,6 +3120,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):
@@ -2816,7 +3187,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;
@@ -2834,13 +3205,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);
@@ -2854,12 +3225,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,
@@ -3032,7 +3409,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 {
@@ -3040,16 +3417,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,
@@ -3145,38 +3520,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 {
     }
   }
@@ -3195,7 +3570,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 {
     }
@@ -3221,16 +3596,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);
@@ -3287,8 +3662,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. */
@@ -5783,6 +6166,10 @@ export {
   DEFAULT_AUTO_OPTIMIZE_POLICY,
   DEFAULT_EAGER_SKILL_LIMIT,
   DELIVERY_AGENTS,
+  DIRECTIVE_PROVEN_MIN_APPLIED,
+  DIRECTIVE_PROVEN_MIN_UTILITY,
+  DIRECTIVE_QUARANTINE_MAX_UTILITY,
+  DIRECTIVE_QUARANTINE_MIN_APPLIED,
   DISCOVERY_AGENTS,
   DOMAIN_AGENTS,
   HEAVY_BUDGET,
@@ -5801,6 +6188,7 @@ export {
   RUNTIME_CAPABILITY_MANIFEST,
   SHADOW_AGENT_SKILLS,
   SKILL_AUGMENTATION_MAX_BYTES,
+  SKILL_EVIDENCE_HALF_LIFE_DAYS,
   SPECIALIST_TOOLS,
   TOOLS,
   VERIFY_AGENTS,
@@ -5828,10 +6216,14 @@ export {
   classifyLearnedEntry,
   clearProjectAgentConsolidated,
   clearProjectSkillAugmentation,
+  consolidatedDocumentPath,
   createProjectAgent,
   createProjectAgentRoster,
   decomposeLearnedEntry,
   detectLearnedConflicts,
+  directiveTrials,
+  directiveUtility,
+  directiveWasApplied,
   enforceLearnedBudget,
   evaluateAutoOptimize,
   existsSync4 as existsSync,
@@ -5842,6 +6234,7 @@ export {
   isConsolidated,
   isDeprecatedRuntimeToolAlias,
   isKnownRuntimeCapability,
+  isProvenDirective,
   listProjectAgentLearnedEntries,
   listProjectAgentRoles,
   listProjectSkillAugmentations,
@@ -5864,8 +6257,12 @@ export {
   parseLearnedEntryStamp,
   parseStructuredLearnedEntries,
   parseStructuredLearnedEntriesFromContent,
+  quarantinePath,
   rankRoleSkills,
+  readQuarantinedDirectives,
   readRawLearnedEntries,
+  recordDirectiveOutcomes,
+  recordProjectAgentOptimizePass,
   recordSkillLoad,
   recordSkillOutcome,
   refreshProjectAgentIdentity,
@@ -5876,11 +6273,14 @@ export {
   resetProjectAgentIdentity,
   resolveAutoOptimizePolicy,
   resolveRoleSkillCandidates,
+  retiredDirectivesToWarnAbout,
   routeDirectiveToSkill,
   runtimeCapabilityForTool,
   runtimeToolReferencesFromText,
   saveProjectAgentConsolidated,
   saveProjectSkillAugmentation,
+  scoreSkillAffinity,
+  scrubRetiredLines,
   setSkillPinned,
   slugifyProjectAgentRole,
   splitLearnedEntries,