@wrongstack/core 0.306.4 → 0.307.0

package/dist/coordination/agents/index.js

@@ -1,6 +1,6 @@
 // src/coordination/agents/agent-prompts.ts
-import { readFileSync as readFileSync10, statSync as statSync2 } from "node:fs";
-import * as path12 from "node:path";
+import { readFileSync as readFileSync11, statSync as statSync2 } from "node:fs";
+import * as path13 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/utils/wstack-paths.ts
@@ -143,591 +143,502 @@ function resolveWstackPaths(opts) {
 }
 
 // src/coordination/agents/project-agent-identity.ts
-import { existsSync as existsSync4, readFileSync as readFileSync9 } from "node:fs";
-import * as path11 from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync10 } from "node:fs";
+import * as path12 from "node:path";
 
-// src/security/capabilities.ts
-var ToolCapabilities = {
-  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
-  SHELL_ARBITRARY: "shell.arbitrary",
-  /**
-   * Can execute the `exec` tool's allowlisted commands.
-   *
-   * "Restricted" describes the command NAME check, not the resulting power.
-   * Treat this as equivalent to {@link SHELL_ARBITRARY} when deciding what to
-   * grant: the allowlist includes general-purpose interpreters (`node`,
-   * `python`, `perl`, `ruby`) and, on Windows, the platform shells (`cmd`,
-   * `powershell`, `pwsh`) — deliberately, since without them `exec` cannot run
-   * `dir`/`type`/any cmdlet. `node -e …` or `cmd /c …` therefore reaches
-   * arbitrary execution, and per-argument denylisting cannot close that while
-   * the shells remain (blocking `node -e` still leaves `cmd /c node -e`).
-   *
-   * What actually bounds this is downstream, not the name check: the permission
-   * policy reconstructs the full command line and runs it through the
-   * destructive classifier, so destructive calls still require confirmation.
-   *
-   * Granting `shell.restricted` while withholding `shell.arbitrary` therefore
-   * buys no meaningful reduction in blast radius. Documented rather than
-   * silently implied, because the two read as a narrow/wide pair (WS-083).
-   */
-  SHELL_RESTRICTED: "shell.restricted",
-  /** Can run a restricted project formatter/linter-style command. */
-  SHELL_EXEC: "shell.exec",
-  /** Can read files inside the project (and possibly outside via symlinks if not guarded). */
-  FS_READ: "fs.read",
-  /** Can write / modify / delete files inside the project. */
-  FS_WRITE: "fs.write",
-  /** Can write files outside the current project root (very high risk). */
-  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
-  /** Can perform outbound network requests. */
-  NET_OUTBOUND: "net.outbound",
-  /** Can mutate in-memory session todos only. */
-  SESSION_TODO: "session.todo",
-  /** Can park after-task `<nextsteps>` suggestions for the current turn. */
-  SESSION_NEXTSTEPS: "session.nextsteps",
-  /** Can mutate in-memory session mode only. */
-  SESSION_MODE: "session.mode",
-  /** Can inspect registered tool metadata. */
-  TOOL_META: "tool.meta",
-  /** Can invoke arbitrary registered tools through a meta-tool. */
-  TOOL_MUTATE_ANY: "tool.mutate.any",
-  /** Can read persistent memory. */
-  MEMORY_READ: "memory.read",
-  /** Can write persistent memory. */
-  MEMORY_WRITE: "memory.write",
-  /** Can delete persistent memory. */
-  MEMORY_DELETE: "memory.delete",
-  /** Proxies tools from external MCP servers (unknown capability). */
-  MCP_PROXY: "mcp.proxy",
-  /** Can spawn or manage subagents / multi-agent tasks. */
-  SUBAGENT_SPAWN: "subagent.spawn",
-  /** Can inspect fleet/subagent coordination state without mutating it. */
-  COORDINATION_FLEET_READ: "coordination.fleet.read",
-  /** Can publish attributed, schema-checked events onto the fleet bus. */
-  COORDINATION_FLEET_EMIT: "coordination.fleet.emit",
-  /** Can submit a task-local structured result to the parent Director. */
-  COORDINATION_RESULT_SUBMIT: "coordination.result.submit",
-  /** Can read or write inter-agent mailbox messages. */
-  COORDINATION_MAIL: "coordination.mail",
-  /** Can schedule, inspect, or cancel in-session cron jobs. */
-  COORDINATION_CRON: "coordination.cron",
-  /** Can mutate global or session configuration / trust state. */
-  CONFIG_MUTATE: "config.mutate",
-  /** Can install packages or run package managers with side effects. */
-  PACKAGE_INSTALL: "package.install"
-};
-var DANGEROUS_FOR_SUBAGENTS = [
-  ToolCapabilities.SHELL_ARBITRARY,
-  ToolCapabilities.SHELL_RESTRICTED,
-  ToolCapabilities.SHELL_EXEC,
-  ToolCapabilities.FS_WRITE,
-  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
-  ToolCapabilities.TOOL_MUTATE_ANY,
-  ToolCapabilities.MEMORY_WRITE,
-  ToolCapabilities.MEMORY_DELETE,
-  ToolCapabilities.MCP_PROXY,
-  ToolCapabilities.SUBAGENT_SPAWN,
-  ToolCapabilities.CONFIG_MUTATE,
-  ToolCapabilities.PACKAGE_INSTALL
-];
-var WIDE_SUBAGENT_CAPABILITIES = [
-  ToolCapabilities.FS_READ,
-  ToolCapabilities.FS_WRITE,
-  ToolCapabilities.NET_OUTBOUND,
-  ToolCapabilities.SESSION_TODO,
-  ToolCapabilities.TOOL_META,
-  ToolCapabilities.MEMORY_READ,
-  ToolCapabilities.SHELL_ARBITRARY,
-  ToolCapabilities.SHELL_RESTRICTED,
-  ToolCapabilities.SHELL_EXEC,
-  ToolCapabilities.PACKAGE_INSTALL,
-  // Read-only fleet visibility (fleet_status) — peer awareness has no blast
-  // radius and every fleet worker should coordinate around its peers.
-  ToolCapabilities.COORDINATION_FLEET_READ,
-  ToolCapabilities.COORDINATION_RESULT_SUBMIT
-];
-function clampSubagentCapabilities(requested, ceiling = WIDE_SUBAGENT_CAPABILITIES) {
-  const ceilingSet = new Set(ceiling);
-  const requestedSet = new Set(requested);
+// src/coordination/agents/project-agent-capture-window.ts
+var CAPTURE_COOLDOWN_MS = 12e4;
+var CAPTURE_MAX_PER_SESSION = 3;
+var CAPTURE_SESSION_WINDOW_MS = 30 * 6e4;
+var MAX_WINDOWS = 1e3;
+var windows = /* @__PURE__ */ new Map();
+function currentWindow(key, now) {
+  const existing = windows.get(key);
+  if (!existing || now - existing.windowStartedAt >= CAPTURE_SESSION_WINDOW_MS) {
+    const fresh = {
+      windowStartedAt: now,
+      count: 0,
+      lastCaptureAt: existing?.lastCaptureAt
+    };
+    if (windows.size >= MAX_WINDOWS && !windows.has(key)) {
+      const oldestKey = windows.keys().next().value;
+      if (oldestKey !== void 0) {
+        windows.delete(oldestKey);
+      }
+    }
+    windows.set(key, fresh);
+    return fresh;
+  }
+  windows.delete(key);
+  windows.set(key, existing);
+  return existing;
+}
+function captureWindowState(key, now = Date.now()) {
+  const window = currentWindow(key, now);
   return {
-    granted: ceiling.filter((capability) => requestedSet.has(capability)),
-    dropped: [...requestedSet].filter((capability) => !ceilingSet.has(capability))
+    count: window.count,
+    lastCaptureAt: window.lastCaptureAt,
+    remaining: Math.max(0, CAPTURE_MAX_PER_SESSION - window.count)
   };
 }
+function recordCaptureAttempt(key, now = Date.now()) {
+  const window = currentWindow(key, now);
+  window.count += 1;
+  window.lastCaptureAt = now;
+}
+function resetCaptureWindows() {
+  windows.clear();
+}
+function resetCaptureWindow(key) {
+  windows.delete(key);
+}
 
-// src/types/runtime-capability-manifest.ts
-var PLAYWRIGHT_ALIASES = {
-  playwright_navigate: "browser_navigate",
-  playwright_screenshot: "browser_screenshot",
-  playwright_click: "browser_click",
-  playwright_type: "browser_type",
-  playwright_evaluate: "browser_evaluate",
-  playwright_select_option: "browser_select",
-  playwright_hover: "browser_hover",
-  playwright_fill_form: "browser_type",
-  playwright_wait_for: "browser_wait",
-  playwright_press_key: "browser_press",
-  playwright_drag: "browser_drag"
-};
-var RUNTIME_CAPABILITY_MANIFEST = [
-  {
-    id: "filesystem.read",
-    pack: "core",
-    exposure: "direct",
-    tools: ["read", "grep", "glob", "tree"]
-  },
-  {
-    id: "code.inspect",
-    pack: "core",
-    exposure: "direct",
-    tools: [
-      "codebase-stats",
-      "codebase-search",
-      "codebase-incoming-calls",
-      "codebase-outgoing-calls",
-      "codebase-index",
-      "dead-code-scan",
-      "diff",
-      "json",
-      "logs"
-    ]
-  },
-  {
-    id: "filesystem.write",
-    pack: "development",
-    exposure: "direct",
-    tools: ["write", "edit", "replace", "patch"]
-  },
-  {
-    id: "execution.shell",
-    pack: "development",
-    exposure: "direct",
-    tools: ["bash", "exec", "language", "language_info", "language_package"]
-  },
-  {
-    id: "verification.run",
-    pack: "development",
-    exposure: "direct",
-    tools: ["lint", "format", "typecheck", "test", "e2e_plan"]
-  },
-  {
-    id: "version-control.manage",
-    pack: "development",
-    exposure: "direct",
-    tools: ["git"]
-  },
+// src/coordination/agents/project-agent-consolidation.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2 } from "node:fs";
+import * as path4 from "node:path";
+
+// src/coordination/agents/project-agent-learning-entries.ts
+function tokenOverlap(a, b) {
+  const setA = new Set(a.split(/\s+/));
+  const setB = new Set(b.split(/\s+/));
+  const intersect = new Set([...setA].filter((t) => setB.has(t)));
+  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+  return union.size === 0 ? 0 : intersect.size / union.size;
+}
+function splitLearnedEntries(body) {
+  return body.split(/\n---\n+/).map((entry) => entry.trim()).map(
+    (entry) => entry.replace(/^#\s+Learned (?:wisdom|instructions) for .+$/im, "").replace(/^>\s*Project-specific learning data for[\s\S]*?$/im, "").replace(/^_No learned entries yet\._$/im, "").replace(/^\*Last capture:[^\n]*\*$/im, "").replace(/<!--[\s\S]*?-->/g, "").trim()
+  ).filter(Boolean);
+}
+
+// src/coordination/agents/project-agent-learning-normalize.ts
+var LEARNED_SOFT_LIMIT = 8192;
+var LEARNED_HARD_LIMIT = 16384;
+var LEARNED_ENTRY_MAX_CHARS = 600;
+var MIN_INSTRUCTIVE_LENGTH = 30;
+var NARRATIVE_SENTENCE_STARTS = [
+  /^(?:when|while|during|after|before|once|since)\s+(?:i|we|the agent|i was|i were|i had)\b/i,
+  /^(?:i|we)\s+(?:found|noticed|learned|discovered|realized|saw|encountered|hit|ran into)\b/i,
+  /^(?:i|we)\s+(?:was|were|had|did|ran|tried|attempted|used|modified|changed|updated)\b/i,
+  /^(?:this|that|the)\s+(?:task|session|run|commit|change|pr|pull request|invocation)\b/i,
+  /^(?:in|on|for|at|during)\s+(?:this|that|the)\s+(?:task|session|run|commit|change|pr)\b/i,
+  /^(?:today|yesterday|earlier|just now|recently|lately)\b/i
+];
+var EPHEMERAL_PATTERNS = [
+  // Commit SHAs. A bare `[0-9a-f]{7,40}` also matches ordinary English words
+  // spelled entirely from hex letters ("defaced", "acceded", "effaced"), so
+  // require at least one digit — every real abbreviated SHA has one in
+  // practice, and the false-positive class disappears.
+  { pattern: /\b(?=[0-9a-f]{7,40}\b)[a-f]*\d[0-9a-f]*\b/g, replacement: "" },
   {
-    id: "dependencies.manage",
-    pack: "development",
-    exposure: "on-demand",
-    tools: ["install", "outdated", "audit"]
+    pattern: /\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/g,
+    replacement: ""
   },
   {
-    id: "documentation.author",
-    pack: "development",
-    exposure: "on-demand",
-    tools: ["document", "design", "scaffold"]
+    pattern: /(?<=\b(?:on|from|since|before|after|dated|until)\s)\d{4}-\d{2}-\d{2}\b/gi,
+    replacement: ""
   },
-  {
-    id: "web.research",
-    pack: "core",
-    exposure: "direct",
-    tools: ["search", "fetch"]
-  },
-  {
-    id: "work.plan",
-    pack: "core",
-    exposure: "direct",
-    tools: ["todo", "plan", "task", "kanban", "nextsteps"]
-  },
-  {
-    id: "coordination.mailbox",
-    pack: "fleet",
-    exposure: "direct",
-    tools: ["mailbox", "mail_send", "mail_inbox", "fleet_status"]
-  },
-  {
-    id: "fleet.delegate",
-    pack: "fleet",
-    exposure: "on-demand",
-    tools: [
-      "delegate",
-      "spawn_subagent",
-      "assign_task",
-      "kanban_queue",
-      "await_tasks",
-      "ask_subagent",
-      "ask_result",
-      "roll_up",
-      "quality_gate",
-      "terminate_subagent",
-      "terminate_all",
-      "work_complete",
-      "collab_debug",
-      "fleet_emit",
-      "fleet"
-    ]
-  },
-  {
-    id: "reasoning.oneshot",
-    pack: "core",
-    exposure: "on-demand",
-    tools: ["llm", "council"]
-  },
-  {
-    id: "memory.manage",
-    pack: "memory",
-    exposure: "on-demand",
-    tools: ["remember", "search_memory", "find_related_memories", "forget"]
-  },
-  {
-    id: "memory.curate",
-    pack: "memory",
-    exposure: "on-demand",
-    tools: [
-      "memory_candidates",
-      "memory_update",
-      "memory_delete",
-      "memory_recover",
-      "memory_backfill_recoverable",
-      "memory_for_file",
-      "memory_for_path",
-      "memory_search",
-      "memory_graph",
-      "memory_gather_batch",
-      "memory_verify",
-      "memory_hygiene"
-    ]
-  },
-  {
-    id: "browser.interact",
-    pack: "browser",
-    exposure: "on-demand",
-    tools: [
-      "browser_open",
-      "browser_status",
-      "browser_list",
-      "browser_navigate",
-      "browser_snapshot",
-      "browser_screenshot",
-      "browser_click",
-      "browser_type",
-      "browser_select",
-      "browser_press",
-      "browser_hover",
-      "browser_drag",
-      "browser_wait",
-      "browser_evaluate",
-      "browser_upload",
-      "browser_close"
-    ],
-    aliases: PLAYWRIGHT_ALIASES
-  },
-  {
-    id: "mcp.dynamic",
-    pack: "mcp",
-    exposure: "on-demand",
-    tools: ["mcp_use"]
-  },
-  {
-    id: "automation.manage",
-    pack: "admin",
-    exposure: "on-demand",
-    tools: ["cron_schedule", "cron_list", "cron_cancel", "watch_start", "watch_list", "watch_stop"]
-  },
-  {
-    id: "context.pin",
-    pack: "admin",
-    exposure: "on-demand",
-    tools: ["pin_add", "pin_list", "pin_remove"]
-  },
-  {
-    id: "quality.analyze",
-    pack: "development",
-    exposure: "on-demand",
-    tools: ["dead_code_scan", "detect_duplicate_code", "secret_scanner_test", "error_lens_history"]
-  },
-  {
-    id: "release.manage",
-    pack: "development",
-    exposure: "on-demand",
-    tools: ["git_autocommit", "semver_current", "semver_bump", "semver_changelog"]
-  },
-  {
-    id: "messaging.telegram",
-    pack: "fleet",
-    exposure: "on-demand",
-    tools: ["telegram_send", "telegram_read", "telegram_approve"]
-  },
-  {
-    id: "tools.discover",
-    pack: "admin",
-    exposure: "direct",
-    tools: ["tool_search", "tool_use", "tool_help", "batch_tool_use"]
-  },
-  {
-    id: "runtime.admin",
-    pack: "admin",
-    exposure: "internal",
-    tools: ["set_working_dir", "context_manager", "mode", "skill", "mcp_control"]
-  }
+  { pattern: /\b(?:line|lines?)\s+\d+(?:\s*[-–]\s*\d+)?/gi, replacement: "" },
+  { pattern: /#\s*(?:PR|issue|MR)\s*\d+/gi, replacement: "" },
+  { pattern: /(?<=\s)#\d{1,6}\b/g, replacement: "" }
 ];
-var CAPABILITY_BY_ID = new Map(
-  RUNTIME_CAPABILITY_MANIFEST.map((definition) => [definition.id, definition])
-);
-var CAPABILITY_BY_TOOL = /* @__PURE__ */ new Map();
-var TOOL_ALIASES = /* @__PURE__ */ new Map();
-for (const definition of RUNTIME_CAPABILITY_MANIFEST) {
-  for (const tool of definition.tools) {
-    CAPABILITY_BY_TOOL.set(tool, definition.id);
+function normalizeLearnedEntry(raw) {
+  if (!raw) return null;
+  let cleaned = raw;
+  for (const { pattern, replacement } of EPHEMERAL_PATTERNS) {
+    cleaned = cleaned.replace(pattern, replacement);
   }
-  for (const [alias, tool] of Object.entries(definition.aliases ?? {})) {
-    TOOL_ALIASES.set(alias, tool);
+  const sentences = splitSentences(cleaned);
+  const directiveSentences = [];
+  let hadSubstantiveNarrative = false;
+  for (const sentence of sentences) {
+    const trimmed = sentence.trim();
+    if (!trimmed) continue;
+    if (isNarrativeSentence(trimmed)) {
+      hadSubstantiveNarrative = true;
+      const salvaged = salvageDirectiveTail(trimmed);
+      if (salvaged) directiveSentences.push(salvaged);
+      continue;
+    }
+    directiveSentences.push(trimmed);
+  }
+  if (directiveSentences.length === 0) return null;
+  let normalized = directiveSentences.join(" ").replace(/\s+/g, " ").trim();
+  if (normalized.length > LEARNED_ENTRY_MAX_CHARS) {
+    normalized = truncateToInstructive(normalized, LEARNED_ENTRY_MAX_CHARS);
+    if (normalized.length < MIN_INSTRUCTIVE_LENGTH) return null;
+  }
+  if (normalized.length < MIN_INSTRUCTIVE_LENGTH) return null;
+  if (hadSubstantiveNarrative && directiveSentences.length < sentences.length / 2) {
+    if (normalized.length < MIN_INSTRUCTIVE_LENGTH * 2) return null;
   }
+  return {
+    text: normalized,
+    category: classifyLearnedEntry(normalized)
+  };
 }
-function toolsForRuntimeCapabilities(capabilityIds) {
-  return [
-    ...new Set(
-      capabilityIds.flatMap((id) => {
-        const definition = CAPABILITY_BY_ID.get(id);
-        if (!definition) throw new Error(`Unknown runtime capability: "${id}"`);
-        return definition.tools;
-      })
-    )
-  ];
+function splitSentences(text) {
+  return text.replace(/\s+/g, " ").split(/(?<=[.!?])\s+(?=[A-Z(])/).map((s) => s.trim()).filter(Boolean);
 }
-function normalizeRuntimeToolName(name) {
-  return TOOL_ALIASES.get(name) ?? name;
+function isNarrativeSentence(sentence) {
+  return NARRATIVE_SENTENCE_STARTS.some((re) => re.test(sentence));
 }
-function runtimeCapabilityForTool(name) {
-  return CAPABILITY_BY_TOOL.get(normalizeRuntimeToolName(name));
+function salvageDirectiveTail(sentence) {
+  for (const re of NARRATIVE_SENTENCE_STARTS) {
+    const m = re.exec(sentence);
+    if (!m) continue;
+    const tail = sentence.slice(m[0].length).replace(/^[,\s]+/, "").trim();
+    if (!tail) return null;
+    if (looksDirective(tail)) return tail;
+    return null;
+  }
+  return null;
 }
-function isKnownRuntimeCapability(id) {
-  return CAPABILITY_BY_ID.has(id);
+var DIRECTIVE_VERB_PATTERN = /^(?:always|never|prefer|avoid|use|ensure|verify|check|run|execute|apply|adopt|choose|require|must|should|don'?t|do not|keep|maintain|set|define|specify|validate|confirm|inspect|review|handle|enable|disable|restrict|cap|limit|wrap|isolate|separate|combine|split|merge|refactor|rename|move|extract|inline)\b/i;
+function looksDirective(text) {
+  if (DIRECTIVE_VERB_PATTERN.test(text)) return true;
+  if (/\b(?:is|are|must be|should be|required to)\s+(?:always|never|used|preferred)\b/i.test(text))
+    return true;
+  if (/\b(?:had to|has to|have to|needs? to|must|should|ought to)\s+\w+/i.test(text) && text.length > MIN_INSTRUCTIVE_LENGTH)
+    return true;
+  return false;
 }
-function inferRuntimeCapabilities(toolNames) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const rawName of toolNames) {
-    const id = runtimeCapabilityForTool(rawName);
-    if (id) ids.add(id);
+function truncateToInstructive(text, maxChars) {
+  const sentences = splitSentences(text);
+  let acc = "";
+  for (const s of sentences) {
+    const candidate = acc ? `${acc} ${s}` : s;
+    if (candidate.length > maxChars) break;
+    acc = candidate;
   }
-  return [...ids];
+  if (acc) return acc;
+  return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
 }
-function missingRuntimeCapabilities(required, toolNames) {
-  if (!required || required.length === 0) return [];
-  const available = new Set(inferRuntimeCapabilities(toolNames));
-  return required.filter((id) => !CAPABILITY_BY_ID.has(id) || !available.has(id));
+function classifyLearnedEntry(text) {
+  const lower = text.toLowerCase();
+  if (/\b(?:avoid|never|don'?t|do not|must not|prevent|watch out|beware|pitfall|gotcha|hazard|risk)\b/.test(
+    lower
+  ))
+    return "warning";
+  if (/\b(?:use|prefer|choose|adopt|leverage|apply|switch to|migrate to)\b/.test(lower) || /\b(?:pattern|approach|strategy|technique|idiom)\b/.test(lower))
+    return "pattern";
+  if (/\b(?:always|must|should|require|ensure|verify|check|run|execute|before|after|when)\b/.test(
+    lower
+  ))
+    return "convention";
+  return "fact";
 }
-function missingRequiredRuntimeTools(required, toolNames) {
-  if (!required || required.length === 0) return [];
-  const available = new Set(toolNames.map(normalizeRuntimeToolName));
-  return required.map(normalizeRuntimeToolName).filter((name) => !CAPABILITY_BY_TOOL.has(name) || !available.has(name));
+function normalizeForComparison(text) {
+  return text.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim().split(/\s+/).sort().join(" ");
 }
-function runtimeToolReferencesFromText(text) {
-  const references = /* @__PURE__ */ new Set();
-  for (const match of text.matchAll(/`([a-z][a-z0-9_-]+)`/gi)) {
-    const name = normalizeRuntimeToolName(match[1] ?? "");
-    if (CAPABILITY_BY_TOOL.has(name)) references.add(name);
-  }
-  for (const pattern of [
-    /\b(?:call|use|invoke|run)\s+`([a-z][a-z0-9_-]+)`/gi,
-    /`([a-z][a-z0-9_-]+)`\s+tool\b/gi
-  ]) {
-    for (const match of text.matchAll(pattern)) {
-      references.add(normalizeRuntimeToolName(match[1] ?? ""));
-    }
-  }
-  return [...references];
+
+// 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 isDeprecatedRuntimeToolAlias(name) {
-  return TOOL_ALIASES.has(name) || name.startsWith("mcp__");
+function directiveUtility(entry) {
+  const { applied, wins } = directiveTrials(entry);
+  return (wins + 1) / (applied + 2);
 }
-
-// src/coordination/agents/project-agent-capture-window.ts
-var CAPTURE_COOLDOWN_MS = 12e4;
-var CAPTURE_MAX_PER_SESSION = 3;
-var CAPTURE_SESSION_WINDOW_MS = 30 * 6e4;
-var windows = /* @__PURE__ */ new Map();
-function currentWindow(key, now) {
-  const existing = windows.get(key);
-  if (!existing || now - existing.windowStartedAt >= CAPTURE_SESSION_WINDOW_MS) {
-    const fresh = {
-      windowStartedAt: now,
-      count: 0,
-      lastCaptureAt: existing?.lastCaptureAt
+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*-->/
+  );
+  if (structuredMatch) {
+    const rawCategory = structuredMatch[1];
+    const candidate = parseLearnedCategory(rawCategory);
+    return {
+      capturedAt: typeof structuredMatch[2] === "string" ? structuredMatch[2].trim() : "",
+      category: candidate ?? null
     };
-    windows.set(key, fresh);
-    return fresh;
   }
-  return existing;
-}
-function captureWindowState(key, now = Date.now()) {
-  const window = currentWindow(key, now);
+  const stampMatch = entry.match(/^>\s*(?:\[\s*([\w-]+)\s*\]\s+)?(?:Captured|Taught)\s+(\S+)/m);
+  if (!stampMatch) {
+    return { capturedAt: "", category: null };
+  }
   return {
-    count: window.count,
-    lastCaptureAt: window.lastCaptureAt,
-    remaining: Math.max(0, CAPTURE_MAX_PER_SESSION - window.count)
+    capturedAt: typeof stampMatch[2] === "string" ? stampMatch[2] : "",
+    category: parseLearnedCategory(stampMatch[1]) ?? null
   };
 }
-function recordCaptureAttempt(key, now = Date.now()) {
-  const window = currentWindow(key, now);
-  window.count += 1;
-  window.lastCaptureAt = now;
-}
-function resetCaptureWindows() {
-  windows.clear();
+function parseLearnedCategory(value) {
+  return value === "convention" || value === "pattern" || value === "warning" || value === "fact" ? value : void 0;
 }
-function resetCaptureWindow(key) {
-  windows.delete(key);
+function stripStamp(entry) {
+  return entry.replace(/<!--\s*learned-stamp:[\s\S]*?-->/g, "").replace(/^>\s*(?:\[[\w-]+\]\s+)?(?:Captured|Taught)\s+.+$/m, "").replace(/\n{3,}/g, "\n\n").trim();
 }
-
-// src/coordination/agents/project-agent-config-io.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import * as path4 from "node:path";
-
-// src/coordination/agents/project-agent-config-validation.ts
-import * as path2 from "node:path";
-var PROJECT_AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "tools",
-  "skillNames",
-  "budget",
-  "provider",
-  "model",
-  "allowedCapabilities",
-  "modelPolicy",
-  "fallbackProfile",
-  "cwd",
-  "worktree",
-  "availability"
-]);
-var PROJECT_AGENT_BUDGET_KEYS = /* @__PURE__ */ new Set([
-  "timeoutMs",
-  "idleTimeoutMs",
-  "maxIterations",
-  "maxToolCalls",
-  "maxTokens",
-  "maxCostUsd"
-]);
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function directiveKey(text) {
+  return normalizeForComparison(text);
 }
-function assertStringList(value, field) {
-  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
-    throw new Error(`Project agent config "${field}" must be an array of non-empty strings.`);
-  }
+function decomposeLearnedEntry(text, category) {
+  const what = text;
+  const why = deriveWhy(category, text);
+  const how = extractHow(text);
+  return { what, why, how };
 }
-function validateProjectAgentConfig(value) {
-  if (!isPlainRecord(value)) throw new Error("Project agent config must be an object.");
-  const unknownKey = Object.keys(value).find((key) => !PROJECT_AGENT_CONFIG_KEYS.has(key));
-  if (unknownKey) throw new Error(`Unknown project agent config field: "${unknownKey}".`);
-  if (value.tools !== void 0) assertStringList(value.tools, "tools");
-  if (value.skillNames !== void 0) assertStringList(value.skillNames, "skillNames");
-  if (value.allowedCapabilities !== void 0) {
-    assertStringList(value.allowedCapabilities, "allowedCapabilities");
-  }
-  for (const field of ["provider", "model", "fallbackProfile"]) {
-    const fieldValue = value[field];
-    if (fieldValue !== void 0 && (typeof fieldValue !== "string" || !fieldValue.trim())) {
-      throw new Error(`Project agent config "${field}" must be a non-empty string.`);
-    }
-  }
-  if (value.cwd !== void 0) {
-    if (typeof value.cwd !== "string" || !value.cwd.trim()) {
-      throw new Error('Project agent config "cwd" must be a non-empty relative path.');
-    }
-    const cwd = value.cwd.replace(/\\/g, "/").trim();
-    if (path2.posix.isAbsolute(cwd) || /^[a-z]:\//i.test(cwd) || cwd.split("/").includes("..")) {
-      throw new Error('Project agent config "cwd" must stay inside the assigned checkout.');
-    }
-    value.cwd = cwd;
+var WHY_BY_CATEGORY = {
+  convention: "Established convention for this codebase \u2014 skipping it risks regressions, merge friction, or out-of-sync state with peers.",
+  pattern: "This project's chosen approach \u2014 alternatives were considered and either conflict with existing architecture or were rejected for known reasons.",
+  warning: "Known failure mode \u2014 skipping this has caused real defects in this codebase. The cost of getting it wrong outweighs the cost of the check.",
+  fact: "Current state of the project \u2014 assumed by other conventions, build steps, or peers, so acting on a stale assumption wastes a cycle."
+};
+function deriveWhy(category, text) {
+  const base = WHY_BY_CATEGORY[category];
+  const signals = [];
+  const lower = text.toLowerCase();
+  if (/\bbefore\s+(?:merge|commit|deploy|release|shipping|publishing)\b/.test(lower))
+    signals.push("guard before shipping");
+  if (/\bto\s+avoid\b/.test(lower)) {
+    const m = text.match(/to avoid ([^.!?]+)/i);
+    if (m?.[1]) signals.push(`avoid ${m[1].trim()}`);
   }
-  if (value.worktree !== void 0 && value.worktree !== true && value.worktree !== false && value.worktree !== "auto" && value.worktree !== "required" && value.worktree !== "off") {
-    throw new Error('Project agent config "worktree" must be auto, required, off, or boolean.');
+  if (/\bso\s+(?:that|we|the project)\b/.test(lower)) {
+    const m = text.match(/so (?:that |we |the project )?([^.!?]+)/i);
+    if (m?.[1]) signals.push(`so ${m[1].trim()}`);
   }
-  if (value.modelPolicy !== void 0) validateProjectAgentModelPolicy(value.modelPolicy);
-  if (value.availability !== void 0) validateProjectAgentAvailability(value.availability);
-  if (value.budget !== void 0) {
-    if (!isPlainRecord(value.budget)) {
-      throw new Error('Project agent config "budget" must be an object.');
-    }
-    const unknownBudgetKey = Object.keys(value.budget).find(
-      (key) => !PROJECT_AGENT_BUDGET_KEYS.has(key)
-    );
-    if (unknownBudgetKey) {
-      throw new Error(`Unknown project agent budget field: "${unknownBudgetKey}".`);
-    }
-    for (const [field, amount] of Object.entries(value.budget)) {
-      if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0) {
-        throw new Error(`Project agent budget "${field}" must be a finite non-negative number.`);
-      }
-      if (field !== "maxCostUsd" && !Number.isInteger(amount)) {
-        throw new Error(`Project agent budget "${field}" must be an integer.`);
-      }
-    }
+  if (signals.length === 0) return base;
+  return `${base} Project signals: ${signals.join("; ")}.`;
+}
+function extractHow(text) {
+  const anchors = /* @__PURE__ */ new Set();
+  const backticked = text.match(/`([^`]+)`/g) ?? [];
+  for (const raw of backticked) {
+    const inner = raw.replace(/`/g, "").trim();
+    if (inner.length > 0 && inner.length <= 120) anchors.add(inner);
   }
+  const pathMatches = text.match(
+    /(?:[a-zA-Z0-9_.-]+\/)+[a-zA-Z0-9_.-]+\.(?:tsx|jsonc|json|jsx|yaml|mjs|cjs|yml|ts|js|md)\b/g
+  ) ?? [];
+  for (const p of pathMatches) anchors.add(p);
+  const scoped = text.match(/@[a-z0-9][\w.-]*\/[a-z0-9][\w.-]*/gi) ?? [];
+  for (const p of scoped) anchors.add(p);
+  if (anchors.size === 0) return "";
+  return [...anchors].map((anchor) => `\`${anchor}\``).join("\n");
+}
+function cleanHowLine(line) {
+  let value = line.trim();
+  let previous;
+  do {
+    previous = value;
+    value = value.replace(/^[-*]\s+/, "").replace(/^\*How:\*\s*/i, "").trim();
+  } while (value !== previous);
   return value;
 }
-function validateProjectAgentModelPolicy(value) {
-  if (!isPlainRecord(value)) throw new Error("Project agent modelPolicy must be an object.");
-  const allowedKeys = /* @__PURE__ */ new Set(["allowed", "fallbacks", "strict"]);
-  const unknownKey = Object.keys(value).find((key) => !allowedKeys.has(key));
-  if (unknownKey) throw new Error(`Unknown modelPolicy field: "${unknownKey}".`);
-  const validateTargets = (targets, field, allowEmpty) => {
-    if (!Array.isArray(targets) || !allowEmpty && targets.length === 0) {
-      throw new Error(`Project agent modelPolicy "${field}" must be a non-empty array.`);
-    }
-    for (const target of targets) {
-      if (!isPlainRecord(target) || typeof target.provider !== "string" || !target.provider.trim() || typeof target.model !== "string" || !target.model.trim()) {
-        throw new Error(`Project agent modelPolicy "${field}" contains an invalid target.`);
-      }
-    }
-  };
-  validateTargets(value.allowed, "allowed", false);
-  if (value.fallbacks !== void 0) {
-    validateTargets(value.fallbacks, "fallbacks", true);
-    const allowed = new Set(
-      value.allowed.map(
-        (target) => `${target.provider}\0${target.model}`
-      )
-    );
-    for (const target of value.fallbacks) {
-      if (!allowed.has(`${target.provider}\0${target.model}`)) {
-        throw new Error("Every modelPolicy fallback must also appear in allowed.");
-      }
-    }
-  }
-  if (value.strict !== void 0 && typeof value.strict !== "boolean") {
-    throw new Error('Project agent modelPolicy "strict" must be boolean.');
+function parseStampAttributes(body) {
+  const attributes = {};
+  for (const part of body.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key) attributes[key] = value;
   }
+  return attributes;
 }
-function validateProjectAgentAvailability(value) {
-  if (!isPlainRecord(value)) throw new Error("Project agent availability must be an object.");
-  const allowedKeys = /* @__PURE__ */ new Set(["timezone", "days", "start", "end", "mode"]);
-  const unknownKey = Object.keys(value).find((key) => !allowedKeys.has(key));
-  if (unknownKey) throw new Error(`Unknown availability field: "${unknownKey}".`);
-  if (typeof value.timezone !== "string" || !value.timezone.trim()) {
-    throw new Error("Project agent availability requires a timezone.");
+function parseEntryBody(body) {
+  const lines = [];
+  for (const line of body.split("\n")) {
+    if (/^##\s/.test(line) || /^---\s*$/.test(line) || /^<!--/.test(line)) break;
+    lines.push(line);
   }
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: value.timezone }).format();
-  } catch {
-    throw new Error(`Invalid project agent availability timezone: "${value.timezone}".`);
+  const text = lines.join("\n");
+  const what = /^-\s+\*\*([\s\S]+?)\*\*\s*$/m.exec(text)?.[1]?.replace(/\s+/g, " ").trim() ?? "";
+  if (!what) return void 0;
+  const why = /^\s+-\s+\*Why:\*\s+(.+)$/m.exec(text)?.[1]?.trim() ?? "";
+  const how = lines.filter((line) => /^\s+-\s+\*How:\*/i.test(line)).map((line) => cleanHowLine(line)).filter(Boolean).join("\n");
+  return { what, why, how };
+}
+function parseStructuredLearnedEntriesFromContent(raw, legacyEntries = splitLearnedEntries(raw)) {
+  if (!raw) return [];
+  const structured = [];
+  const stampPattern = /<!--\s*learned-stamp:\s*([^>]*?)\s*-->/g;
+  const stamps = [...raw.matchAll(stampPattern)];
+  for (const [index, stamp] of stamps.entries()) {
+    const attributes = parseStampAttributes(stamp[1] ?? "");
+    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));
+    if (!parsed || parsed.what.length < MIN_INSTRUCTIVE_LENGTH) continue;
+    structured.push({
+      key: directiveKey(parsed.what),
+      category,
+      what: parsed.what,
+      why: parsed.why || WHY_BY_CATEGORY[category],
+      how: parsed.how,
+      capturedAt,
+      ...skill ? { skill } : {},
+      ...trials.applied > 0 ? { applied: trials.applied, wins: trials.wins } : {}
+    });
   }
-  if (!Array.isArray(value.days) || value.days.length === 0 || value.days.some((day) => !Number.isInteger(day) || day < 0 || day > 6)) {
-    throw new Error("Project agent availability days must contain weekday numbers 0-6.");
+  if (structured.length === 0) {
+    for (const chunk of legacyEntries) {
+      const stamp = parseLearnedEntryStamp(chunk);
+      const directive = stamp.capturedAt || stamp.category ? stripStamp(chunk) : chunk;
+      if (directive.length < MIN_INSTRUCTIVE_LENGTH) continue;
+      const category = stamp.category ?? classifyLearnedEntry(directive);
+      const { what, why, how } = decomposeLearnedEntry(directive, category);
+      structured.push({
+        key: directiveKey(directive),
+        category,
+        what,
+        why,
+        how,
+        capturedAt: stamp.capturedAt
+      });
+    }
   }
-  if (typeof value.start !== "string" || typeof value.end !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(value.start) || !/^([01]\d|2[0-3]):[0-5]\d$/.test(value.end)) {
-    throw new Error("Project agent availability start/end must use HH:MM.");
+  return structured;
+}
+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,
+    category: fresh.category,
+    what,
+    why,
+    how,
+    capturedAt: fresh.capturedAt,
+    ...fresh.skill ? { skill: fresh.skill } : {},
+    ...inherited.applied > 0 ? { applied: inherited.applied, wins: inherited.wins } : {}
+  };
+  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,
+    pattern: 2,
+    fact: 3
+  };
+  merged.sort((a, b) => {
+    const cmp = order[a.category] - order[b.category];
+    if (cmp !== 0) return cmp;
+    return a.what.localeCompare(b.what);
+  });
+  return merged;
+}
+var SECTION_TITLE = {
+  warning: "## What to avoid",
+  convention: "## What to do",
+  pattern: "## Patterns to follow",
+  fact: "## Project facts"
+};
+function renderLearnedInstructions(role, entries, capturedAt) {
+  const headerLines = [
+    `# Learned instructions for \`${role}\``,
+    "",
+    "> Project-specific learning data for the `" + role + "` agent. Each entry is a directive \u2014 read it as an instruction, not a journal entry. Entries are re-derived on every capture, so this file is always a current, structured snapshot of what this agent has learned.",
+    ""
+  ];
+  if (entries.length === 0) {
+    return headerLines.join("\n") + [
+      "_No learned entries yet._",
+      "",
+      "---",
+      `*Last capture: ${capturedAt} \xB7 0 entries*`,
+      ""
+    ].join("\n");
   }
-  if (value.mode !== void 0 && value.mode !== "advisory" && value.mode !== "enforce") {
-    throw new Error("Project agent availability mode must be advisory or enforce.");
+  const buckets = {
+    warning: [],
+    convention: [],
+    pattern: [],
+    fact: []
+  };
+  for (const entry of entries) buckets[entry.category].push(entry);
+  const sections = [];
+  for (const category of ["warning", "convention", "pattern", "fact"]) {
+    const list = buckets[category];
+    if (list.length === 0) continue;
+    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}`] : [],
+        // 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}**`);
+      sections.push(`  - *Why:* ${entry.why}`);
+      for (const line of entry.how.split("\n").map(cleanHowLine).filter(Boolean)) {
+        sections.push(`  - *How:* ${line}`);
+      }
+      sections.push("");
+    }
+  }
+  const footer = ["---", `*Last capture: ${capturedAt} \xB7 ${entries.length} entries*`, ""];
+  return [...headerLines, ...sections, ...footer].join("\n");
+}
+var DROP_PRIORITY = {
+  fact: 0,
+  pattern: 1,
+  convention: 2,
+  warning: 3
+};
+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) {
+        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-paths.ts
 import { randomUUID } from "node:crypto";
 import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import * as path3 from "node:path";
+import * as path2 from "node:path";
 var AGENT_ROLE_PATTERN = /^[a-z0-9][a-z0-9._-]{0,95}$/i;
 function assertProjectAgentRole(role) {
   const normalized = role.trim();
@@ -741,13 +652,13 @@ function isProjectAgentRoleName(name) {
 }
 function agentsDir(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  return path3.join(root, ".wrongstack", "agents");
+  return path2.join(root, ".wrongstack", "agents");
 }
 function roleDir(role, projectRoot) {
-  return path3.join(agentsDir(projectRoot), assertProjectAgentRole(role));
+  return path2.join(agentsDir(projectRoot), assertProjectAgentRole(role));
 }
 function writeTextAtomically(filePath, content) {
-  mkdirSync(path3.dirname(filePath), { recursive: true });
+  mkdirSync(path2.dirname(filePath), { recursive: true });
   const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
   try {
     writeFileSync(temporaryPath, content, "utf8");
@@ -760,959 +671,957 @@ function writeTextAtomically(filePath, content) {
   }
 }
 function learningPolicyPath(role, projectRoot) {
-  return path3.join(roleDir(role, projectRoot), "learning.json");
+  return path2.join(roleDir(role, projectRoot), "learning.json");
 }
 function projectAgentProfilePath(role, projectRoot) {
-  return path3.join(roleDir(role, projectRoot), "profile.json");
+  return path2.join(roleDir(role, projectRoot), "profile.json");
 }
 
-// src/coordination/agents/project-agent-config-io.ts
-function loadProjectAgentConfig(role, projectRoot) {
-  const cfgPath = path4.join(roleDir(role, projectRoot), "config.json");
+// src/coordination/agents/project-agent-quarantine.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import * as path3 from "node:path";
+var QUARANTINE_MAX_BYTES = 64 * 1024;
+var RETIRED_MATCH_THRESHOLD = 0.55;
+function quarantinePath(role, projectRoot) {
+  return path3.join(roleDir(role, projectRoot), "quarantine.md");
+}
+function readTextOrEmpty(filePath) {
   try {
-    return validateProjectAgentConfig(JSON.parse(readFileSync2(cfgPath, "utf8")));
+    return readFileSync2(filePath, "utf8");
   } catch {
-    return void 0;
+    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}\`
 
-// src/coordination/agents/project-agent-consolidation.ts
-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) {
-  const setA = new Set(a.split(/\s+/));
-  const setB = new Set(b.split(/\s+/));
-  const intersect = new Set([...setA].filter((t) => setB.has(t)));
-  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
-  return union.size === 0 ? 0 : intersect.size / union.size;
-}
-function splitLearnedEntries(body) {
-  return body.split(/\n---\n+/).map((entry) => entry.trim()).map(
-    (entry) => entry.replace(/^#\s+Learned (?:wisdom|instructions) for .+$/im, "").replace(/^>\s*Project-specific learning data for[\s\S]*?$/im, "").replace(/^_No learned entries yet\._$/im, "").replace(/^\*Last capture:[^\n]*\*$/im, "").replace(/<!--[\s\S]*?-->/g, "").trim()
-  ).filter(Boolean);
-}
+> 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.
 
-// src/coordination/agents/project-agent-learning-normalize.ts
-var LEARNED_SOFT_LIMIT = 8192;
-var LEARNED_HARD_LIMIT = 16384;
-var LEARNED_ENTRY_MAX_CHARS = 600;
-var MIN_INSTRUCTIVE_LENGTH = 30;
-var NARRATIVE_SENTENCE_STARTS = [
-  /^(?:when|while|during|after|before|once|since)\s+(?:i|we|the agent|i was|i were|i had)\b/i,
-  /^(?:i|we)\s+(?:found|noticed|learned|discovered|realized|saw|encountered|hit|ran into)\b/i,
-  /^(?:i|we)\s+(?:was|were|had|did|ran|tried|attempted|used|modified|changed|updated)\b/i,
-  /^(?:this|that|the)\s+(?:task|session|run|commit|change|pr|pull request|invocation)\b/i,
-  /^(?:in|on|for|at|during)\s+(?:this|that|the)\s+(?:task|session|run|commit|change|pr)\b/i,
-  /^(?:today|yesterday|earlier|just now|recently|lately)\b/i
-];
-var EPHEMERAL_PATTERNS = [
-  // Commit SHAs. A bare `[0-9a-f]{7,40}` also matches ordinary English words
-  // spelled entirely from hex letters ("defaced", "acceded", "effaced"), so
-  // require at least one digit — every real abbreviated SHA has one in
-  // practice, and the false-positive class disappears.
-  { pattern: /\b(?=[0-9a-f]{7,40}\b)[a-f]*\d[0-9a-f]*\b/g, replacement: "" },
-  {
-    pattern: /\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/g,
-    replacement: ""
-  },
-  {
-    pattern: /(?<=\b(?:on|from|since|before|after|dated|until)\s)\d{4}-\d{2}-\d{2}\b/gi,
-    replacement: ""
-  },
-  { pattern: /\b(?:line|lines?)\s+\d+(?:\s*[-–]\s*\d+)?/gi, replacement: "" },
-  { pattern: /#\s*(?:PR|issue|MR)\s*\d+/gi, replacement: "" },
-  { pattern: /(?<=\s)#\d{1,6}\b/g, replacement: "" }
-];
-function normalizeLearnedEntry(raw) {
-  if (!raw) return null;
-  let cleaned = raw;
-  for (const { pattern, replacement } of EPHEMERAL_PATTERNS) {
-    cleaned = cleaned.replace(pattern, replacement);
+`;
+  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);
   }
-  const sentences = splitSentences(cleaned);
-  const directiveSentences = [];
-  let hadSubstantiveNarrative = false;
-  for (const sentence of sentences) {
-    const trimmed = sentence.trim();
-    if (!trimmed) continue;
-    if (isNarrativeSentence(trimmed)) {
-      hadSubstantiveNarrative = true;
-      const salvaged = salvageDirectiveTail(trimmed);
-      if (salvaged) directiveSentences.push(salvaged);
-      continue;
+  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();
     }
-    directiveSentences.push(trimmed);
-  }
-  if (directiveSentences.length === 0) return null;
-  let normalized = directiveSentences.join(" ").replace(/\s+/g, " ").trim();
-  if (normalized.length > LEARNED_ENTRY_MAX_CHARS) {
-    normalized = truncateToInstructive(normalized, LEARNED_ENTRY_MAX_CHARS);
-    if (normalized.length < MIN_INSTRUCTIVE_LENGTH) return null;
-  }
-  if (normalized.length < MIN_INSTRUCTIVE_LENGTH) return null;
-  if (hadSubstantiveNarrative && directiveSentences.length < sentences.length / 2) {
-    if (normalized.length < MIN_INSTRUCTIVE_LENGTH * 2) return null;
+    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 {
-    text: normalized,
-    category: classifyLearnedEntry(normalized)
-  };
+  return out;
 }
-function splitSentences(text) {
-  return text.replace(/\s+/g, " ").split(/(?<=[.!?])\s+(?=[A-Z(])/).map((s) => s.trim()).filter(Boolean);
+function bareClaim(line) {
+  return line.replace(/^\s*[-*+]\s+/, "").replace(/^\s*\d+[.)]\s+/, "").replace(/\*\*/g, "").replace(/`/g, "").trim();
 }
-function isNarrativeSentence(sentence) {
-  return NARRATIVE_SENTENCE_STARTS.some((re) => re.test(sentence));
+function indentOf(line) {
+  return line.length - line.trimStart().length;
 }
-function salvageDirectiveTail(sentence) {
-  for (const re of NARRATIVE_SENTENCE_STARTS) {
-    const m = re.exec(sentence);
-    if (!m) continue;
-    const tail = sentence.slice(m[0].length).replace(/^[,\s]+/, "").trim();
-    if (!tail) return null;
-    if (looksDirective(tail)) return tail;
-    return null;
+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 null;
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
-var DIRECTIVE_VERB_PATTERN = /^(?:always|never|prefer|avoid|use|ensure|verify|check|run|execute|apply|adopt|choose|require|must|should|don'?t|do not|keep|maintain|set|define|specify|validate|confirm|inspect|review|handle|enable|disable|restrict|cap|limit|wrap|isolate|separate|combine|split|merge|refactor|rename|move|extract|inline)\b/i;
-function looksDirective(text) {
-  if (DIRECTIVE_VERB_PATTERN.test(text)) return true;
-  if (/\b(?:is|are|must be|should be|required to)\s+(?:always|never|used|preferred)\b/i.test(text))
-    return true;
-  if (/\b(?:had to|has to|have to|needs? to|must|should|ought to)\s+\w+/i.test(text) && text.length > MIN_INSTRUCTIVE_LENGTH)
-    return true;
-  return false;
+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 truncateToInstructive(text, maxChars) {
-  const sentences = splitSentences(text);
-  let acc = "";
-  for (const s of sentences) {
-    const candidate = acc ? `${acc} ${s}` : s;
-    if (candidate.length > maxChars) break;
-    acc = candidate;
-  }
-  if (acc) return acc;
-  return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+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
+    )
+  );
 }
-function classifyLearnedEntry(text) {
-  const lower = text.toLowerCase();
-  if (/\b(?:avoid|never|don'?t|do not|must not|prevent|watch out|beware|pitfall|gotcha|hazard|risk)\b/.test(
-    lower
-  ))
-    return "warning";
-  if (/\b(?:use|prefer|choose|adopt|leverage|apply|switch to|migrate to)\b/.test(lower) || /\b(?:pattern|approach|strategy|technique|idiom)\b/.test(lower))
-    return "pattern";
-  if (/\b(?:always|must|should|require|ensure|verify|check|run|execute|before|after|when)\b/.test(
-    lower
-  ))
-    return "convention";
-  return "fact";
+
+// src/coordination/agents/project-agent-consolidation.ts
+function learnedPath(role, projectRoot) {
+  return path4.join(roleDir(role, projectRoot), "learned.md");
 }
-function normalizeForComparison(text) {
-  return text.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim().split(/\s+/).sort().join(" ");
+function loadProjectAgentLearnedText(role, projectRoot) {
+  try {
+    return readFileSync3(learnedPath(role, projectRoot), "utf8").trim();
+  } catch {
+    return "";
+  }
 }
-
-// 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 readRawLearnedEntries(role, projectRoot) {
+  const raw = loadProjectAgentLearnedText(role, projectRoot);
+  return parseStructuredLearnedEntriesFromContent(raw, splitLearnedEntries(raw));
 }
-function directiveUtility(entry) {
-  const { applied, wins } = directiveTrials(entry);
-  return (wins + 1) / (applied + 2);
+function consolidationPath(role, projectRoot) {
+  return path4.join(roleDir(role, projectRoot), "consolidated.md");
 }
-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 consolidatedDocumentPath(role, projectRoot) {
+  return consolidationPath(assertProjectAgentRole(role), projectRoot);
 }
-function parseLearnedEntryStamp(entry) {
-  const structuredMatch = entry.match(
-    /<!--\s*learned-stamp:\s*category=([\w-]+);\s*capturedAt=([^;]+?)\s*-->/
-  );
-  if (structuredMatch) {
-    const rawCategory = structuredMatch[1];
-    const candidate = parseLearnedCategory(rawCategory);
-    return {
-      capturedAt: typeof structuredMatch[2] === "string" ? structuredMatch[2].trim() : "",
-      category: candidate ?? null
-    };
-  }
-  const stampMatch = entry.match(/^>\s*(?:\[\s*([\w-]+)\s*\]\s+)?(?:Captured|Taught)\s+(\S+)/m);
-  if (!stampMatch) {
-    return { capturedAt: "", category: null };
-  }
-  return {
-    capturedAt: typeof stampMatch[2] === "string" ? stampMatch[2] : "",
-    category: parseLearnedCategory(stampMatch[1]) ?? null
-  };
+function consolidationMetaPath(role, projectRoot) {
+  return path4.join(roleDir(role, projectRoot), "consolidation.json");
 }
-function parseLearnedCategory(value) {
-  return value === "convention" || value === "pattern" || value === "warning" || value === "fact" ? value : void 0;
+function archivePath(role, at, projectRoot) {
+  return path4.join(roleDir(role, projectRoot), "archive", `learned-${at.replace(/[:.]/g, "-")}.md`);
 }
-function stripStamp(entry) {
-  return entry.replace(/<!--\s*learned-stamp:[\s\S]*?-->/g, "").replace(/^>\s*(?:\[[\w-]+\]\s+)?(?:Captured|Taught)\s+.+$/m, "").replace(/\n{3,}/g, "\n\n").trim();
+function loadProjectAgentConsolidated(role, projectRoot) {
+  try {
+    return readFileSync3(consolidationPath(role, projectRoot), "utf8").trim();
+  } catch {
+    return "";
+  }
 }
-function directiveKey(text) {
-  return normalizeForComparison(text);
+function loadConsolidationMetadata(role, projectRoot) {
+  try {
+    const raw = readFileSync3(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;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
 }
-function decomposeLearnedEntry(text, category) {
-  const what = text;
-  const why = deriveWhy(category, text);
-  const how = extractHow(text);
-  return { what, why, how };
+function isConsolidated(role, projectRoot) {
+  return existsSync(consolidationMetaPath(role, projectRoot));
 }
-var WHY_BY_CATEGORY = {
-  convention: "Established convention for this codebase \u2014 skipping it risks regressions, merge friction, or out-of-sync state with peers.",
-  pattern: "This project's chosen approach \u2014 alternatives were considered and either conflict with existing architecture or were rejected for known reasons.",
-  warning: "Known failure mode \u2014 skipping this has caused real defects in this codebase. The cost of getting it wrong outweighs the cost of the check.",
-  fact: "Current state of the project \u2014 assumed by other conventions, build steps, or peers, so acting on a stale assumption wastes a cycle."
-};
-function deriveWhy(category, text) {
-  const base = WHY_BY_CATEGORY[category];
-  const signals = [];
-  const lower = text.toLowerCase();
-  if (/\bbefore\s+(?:merge|commit|deploy|release|shipping|publishing)\b/.test(lower))
-    signals.push("guard before shipping");
-  if (/\bto\s+avoid\b/.test(lower)) {
-    const m = text.match(/to avoid ([^.!?]+)/i);
-    if (m?.[1]) signals.push(`avoid ${m[1].trim()}`);
-  }
-  if (/\bso\s+(?:that|we|the project)\b/.test(lower)) {
-    const m = text.match(/so (?:that |we |the project )?([^.!?]+)/i);
-    if (m?.[1]) signals.push(`so ${m[1].trim()}`);
-  }
-  if (signals.length === 0) return base;
-  return `${base} Project signals: ${signals.join("; ")}.`;
-}
-function extractHow(text) {
-  const anchors = /* @__PURE__ */ new Set();
-  const backticked = text.match(/`([^`]+)`/g) ?? [];
-  for (const raw of backticked) {
-    const inner = raw.replace(/`/g, "").trim();
-    if (inner.length > 0 && inner.length <= 120) anchors.add(inner);
-  }
-  const pathMatches = text.match(
-    /(?:[a-zA-Z0-9_.-]+\/)+[a-zA-Z0-9_.-]+\.(?:tsx|jsonc|json|jsx|yaml|mjs|cjs|yml|ts|js|md)\b/g
-  ) ?? [];
-  for (const p of pathMatches) anchors.add(p);
-  const scoped = text.match(/@[a-z0-9][\w.-]*\/[a-z0-9][\w.-]*/gi) ?? [];
-  for (const p of scoped) anchors.add(p);
-  if (anchors.size === 0) return "";
-  return [...anchors].map((anchor) => `\`${anchor}\``).join("\n");
-}
-function cleanHowLine(line) {
-  let value = line.trim();
-  let previous;
-  do {
-    previous = value;
-    value = value.replace(/^[-*]\s+/, "").replace(/^\*How:\*\s*/i, "").trim();
-  } while (value !== previous);
-  return value;
-}
-function parseStampAttributes(body) {
-  const attributes = {};
-  for (const part of body.split(";")) {
-    const eq = part.indexOf("=");
-    if (eq === -1) continue;
-    const key = part.slice(0, eq).trim();
-    const value = part.slice(eq + 1).trim();
-    if (key) attributes[key] = value;
-  }
-  return attributes;
-}
-function parseEntryBody(body) {
-  const lines = [];
-  for (const line of body.split("\n")) {
-    if (/^##\s/.test(line) || /^---\s*$/.test(line) || /^<!--/.test(line)) break;
-    lines.push(line);
-  }
-  const text = lines.join("\n");
-  const what = /^-\s+\*\*([\s\S]+?)\*\*\s*$/m.exec(text)?.[1]?.replace(/\s+/g, " ").trim() ?? "";
-  if (!what) return void 0;
-  const why = /^\s+-\s+\*Why:\*\s+(.+)$/m.exec(text)?.[1]?.trim() ?? "";
-  const how = lines.filter((line) => /^\s+-\s+\*How:\*/i.test(line)).map((line) => cleanHowLine(line)).filter(Boolean).join("\n");
-  return { what, why, how };
-}
-function parseStructuredLearnedEntriesFromContent(raw, legacyEntries = splitLearnedEntries(raw)) {
-  if (!raw) return [];
-  const structured = [];
-  const stampPattern = /<!--\s*learned-stamp:\s*([^>]*?)\s*-->/g;
-  const stamps = [...raw.matchAll(stampPattern)];
-  for (const [index, stamp] of stamps.entries()) {
-    const attributes = parseStampAttributes(stamp[1] ?? "");
-    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));
-    if (!parsed || parsed.what.length < MIN_INSTRUCTIVE_LENGTH) continue;
-    structured.push({
-      key: directiveKey(parsed.what),
-      category,
-      what: parsed.what,
-      why: parsed.why || WHY_BY_CATEGORY[category],
-      how: parsed.how,
-      capturedAt,
-      ...skill ? { skill } : {},
-      ...trials.applied > 0 ? { applied: trials.applied, wins: trials.wins } : {}
-    });
-  }
-  if (structured.length === 0) {
-    for (const chunk of legacyEntries) {
-      const stamp = parseLearnedEntryStamp(chunk);
-      const directive = stamp.capturedAt || stamp.category ? stripStamp(chunk) : chunk;
-      if (directive.length < MIN_INSTRUCTIVE_LENGTH) continue;
-      const category = stamp.category ?? classifyLearnedEntry(directive);
-      const { what, why, how } = decomposeLearnedEntry(directive, category);
-      structured.push({
-        key: directiveKey(directive),
-        category,
-        what,
-        why,
-        how,
-        capturedAt: stamp.capturedAt
-      });
+function saveProjectAgentConsolidated(role, content, projectRoot, options) {
+  const normalizedRole = assertProjectAgentRole(role);
+  if (!content.trim()) return consolidationPath(normalizedRole, projectRoot);
+  const dir = roleDir(normalizedRole, projectRoot);
+  mkdirSync2(dir, { recursive: true });
+  const fp = consolidationPath(normalizedRole, projectRoot);
+  writeTextAtomically(fp, content);
+  const consolidatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let archived;
+  if (options?.prune) {
+    const rawText = loadProjectAgentLearnedText(normalizedRole, projectRoot);
+    if (rawText) {
+      archived = archivePath(normalizedRole, consolidatedAt, projectRoot);
+      writeTextAtomically(archived, rawText);
     }
+    writeTextAtomically(
+      learnedPath(normalizedRole, projectRoot),
+      renderLearnedInstructions(normalizedRole, [], consolidatedAt)
+    );
   }
-  return structured;
-}
-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)
+  const rawEntries = readRawLearnedEntries(normalizedRole, projectRoot);
+  const rawBytes = Buffer.byteLength(
+    loadProjectAgentLearnedText(normalizedRole, projectRoot),
+    "utf8"
   );
-  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,
-    category: fresh.category,
-    what,
-    why,
-    how,
-    capturedAt: fresh.capturedAt,
-    ...fresh.skill ? { skill: fresh.skill } : {},
-    ...inherited.applied > 0 ? { applied: inherited.applied, wins: inherited.wins } : {}
+  const meta = {
+    consolidatedAt,
+    sourceEntryCount: rawEntries.length,
+    sourceBytes: rawBytes,
+    consolidatedBytes: Buffer.byteLength(content, "utf8"),
+    trigger: options?.trigger ?? "manual",
+    ...options?.model ? { model: options.model } : {},
+    ...options?.prune ? { pruned: true } : {},
+    ...archived ? { archivePath: archived } : {},
+    ...options?.skills?.length ? { skills: [...options.skills] } : {}
   };
-  const merged = existing.filter(
-    (entry) => entry.category !== fresh.category || tokenOverlap(entry.key, key) < 0.55
+  writeTextAtomically(
+    consolidationMetaPath(normalizedRole, projectRoot),
+    `${JSON.stringify(meta, null, 2)}
+`
   );
-  merged.push(freshEntry);
-  return sortStructuredEntries(merged);
+  return fp;
 }
-function sortStructuredEntries(merged) {
-  const order = {
-    warning: 0,
-    convention: 1,
-    pattern: 2,
-    fact: 3
-  };
-  merged.sort((a, b) => {
-    const cmp = order[a.category] - order[b.category];
-    if (cmp !== 0) return cmp;
-    return a.what.localeCompare(b.what);
-  });
-  return merged;
+function clearProjectAgentConsolidated(role, projectRoot) {
+  const normalizedRole = assertProjectAgentRole(role);
+  for (const file of [
+    consolidationPath(normalizedRole, projectRoot),
+    consolidationMetaPath(normalizedRole, projectRoot)
+  ]) {
+    try {
+      rmSync2(file, { force: true });
+    } catch {
+    }
+  }
 }
-var SECTION_TITLE = {
-  warning: "## What to avoid",
-  convention: "## What to do",
-  pattern: "## Patterns to follow",
-  fact: "## Project facts"
-};
-function renderLearnedInstructions(role, entries, capturedAt) {
-  const headerLines = [
-    `# Learned instructions for \`${role}\``,
+function buildConsolidationInstruction(role, projectRoot) {
+  const normalizedRole = assertProjectAgentRole(role);
+  const entries = readRawLearnedEntries(normalizedRole, projectRoot);
+  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}
+
+${entry}`).join("\n\n");
+  const sections = [
+    `You are reviewing and consolidating the captured learning entries for the "${normalizedRole}" agent role in this project.`,
     "",
-    "> Project-specific learning data for the `" + role + "` agent. Each entry is a directive \u2014 read it as an instruction, not a journal entry. Entries are re-derived on every capture, so this file is always a current, structured snapshot of what this agent has learned.",
-    ""
+    "Your task is to synthesize the raw entries below into a single, narrowly-scoped document that represents what this agent has learned \u2014 specifically for its skills and role responsibilities. This document is the **instruction manual for future invocations** of this agent in this project. It is not a journal, not an exhaustive transcription, and not a memory store.",
+    "",
+    "## Requirements",
+    "",
+    "1. **Be selective.** Some raw entries are noise \u2014 narrative descriptions of single-session events, ephemeral references (commit SHAs, timestamps, line numbers, PR refs), or thin fragments that cannot be generalized. **Drop them.** The output must be smaller than the input; a consolidation that preserves every word is not a consolidation.",
+    '2. **Extract the directive.** When a raw entry mixes narrative framing with a buried lesson ("When I worked on X, I realized Y"), extract the lesson as a directive and discard the framing.',
+    "3. **Generic, not specific.** Rewrite entries so they apply across sessions. Replace session-specific anchors (commit SHAs, dates, line numbers) with general principles or concrete tools/commands that will still be valid next month.",
+    "4. **Self-contained bullets.** Each bullet must make sense standalone \u2014 understandable to a future agent that has no context about the session that produced it.",
+    "5. **Narrow scope.** Keep only knowledge that is genuinely durable and role-relevant. When in doubt, leave it out.",
+    "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)
+
+${rawBody}` : "## Raw learned entries\n\n(No raw entries yet \u2014 return an empty document.)"
   ];
-  if (entries.length === 0) {
-    return headerLines.join("\n") + [
-      "_No learned entries yet._",
+  if (existingConsolidation) {
+    sections.push(
       "",
-      "---",
-      `*Last capture: ${capturedAt} \xB7 0 entries*`,
-      ""
-    ].join("\n");
+      `## Existing consolidated document (for reference \u2014 improve upon it)
+
+${existingConsolidation}`
+    );
   }
-  const buckets = {
-    warning: [],
-    convention: [],
-    pattern: [],
-    fact: []
-  };
-  for (const entry of entries) buckets[entry.category].push(entry);
-  const sections = [];
-  for (const category of ["warning", "convention", "pattern", "fact"]) {
-    const list = buckets[category];
-    if (list.length === 0) continue;
-    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}`] : [],
-        // 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}**`);
-      sections.push(`  - *Why:* ${entry.why}`);
-      for (const line of entry.how.split("\n").map(cleanHowLine).filter(Boolean)) {
-        sections.push(`  - *How:* ${line}`);
-      }
-      sections.push("");
-    }
+  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")}`
+    );
   }
-  const footer = ["---", `*Last capture: ${capturedAt} \xB7 ${entries.length} entries*`, ""];
-  return [...headerLines, ...sections, ...footer].join("\n");
+  sections.push(
+    "",
+    "## Output",
+    "",
+    "Return ONLY the consolidated markdown document. Do not wrap it in code fences or add commentary."
+  );
+  return {
+    instruction: sections.join("\n"),
+    rawEntries,
+    hasExistingConsolidation: Boolean(existingConsolidation)
+  };
 }
-var DROP_PRIORITY = {
-  fact: 0,
-  pattern: 1,
-  convention: 2,
-  warning: 3
-};
-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) {
-        if (byPriority < 0) victimIndex = i;
-        continue;
+
+// src/coordination/agents/project-agent-knowledge-manifests.ts
+var BUILT_IN_KNOWLEDGE_MANIFESTS = {
+  android: {
+    role: "android",
+    // Only machine-readable JSON registries belong in liveQueries. Android
+    // release/API data has no JSON registry endpoint, so those checks stay as
+    // checklist prose below.
+    liveQueries: {
+      kotlin: {
+        registry: "https://registry.npmjs.org/kotlin/latest",
+        key: "version",
+        description: "Kotlin latest stable"
       }
-      const byUtility = directiveUtility(a) - directiveUtility(b);
-      if (Math.abs(byUtility) > UTILITY_EPSILON) {
-        if (byUtility < 0) victimIndex = i;
-        continue;
+    },
+    checklist: [
+      "Current Android Gradle Plugin version (8.x+)",
+      "Current Kotlin version (2.x+)",
+      "Current compileSdk / targetSdk (\u2265 34, check Play Store policy)",
+      "Current Jetpack Compose stable version",
+      "All third-party dependencies are at latest compatible minor"
+    ],
+    verifyThreshold: 0.5
+  },
+  frontend: {
+    role: "frontend",
+    liveQueries: {
+      react: {
+        registry: "https://registry.npmjs.org/react/latest",
+        key: "version",
+        description: "React latest stable"
+      },
+      nextjs: {
+        registry: "https://registry.npmjs.org/next/latest",
+        key: "version",
+        description: "Next.js latest stable"
       }
-      if (a.capturedAt < b.capturedAt) victimIndex = i;
-    }
-    dropped.push(...kept.splice(victimIndex, 1));
+    },
+    checklist: [
+      "Current React version (pinned in package.json)",
+      "Current Next.js / Vite / framework version",
+      "Node.js runtime version (project .nvmrc or engines)",
+      "All devDependencies are at latest compatible versions",
+      "Browser compatibility targets from browserslist"
+    ],
+    verifyThreshold: 0.5
+  },
+  executor: {
+    role: "executor",
+    liveQueries: {
+      node: {
+        registry: "https://registry.npmjs.org/node/latest",
+        key: "version",
+        description: "Node.js latest release"
+      }
+    },
+    checklist: [
+      "Node.js version from .nvmrc or package.engines",
+      "TypeScript version from package.json",
+      "Package manager (pnpm \u2265 9) from packageManager",
+      "Current toolchain: esbuild, vitest, etc."
+    ],
+    verifyThreshold: 0.6
   }
-  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");
+// src/coordination/agents/project-agent-learning-policy.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+var DEFAULT_LEARNING_POLICY = {
+  enabled: true,
+  lifetimeCaptureCount: 0
+};
+function loadProjectAgentLearningPolicy(role, projectRoot) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync4(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 } : {},
+      ...typeof parsed.lastOptimizeAt === "string" ? { lastOptimizeAt: parsed.lastOptimizeAt } : {}
+    };
+  } catch {
+    return { ...DEFAULT_LEARNING_POLICY };
+  }
 }
-function readTextOrEmpty(filePath) {
+function updateProjectAgentLearningPolicy(role, patch, projectRoot) {
+  const defined = Object.fromEntries(
+    Object.entries(patch).filter(([, value]) => value !== void 0)
+  );
+  const updated = {
+    ...loadProjectAgentLearningPolicy(role, projectRoot),
+    ...defined
+  };
+  writeTextAtomically(
+    learningPolicyPath(role, projectRoot),
+    `${JSON.stringify(updated, null, 2)}
+`
+  );
+  return updated;
+}
+function recordProjectAgentOptimizePass(role, projectRoot, at = (/* @__PURE__ */ new Date()).toISOString()) {
   try {
-    return readFileSync3(filePath, "utf8");
+    updateProjectAgentLearningPolicy(role, { lastOptimizeAt: at }, projectRoot);
   } 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.
+// src/coordination/agents/project-agent-skill-layer.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync3 } from "node:fs";
+import * as path8 from "node:path";
 
-`;
-  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);
+// src/coordination/agents/project-agent-config-io.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+import * as path6 from "node:path";
+
+// src/coordination/agents/project-agent-config-validation.ts
+import * as path5 from "node:path";
+var PROJECT_AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "tools",
+  "skillNames",
+  "budget",
+  "provider",
+  "model",
+  "allowedCapabilities",
+  "modelPolicy",
+  "fallbackProfile",
+  "cwd",
+  "worktree",
+  "availability"
+]);
+var PROJECT_AGENT_BUDGET_KEYS = /* @__PURE__ */ new Set([
+  "timeoutMs",
+  "idleTimeoutMs",
+  "maxIterations",
+  "maxToolCalls",
+  "maxTokens",
+  "maxCostUsd"
+]);
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-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 } : {} });
+function assertStringList(value, field) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
+    throw new Error(`Project agent config "${field}" must be an array of non-empty strings.`);
   }
-  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++;
+function validateProjectAgentConfig(value) {
+  if (!isPlainRecord(value)) throw new Error("Project agent config must be an object.");
+  const unknownKey = Object.keys(value).find((key) => !PROJECT_AGENT_CONFIG_KEYS.has(key));
+  if (unknownKey) throw new Error(`Unknown project agent config field: "${unknownKey}".`);
+  if (value.tools !== void 0) assertStringList(value.tools, "tools");
+  if (value.skillNames !== void 0) assertStringList(value.skillNames, "skillNames");
+  if (value.allowedCapabilities !== void 0) {
+    assertStringList(value.allowedCapabilities, "allowedCapabilities");
+  }
+  for (const field of ["provider", "model", "fallbackProfile"]) {
+    const fieldValue = value[field];
+    if (fieldValue !== void 0 && (typeof fieldValue !== "string" || !fieldValue.trim())) {
+      throw new Error(`Project agent config "${field}" must be a non-empty string.`);
+    }
+  }
+  if (value.cwd !== void 0) {
+    if (typeof value.cwd !== "string" || !value.cwd.trim()) {
+      throw new Error('Project agent config "cwd" must be a non-empty relative path.');
+    }
+    const cwd = value.cwd.replace(/\\/g, "/").trim();
+    if (path5.posix.isAbsolute(cwd) || /^[a-z]:\//i.test(cwd) || cwd.split("/").includes("..")) {
+      throw new Error('Project agent config "cwd" must stay inside the assigned checkout.');
+    }
+    value.cwd = cwd;
+  }
+  if (value.worktree !== void 0 && value.worktree !== true && value.worktree !== false && value.worktree !== "auto" && value.worktree !== "required" && value.worktree !== "off") {
+    throw new Error('Project agent config "worktree" must be auto, required, off, or boolean.');
+  }
+  if (value.modelPolicy !== void 0) validateProjectAgentModelPolicy(value.modelPolicy);
+  if (value.availability !== void 0) validateProjectAgentAvailability(value.availability);
+  if (value.budget !== void 0) {
+    if (!isPlainRecord(value.budget)) {
+      throw new Error('Project agent config "budget" must be an object.');
+    }
+    const unknownBudgetKey = Object.keys(value.budget).find(
+      (key) => !PROJECT_AGENT_BUDGET_KEYS.has(key)
+    );
+    if (unknownBudgetKey) {
+      throw new Error(`Unknown project agent budget field: "${unknownBudgetKey}".`);
+    }
+    for (const [field, amount] of Object.entries(value.budget)) {
+      if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0) {
+        throw new Error(`Project agent budget "${field}" must be a finite non-negative number.`);
+      }
+      if (field !== "maxCostUsd" && !Number.isInteger(amount)) {
+        throw new Error(`Project agent budget "${field}" must be an integer.`);
       }
-      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
-    )
-  );
+  return value;
 }
-
-// src/coordination/agents/project-agent-consolidation.ts
-function learnedPath(role, projectRoot) {
-  return path6.join(roleDir(role, projectRoot), "learned.md");
+function validateProjectAgentModelPolicy(value) {
+  if (!isPlainRecord(value)) throw new Error("Project agent modelPolicy must be an object.");
+  const allowedKeys = /* @__PURE__ */ new Set(["allowed", "fallbacks", "strict"]);
+  const unknownKey = Object.keys(value).find((key) => !allowedKeys.has(key));
+  if (unknownKey) throw new Error(`Unknown modelPolicy field: "${unknownKey}".`);
+  const validateTargets = (targets, field, allowEmpty) => {
+    if (!Array.isArray(targets) || !allowEmpty && targets.length === 0) {
+      throw new Error(`Project agent modelPolicy "${field}" must be a non-empty array.`);
+    }
+    for (const target of targets) {
+      if (!isPlainRecord(target) || typeof target.provider !== "string" || !target.provider.trim() || typeof target.model !== "string" || !target.model.trim()) {
+        throw new Error(`Project agent modelPolicy "${field}" contains an invalid target.`);
+      }
+    }
+  };
+  validateTargets(value.allowed, "allowed", false);
+  if (value.fallbacks !== void 0) {
+    validateTargets(value.fallbacks, "fallbacks", true);
+    const allowed = new Set(
+      value.allowed.map(
+        (target) => `${target.provider}\0${target.model}`
+      )
+    );
+    for (const target of value.fallbacks) {
+      if (!allowed.has(`${target.provider}\0${target.model}`)) {
+        throw new Error("Every modelPolicy fallback must also appear in allowed.");
+      }
+    }
+  }
+  if (value.strict !== void 0 && typeof value.strict !== "boolean") {
+    throw new Error('Project agent modelPolicy "strict" must be boolean.');
+  }
 }
-function loadProjectAgentLearnedText(role, projectRoot) {
+function validateProjectAgentAvailability(value) {
+  if (!isPlainRecord(value)) throw new Error("Project agent availability must be an object.");
+  const allowedKeys = /* @__PURE__ */ new Set(["timezone", "days", "start", "end", "mode"]);
+  const unknownKey = Object.keys(value).find((key) => !allowedKeys.has(key));
+  if (unknownKey) throw new Error(`Unknown availability field: "${unknownKey}".`);
+  if (typeof value.timezone !== "string" || !value.timezone.trim()) {
+    throw new Error("Project agent availability requires a timezone.");
+  }
   try {
-    return readFileSync4(learnedPath(role, projectRoot), "utf8").trim();
+    new Intl.DateTimeFormat("en-US", { timeZone: value.timezone }).format();
   } catch {
-    return "";
+    throw new Error(`Invalid project agent availability timezone: "${value.timezone}".`);
+  }
+  if (!Array.isArray(value.days) || value.days.length === 0 || value.days.some((day) => !Number.isInteger(day) || day < 0 || day > 6)) {
+    throw new Error("Project agent availability days must contain weekday numbers 0-6.");
+  }
+  if (typeof value.start !== "string" || typeof value.end !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(value.start) || !/^([01]\d|2[0-3]):[0-5]\d$/.test(value.end)) {
+    throw new Error("Project agent availability start/end must use HH:MM.");
+  }
+  if (value.mode !== void 0 && value.mode !== "advisory" && value.mode !== "enforce") {
+    throw new Error("Project agent availability mode must be advisory or enforce.");
   }
 }
-function readRawLearnedEntries(role, projectRoot) {
-  const raw = loadProjectAgentLearnedText(role, projectRoot);
-  return parseStructuredLearnedEntriesFromContent(raw, splitLearnedEntries(raw));
-}
-function consolidationPath(role, projectRoot) {
-  return path6.join(roleDir(role, projectRoot), "consolidated.md");
-}
-function consolidatedDocumentPath(role, projectRoot) {
-  return consolidationPath(assertProjectAgentRole(role), projectRoot);
-}
-function consolidationMetaPath(role, projectRoot) {
-  return path6.join(roleDir(role, projectRoot), "consolidation.json");
-}
-function archivePath(role, at, projectRoot) {
-  return path6.join(roleDir(role, projectRoot), "archive", `learned-${at.replace(/[:.]/g, "-")}.md`);
-}
-function loadProjectAgentConsolidated(role, projectRoot) {
+
+// src/coordination/agents/project-agent-config-io.ts
+function loadProjectAgentConfig(role, projectRoot) {
+  const cfgPath = path6.join(roleDir(role, projectRoot), "config.json");
   try {
-    return readFileSync4(consolidationPath(role, projectRoot), "utf8").trim();
+    return validateProjectAgentConfig(JSON.parse(readFileSync5(cfgPath, "utf8")));
   } catch {
-    return "";
+    return void 0;
   }
 }
-function loadConsolidationMetadata(role, projectRoot) {
+
+// src/coordination/agents/project-agent-profile.ts
+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);
+}
+function loadProjectAgentProfile(role, projectRoot) {
   try {
-    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;
+    const parsed = JSON.parse(
+      readFileSync6(projectAgentProfilePath(role, projectRoot), "utf8")
+    );
+    const normalizedRole = assertProjectAgentRole(parsed.role ?? role);
+    const baseRole = assertProjectAgentRole(parsed.baseRole ?? "generic");
+    if (normalizedRole !== assertProjectAgentRole(role)) return void 0;
+    if (typeof parsed.name !== "string" || !parsed.name.trim()) return void 0;
+    if (typeof parsed.purpose !== "string" || !parsed.purpose.trim()) return void 0;
+    if (!Array.isArray(parsed.taskTypes) || parsed.taskTypes.some((item) => typeof item !== "string")) {
+      return void 0;
     }
-    return void 0;
+    const createdAt = typeof parsed.createdAt === "string" ? parsed.createdAt : (/* @__PURE__ */ new Date(0)).toISOString();
+    const updatedAt = typeof parsed.updatedAt === "string" ? parsed.updatedAt : createdAt;
+    return {
+      role: normalizedRole,
+      name: parsed.name.trim(),
+      baseRole,
+      purpose: parsed.purpose.trim(),
+      taskTypes: parsed.taskTypes.map((item) => item.trim()).filter(Boolean),
+      createdAt,
+      updatedAt
+    };
   } catch {
     return void 0;
   }
 }
-function isConsolidated(role, projectRoot) {
-  return existsSync(consolidationMetaPath(role, projectRoot));
-}
-function saveProjectAgentConsolidated(role, content, projectRoot, options) {
-  const normalizedRole = assertProjectAgentRole(role);
-  if (!content.trim()) return consolidationPath(normalizedRole, projectRoot);
-  const dir = roleDir(normalizedRole, projectRoot);
-  mkdirSync2(dir, { recursive: true });
-  const fp = consolidationPath(normalizedRole, projectRoot);
-  writeTextAtomically(fp, content);
-  const consolidatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  let archived;
-  if (options?.prune) {
-    const rawText = loadProjectAgentLearnedText(normalizedRole, projectRoot);
-    if (rawText) {
-      archived = archivePath(normalizedRole, consolidatedAt, projectRoot);
-      writeTextAtomically(archived, rawText);
-    }
-    writeTextAtomically(
-      learnedPath(normalizedRole, projectRoot),
-      renderLearnedInstructions(normalizedRole, [], consolidatedAt)
-    );
+function createProjectAgent(input, projectRoot) {
+  const name = input.name.trim();
+  const purpose = input.purpose.trim();
+  if (!name || name.length > 120) throw new Error("Project agent name must be 1-120 characters.");
+  if (purpose.length < 10 || purpose.length > 4e3) {
+    throw new Error("Project agent purpose must be 10-4000 characters.");
   }
-  const rawEntries = readRawLearnedEntries(normalizedRole, projectRoot);
-  const rawBytes = Buffer.byteLength(
-    loadProjectAgentLearnedText(normalizedRole, projectRoot),
-    "utf8"
+  const role = assertProjectAgentRole(
+    (input.role?.trim() || slugifyProjectAgentRole(name)).toLowerCase()
   );
-  const meta = {
-    consolidatedAt,
-    sourceEntryCount: rawEntries.length,
-    sourceBytes: rawBytes,
-    consolidatedBytes: Buffer.byteLength(content, "utf8"),
-    trigger: options?.trigger ?? "manual",
-    ...options?.model ? { model: options.model } : {},
-    ...options?.prune ? { pruned: true } : {},
-    ...archived ? { archivePath: archived } : {},
-    ...options?.skills?.length ? { skills: [...options.skills] } : {}
-  };
-  writeTextAtomically(
-    consolidationMetaPath(normalizedRole, projectRoot),
-    `${JSON.stringify(meta, null, 2)}
-`
-  );
-  return fp;
-}
-function clearProjectAgentConsolidated(role, projectRoot) {
-  const normalizedRole = assertProjectAgentRole(role);
-  for (const file of [
-    consolidationPath(normalizedRole, projectRoot),
-    consolidationMetaPath(normalizedRole, projectRoot)
-  ]) {
-    try {
-      rmSync2(file, { force: true });
-    } catch {
-    }
+  const baseRole = assertProjectAgentRole((input.baseRole?.trim() || "generic").toLowerCase());
+  const taskTypes = [...new Set(input.taskTypes.map((item) => item.trim()).filter(Boolean))];
+  if (taskTypes.length === 0 || taskTypes.length > 32 || taskTypes.some((item) => item.length > 160)) {
+    throw new Error("Project agent requires 1-32 task descriptions, each at most 160 characters.");
   }
-}
-function buildConsolidationInstruction(role, projectRoot) {
-  const normalizedRole = assertProjectAgentRole(role);
-  const entries = readRawLearnedEntries(normalizedRole, projectRoot);
-  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}
-
-${entry}`).join("\n\n");
-  const sections = [
-    `You are reviewing and consolidating the captured learning entries for the "${normalizedRole}" agent role in this project.`,
+  const dir = roleDir(role, projectRoot);
+  if (existsSync2(dir) && readdirSync(dir).length > 0) {
+    throw new Error(`Project agent role "${role}" already exists.`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const profile = {
+    role,
+    name,
+    baseRole,
+    purpose,
+    taskTypes,
+    createdAt: now,
+    updatedAt: now
+  };
+  const identity = [
+    `# ${name}`,
     "",
-    "Your task is to synthesize the raw entries below into a single, narrowly-scoped document that represents what this agent has learned \u2014 specifically for its skills and role responsibilities. This document is the **instruction manual for future invocations** of this agent in this project. It is not a journal, not an exhaustive transcription, and not a memory store.",
+    `You are the project-specific "${name}" agent (role: ${role}).`,
     "",
-    "## Requirements",
+    "## Purpose",
     "",
-    "1. **Be selective.** Some raw entries are noise \u2014 narrative descriptions of single-session events, ephemeral references (commit SHAs, timestamps, line numbers, PR refs), or thin fragments that cannot be generalized. **Drop them.** The output must be smaller than the input; a consolidation that preserves every word is not a consolidation.",
-    '2. **Extract the directive.** When a raw entry mixes narrative framing with a buried lesson ("When I worked on X, I realized Y"), extract the lesson as a directive and discard the framing.',
-    "3. **Generic, not specific.** Rewrite entries so they apply across sessions. Replace session-specific anchors (commit SHAs, dates, line numbers) with general principles or concrete tools/commands that will still be valid next month.",
-    "4. **Self-contained bullets.** Each bullet must make sense standalone \u2014 understandable to a future agent that has no context about the session that produced it.",
-    "5. **Narrow scope.** Keep only knowledge that is genuinely durable and role-relevant. When in doubt, leave it out.",
-    "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.",
+    purpose,
     "",
-    rawEntries.length > 0 ? `## Raw learned entries (${rawEntries.length} total)
-
-${rawBody}` : "## Raw learned entries\n\n(No raw entries yet \u2014 return an empty document.)"
-  ];
-  if (existingConsolidation) {
-    sections.push(
-      "",
-      `## Existing consolidated document (for reference \u2014 improve upon it)
-
-${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(
+    "## Primary task types",
     "",
-    "## Output",
+    ...taskTypes.map((item) => `- ${item}`),
     "",
-    "Return ONLY the consolidated markdown document. Do not wrap it in code fences or add commentary."
+    "Learn durable project conventions from completed work, keep conclusions evidence-based, and stay within this assigned purpose.",
+    ""
+  ].join("\n");
+  mkdirSync3(dir, { recursive: true });
+  writeTextAtomically(path7.join(dir, "identity.md"), identity);
+  writeTextAtomically(
+    projectAgentProfilePath(role, projectRoot),
+    `${JSON.stringify(profile, null, 2)}
+`
   );
-  return {
-    instruction: sections.join("\n"),
-    rawEntries,
-    hasExistingConsolidation: Boolean(existingConsolidation)
-  };
+  return profile;
 }
 
-// src/coordination/agents/project-agent-knowledge-manifests.ts
-var BUILT_IN_KNOWLEDGE_MANIFESTS = {
-  android: {
-    role: "android",
-    // Only machine-readable JSON registries belong in liveQueries. Android
-    // release/API data has no JSON registry endpoint, so those checks stay as
-    // checklist prose below.
-    liveQueries: {
-      kotlin: {
-        registry: "https://registry.npmjs.org/kotlin/latest",
-        key: "version",
-        description: "Kotlin latest stable"
-      }
-    },
-    checklist: [
-      "Current Android Gradle Plugin version (8.x+)",
-      "Current Kotlin version (2.x+)",
-      "Current compileSdk / targetSdk (\u2265 34, check Play Store policy)",
-      "Current Jetpack Compose stable version",
-      "All third-party dependencies are at latest compatible minor"
-    ],
-    verifyThreshold: 0.5
+// src/types/runtime-capability-manifest.ts
+var PLAYWRIGHT_ALIASES = {
+  playwright_navigate: "browser_navigate",
+  playwright_screenshot: "browser_screenshot",
+  playwright_click: "browser_click",
+  playwright_type: "browser_type",
+  playwright_evaluate: "browser_evaluate",
+  playwright_select_option: "browser_select",
+  playwright_hover: "browser_hover",
+  playwright_fill_form: "browser_type",
+  playwright_wait_for: "browser_wait",
+  playwright_press_key: "browser_press",
+  playwright_drag: "browser_drag"
+};
+var RUNTIME_CAPABILITY_MANIFEST = [
+  {
+    id: "filesystem.read",
+    pack: "core",
+    exposure: "direct",
+    tools: ["read", "grep", "glob", "tree"]
   },
-  frontend: {
-    role: "frontend",
-    liveQueries: {
-      react: {
-        registry: "https://registry.npmjs.org/react/latest",
-        key: "version",
-        description: "React latest stable"
-      },
-      nextjs: {
-        registry: "https://registry.npmjs.org/next/latest",
-        key: "version",
-        description: "Next.js latest stable"
-      }
-    },
-    checklist: [
-      "Current React version (pinned in package.json)",
-      "Current Next.js / Vite / framework version",
-      "Node.js runtime version (project .nvmrc or engines)",
-      "All devDependencies are at latest compatible versions",
-      "Browser compatibility targets from browserslist"
-    ],
-    verifyThreshold: 0.5
+  {
+    id: "code.inspect",
+    pack: "core",
+    exposure: "direct",
+    tools: [
+      "codebase-stats",
+      "codebase-search",
+      "codebase-incoming-calls",
+      "codebase-outgoing-calls",
+      "codebase-index",
+      "codebase-skeleton",
+      "codebase-repo-map",
+      "codebase-impact-analysis",
+      "dead-code-scan",
+      "diff",
+      "json",
+      "logs"
+    ]
   },
-  executor: {
-    role: "executor",
-    liveQueries: {
-      node: {
-        registry: "https://registry.npmjs.org/node/latest",
-        key: "version",
-        description: "Node.js latest release"
-      }
-    },
-    checklist: [
-      "Node.js version from .nvmrc or package.engines",
-      "TypeScript version from package.json",
-      "Package manager (pnpm \u2265 9) from packageManager",
-      "Current toolchain: esbuild, vitest, etc."
+  {
+    id: "filesystem.write",
+    pack: "development",
+    exposure: "direct",
+    tools: ["write", "edit", "replace", "patch", "codebase-ast-replace"]
+  },
+  {
+    id: "execution.shell",
+    pack: "development",
+    exposure: "direct",
+    tools: ["bash", "exec", "language", "language_info", "language_package"]
+  },
+  {
+    id: "verification.run",
+    pack: "development",
+    exposure: "direct",
+    tools: ["lint", "format", "typecheck", "test", "e2e_plan", "codebase-targeted-test"]
+  },
+  {
+    id: "version-control.manage",
+    pack: "development",
+    exposure: "direct",
+    tools: ["git"]
+  },
+  {
+    id: "dependencies.manage",
+    pack: "development",
+    exposure: "on-demand",
+    tools: ["install", "outdated", "audit"]
+  },
+  {
+    id: "documentation.author",
+    pack: "development",
+    exposure: "on-demand",
+    tools: ["document", "design", "scaffold"]
+  },
+  {
+    id: "web.research",
+    pack: "core",
+    exposure: "direct",
+    tools: ["search", "fetch"]
+  },
+  {
+    id: "work.plan",
+    pack: "core",
+    exposure: "direct",
+    tools: ["todo", "plan", "task", "kanban", "nextsteps"]
+  },
+  {
+    id: "coordination.mailbox",
+    pack: "fleet",
+    exposure: "direct",
+    tools: ["mailbox", "mail_send", "mail_inbox", "fleet_status"]
+  },
+  {
+    id: "fleet.delegate",
+    pack: "fleet",
+    exposure: "on-demand",
+    tools: [
+      "delegate",
+      "spawn_subagent",
+      "assign_task",
+      "kanban_queue",
+      "await_tasks",
+      "ask_subagent",
+      "ask_result",
+      "roll_up",
+      "quality_gate",
+      "terminate_subagent",
+      "terminate_all",
+      "work_complete",
+      "collab_debug",
+      "fleet_emit",
+      "fleet"
+    ]
+  },
+  {
+    id: "reasoning.oneshot",
+    pack: "core",
+    exposure: "on-demand",
+    tools: ["llm", "council"]
+  },
+  {
+    id: "memory.manage",
+    pack: "memory",
+    exposure: "on-demand",
+    tools: ["remember", "search_memory", "find_related_memories", "forget"]
+  },
+  {
+    id: "memory.curate",
+    pack: "memory",
+    exposure: "on-demand",
+    tools: [
+      "memory_candidates",
+      "memory_update",
+      "memory_delete",
+      "memory_recover",
+      "memory_backfill_recoverable",
+      "memory_for_file",
+      "memory_for_path",
+      "memory_search",
+      "memory_graph",
+      "memory_gather_batch",
+      "memory_verify",
+      "memory_hygiene"
+    ]
+  },
+  {
+    id: "browser.interact",
+    pack: "browser",
+    exposure: "on-demand",
+    tools: [
+      "browser_open",
+      "browser_status",
+      "browser_list",
+      "browser_navigate",
+      "browser_snapshot",
+      "browser_screenshot",
+      "browser_click",
+      "browser_type",
+      "browser_select",
+      "browser_press",
+      "browser_hover",
+      "browser_drag",
+      "browser_wait",
+      "browser_evaluate",
+      "browser_upload",
+      "browser_close"
     ],
-    verifyThreshold: 0.6
+    aliases: PLAYWRIGHT_ALIASES
+  },
+  {
+    id: "mcp.dynamic",
+    pack: "mcp",
+    exposure: "on-demand",
+    tools: ["mcp_use"]
+  },
+  {
+    id: "automation.manage",
+    pack: "admin",
+    exposure: "on-demand",
+    tools: ["cron_schedule", "cron_list", "cron_cancel", "watch_start", "watch_list", "watch_stop"]
+  },
+  {
+    id: "context.pin",
+    pack: "admin",
+    exposure: "on-demand",
+    tools: ["pin_add", "pin_list", "pin_remove"]
+  },
+  {
+    id: "quality.analyze",
+    pack: "development",
+    exposure: "on-demand",
+    tools: [
+      "dead_code_scan",
+      "detect_duplicate_code",
+      "secret_scanner_test",
+      "error_lens_history",
+      "security-ast-scan"
+    ]
+  },
+  {
+    id: "release.manage",
+    pack: "development",
+    exposure: "on-demand",
+    tools: ["git_autocommit", "semver_current", "semver_bump", "semver_changelog"]
+  },
+  {
+    id: "messaging.telegram",
+    pack: "fleet",
+    exposure: "on-demand",
+    tools: ["telegram_send", "telegram_read", "telegram_approve"]
+  },
+  {
+    id: "tools.discover",
+    pack: "admin",
+    exposure: "direct",
+    tools: ["tool_search", "tool_use", "tool_help", "batch_tool_use", "clarify"]
+  },
+  {
+    id: "runtime.admin",
+    pack: "admin",
+    exposure: "internal",
+    tools: ["set_working_dir", "context_manager", "mode", "skill", "mcp_control"]
   }
-};
-
-// src/coordination/agents/project-agent-learning-policy.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-var DEFAULT_LEARNING_POLICY = {
-  enabled: true,
-  lifetimeCaptureCount: 0
-};
-function loadProjectAgentLearningPolicy(role, projectRoot) {
-  try {
-    const parsed = JSON.parse(
-      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 } : {},
-      ...typeof parsed.lastOptimizeAt === "string" ? { lastOptimizeAt: parsed.lastOptimizeAt } : {}
-    };
-  } catch {
-    return { ...DEFAULT_LEARNING_POLICY };
+];
+var CAPABILITY_BY_ID = new Map(
+  RUNTIME_CAPABILITY_MANIFEST.map((definition) => [definition.id, definition])
+);
+var CAPABILITY_BY_TOOL = /* @__PURE__ */ new Map();
+var TOOL_ALIASES = /* @__PURE__ */ new Map();
+for (const definition of RUNTIME_CAPABILITY_MANIFEST) {
+  for (const tool of definition.tools) {
+    CAPABILITY_BY_TOOL.set(tool, definition.id);
   }
+  for (const [alias, tool] of Object.entries(definition.aliases ?? {})) {
+    TOOL_ALIASES.set(alias, tool);
+  }
+}
+function toolsForRuntimeCapabilities(capabilityIds) {
+  return [
+    ...new Set(
+      capabilityIds.flatMap((id) => {
+        const definition = CAPABILITY_BY_ID.get(id);
+        if (!definition) throw new Error(`Unknown runtime capability: "${id}"`);
+        return definition.tools;
+      })
+    )
+  ];
+}
+function normalizeRuntimeToolName(name) {
+  return TOOL_ALIASES.get(name) ?? name;
+}
+function runtimeCapabilityForTool(name) {
+  return CAPABILITY_BY_TOOL.get(normalizeRuntimeToolName(name));
 }
-function updateProjectAgentLearningPolicy(role, patch, projectRoot) {
-  const defined = Object.fromEntries(
-    Object.entries(patch).filter(([, value]) => value !== void 0)
-  );
-  const updated = {
-    ...loadProjectAgentLearningPolicy(role, projectRoot),
-    ...defined
-  };
-  writeTextAtomically(
-    learningPolicyPath(role, projectRoot),
-    `${JSON.stringify(updated, null, 2)}
-`
-  );
-  return updated;
+function isKnownRuntimeCapability(id) {
+  return CAPABILITY_BY_ID.has(id);
 }
-function recordProjectAgentOptimizePass(role, projectRoot, at = (/* @__PURE__ */ new Date()).toISOString()) {
-  try {
-    updateProjectAgentLearningPolicy(role, { lastOptimizeAt: at }, projectRoot);
-  } catch {
+function inferRuntimeCapabilities(toolNames) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const rawName of toolNames) {
+    const id = runtimeCapabilityForTool(rawName);
+    if (id) ids.add(id);
   }
+  return [...ids];
 }
-
-// src/coordination/agents/project-agent-skill-layer.ts
-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 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);
+function missingRuntimeCapabilities(required, toolNames) {
+  if (!required || required.length === 0) return [];
+  const available = new Set(inferRuntimeCapabilities(toolNames));
+  return required.filter((id) => !CAPABILITY_BY_ID.has(id) || !available.has(id));
 }
-function loadProjectAgentProfile(role, projectRoot) {
-  try {
-    const parsed = JSON.parse(
-      readFileSync6(projectAgentProfilePath(role, projectRoot), "utf8")
-    );
-    const normalizedRole = assertProjectAgentRole(parsed.role ?? role);
-    const baseRole = assertProjectAgentRole(parsed.baseRole ?? "generic");
-    if (normalizedRole !== assertProjectAgentRole(role)) return void 0;
-    if (typeof parsed.name !== "string" || !parsed.name.trim()) return void 0;
-    if (typeof parsed.purpose !== "string" || !parsed.purpose.trim()) return void 0;
-    if (!Array.isArray(parsed.taskTypes) || parsed.taskTypes.some((item) => typeof item !== "string")) {
-      return void 0;
-    }
-    const createdAt = typeof parsed.createdAt === "string" ? parsed.createdAt : (/* @__PURE__ */ new Date(0)).toISOString();
-    const updatedAt = typeof parsed.updatedAt === "string" ? parsed.updatedAt : createdAt;
-    return {
-      role: normalizedRole,
-      name: parsed.name.trim(),
-      baseRole,
-      purpose: parsed.purpose.trim(),
-      taskTypes: parsed.taskTypes.map((item) => item.trim()).filter(Boolean),
-      createdAt,
-      updatedAt
-    };
-  } catch {
-    return void 0;
-  }
+function missingRequiredRuntimeTools(required, toolNames) {
+  if (!required || required.length === 0) return [];
+  const available = new Set(toolNames.map(normalizeRuntimeToolName));
+  return required.map(normalizeRuntimeToolName).filter((name) => !CAPABILITY_BY_TOOL.has(name) || !available.has(name));
 }
-function createProjectAgent(input, projectRoot) {
-  const name = input.name.trim();
-  const purpose = input.purpose.trim();
-  if (!name || name.length > 120) throw new Error("Project agent name must be 1-120 characters.");
-  if (purpose.length < 10 || purpose.length > 4e3) {
-    throw new Error("Project agent purpose must be 10-4000 characters.");
-  }
-  const role = assertProjectAgentRole(
-    (input.role?.trim() || slugifyProjectAgentRole(name)).toLowerCase()
-  );
-  const baseRole = assertProjectAgentRole((input.baseRole?.trim() || "generic").toLowerCase());
-  const taskTypes = [...new Set(input.taskTypes.map((item) => item.trim()).filter(Boolean))];
-  if (taskTypes.length === 0 || taskTypes.length > 32 || taskTypes.some((item) => item.length > 160)) {
-    throw new Error("Project agent requires 1-32 task descriptions, each at most 160 characters.");
+function runtimeToolReferencesFromText(text) {
+  const references = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/`([a-z][a-z0-9_-]+)`/gi)) {
+    const name = normalizeRuntimeToolName(match[1] ?? "");
+    if (CAPABILITY_BY_TOOL.has(name)) references.add(name);
   }
-  const dir = roleDir(role, projectRoot);
-  if (existsSync2(dir) && readdirSync(dir).length > 0) {
-    throw new Error(`Project agent role "${role}" already exists.`);
+  for (const pattern of [
+    /\b(?:call|use|invoke|run)\s+`([a-z][a-z0-9_-]+)`/gi,
+    /`([a-z][a-z0-9_-]+)`\s+tool\b/gi
+  ]) {
+    for (const match of text.matchAll(pattern)) {
+      references.add(normalizeRuntimeToolName(match[1] ?? ""));
+    }
   }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const profile = {
-    role,
-    name,
-    baseRole,
-    purpose,
-    taskTypes,
-    createdAt: now,
-    updatedAt: now
-  };
-  const identity = [
-    `# ${name}`,
-    "",
-    `You are the project-specific "${name}" agent (role: ${role}).`,
-    "",
-    "## Purpose",
-    "",
-    purpose,
-    "",
-    "## Primary task types",
-    "",
-    ...taskTypes.map((item) => `- ${item}`),
-    "",
-    "Learn durable project conventions from completed work, keep conclusions evidence-based, and stay within this assigned purpose.",
-    ""
-  ].join("\n");
-  mkdirSync3(dir, { recursive: true });
-  writeTextAtomically(path7.join(dir, "identity.md"), identity);
-  writeTextAtomically(
-    projectAgentProfilePath(role, projectRoot),
-    `${JSON.stringify(profile, null, 2)}
-`
-  );
-  return profile;
+  return [...references];
+}
+function isDeprecatedRuntimeToolAlias(name) {
+  return TOOL_ALIASES.has(name) || name.startsWith("mcp__");
 }
 
 // src/coordination/agents/role-skills.ts
@@ -2877,85 +2786,128 @@ function listProjectAgentRoles(projectRoot) {
   }
 }
 
-// src/coordination/agents/project-agent-identity.ts
-function createProjectAgentRoster(baseRoster, projectRoot) {
-  const target = { ...baseRoster };
-  const resolveRole = (role, resolving = /* @__PURE__ */ new Set()) => {
-    if (resolving.has(role)) return void 0;
-    const isBuiltIn = Object.hasOwn(target, role);
-    if (!isBuiltIn && !listProjectAgentRoles(projectRoot).includes(role)) return void 0;
-    resolving.add(role);
-    const profile = loadProjectAgentProfile(role, projectRoot);
-    const template = isBuiltIn ? target[role] : profile ? resolveRole(profile.baseRole, resolving) ?? target["generic"] : target["generic"];
-    resolving.delete(role);
-    if (!template) return void 0;
-    const base = isBuiltIn ? template : {
-      ...template,
-      id: role,
-      role,
-      name: profile?.name ?? role,
-      ...profile ? {
-        dispatch: {
-          summary: profile.purpose,
-          keywords: [
-            ...profile.taskTypes,
-            ...new Set(
-              `${profile.purpose} ${profile.taskTypes.join(" ")}`.toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length >= 3)
-            )
-          ]
-        }
-      } : {}
-    };
-    return applyProjectAgentConfig(base, loadProjectAgentConfig(role, projectRoot), {
-      protectSystemRole: isBuiltIn && !profile
-    });
+// src/security/capabilities.ts
+var ToolCapabilities = {
+  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
+  SHELL_ARBITRARY: "shell.arbitrary",
+  /**
+   * Can execute the `exec` tool's allowlisted commands.
+   *
+   * "Restricted" describes the command NAME check, not the resulting power.
+   * Treat this as equivalent to {@link SHELL_ARBITRARY} when deciding what to
+   * grant: the allowlist includes general-purpose interpreters (`node`,
+   * `python`, `perl`, `ruby`) and, on Windows, the platform shells (`cmd`,
+   * `powershell`, `pwsh`) — deliberately, since without them `exec` cannot run
+   * `dir`/`type`/any cmdlet. `node -e …` or `cmd /c …` therefore reaches
+   * arbitrary execution, and per-argument denylisting cannot close that while
+   * the shells remain (blocking `node -e` still leaves `cmd /c node -e`).
+   *
+   * What actually bounds this is downstream, not the name check: the permission
+   * policy reconstructs the full command line and runs it through the
+   * destructive classifier, so destructive calls still require confirmation.
+   *
+   * Granting `shell.restricted` while withholding `shell.arbitrary` therefore
+   * buys no meaningful reduction in blast radius. Documented rather than
+   * silently implied, because the two read as a narrow/wide pair (WS-083).
+   */
+  SHELL_RESTRICTED: "shell.restricted",
+  /** Can run a restricted project formatter/linter-style command. */
+  SHELL_EXEC: "shell.exec",
+  /** Can read files inside the project (and possibly outside via symlinks if not guarded). */
+  FS_READ: "fs.read",
+  /** Can write / modify / delete files inside the project. */
+  FS_WRITE: "fs.write",
+  /** Can write files outside the current project root (very high risk). */
+  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Can perform outbound network requests. */
+  NET_OUTBOUND: "net.outbound",
+  /** Can mutate in-memory session todos only. */
+  SESSION_TODO: "session.todo",
+  /** Can park after-task `<nextsteps>` suggestions for the current turn. */
+  SESSION_NEXTSTEPS: "session.nextsteps",
+  /** Can mutate in-memory session mode only. */
+  SESSION_MODE: "session.mode",
+  /** Can inspect registered tool metadata. */
+  TOOL_META: "tool.meta",
+  /** Can invoke arbitrary registered tools through a meta-tool. */
+  TOOL_MUTATE_ANY: "tool.mutate.any",
+  /** Can read persistent memory. */
+  MEMORY_READ: "memory.read",
+  /** Can write persistent memory. */
+  MEMORY_WRITE: "memory.write",
+  /** Can delete persistent memory. */
+  MEMORY_DELETE: "memory.delete",
+  /** Proxies tools from external MCP servers (unknown capability). */
+  MCP_PROXY: "mcp.proxy",
+  /** Can spawn or manage subagents / multi-agent tasks. */
+  SUBAGENT_SPAWN: "subagent.spawn",
+  /** Can inspect fleet/subagent coordination state without mutating it. */
+  COORDINATION_FLEET_READ: "coordination.fleet.read",
+  /** Can publish attributed, schema-checked events onto the fleet bus. */
+  COORDINATION_FLEET_EMIT: "coordination.fleet.emit",
+  /** Can submit a task-local structured result to the parent Director. */
+  COORDINATION_RESULT_SUBMIT: "coordination.result.submit",
+  /** Can read or write inter-agent mailbox messages. */
+  COORDINATION_MAIL: "coordination.mail",
+  /** Can schedule, inspect, or cancel in-session cron jobs. */
+  COORDINATION_CRON: "coordination.cron",
+  /** Can mutate global or session configuration / trust state. */
+  CONFIG_MUTATE: "config.mutate",
+  /** Can install packages or run package managers with side effects. */
+  PACKAGE_INSTALL: "package.install"
+};
+var DANGEROUS_FOR_SUBAGENTS = [
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.TOOL_MUTATE_ANY,
+  ToolCapabilities.MEMORY_WRITE,
+  ToolCapabilities.MEMORY_DELETE,
+  ToolCapabilities.MCP_PROXY,
+  ToolCapabilities.SUBAGENT_SPAWN,
+  ToolCapabilities.CONFIG_MUTATE,
+  ToolCapabilities.PACKAGE_INSTALL
+];
+var WIDE_SUBAGENT_CAPABILITIES = [
+  ToolCapabilities.FS_READ,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.NET_OUTBOUND,
+  ToolCapabilities.SESSION_TODO,
+  ToolCapabilities.TOOL_META,
+  ToolCapabilities.MEMORY_READ,
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.PACKAGE_INSTALL,
+  // Read-only fleet visibility (fleet_status) — peer awareness has no blast
+  // radius and every fleet worker should coordinate around its peers.
+  ToolCapabilities.COORDINATION_FLEET_READ,
+  ToolCapabilities.COORDINATION_RESULT_SUBMIT
+];
+function clampSubagentCapabilities(requested, ceiling = WIDE_SUBAGENT_CAPABILITIES) {
+  const ceilingSet = new Set(ceiling);
+  const requestedSet = new Set(requested);
+  return {
+    granted: ceiling.filter((capability) => requestedSet.has(capability)),
+    dropped: [...requestedSet].filter((capability) => !ceilingSet.has(capability))
   };
-  return new Proxy(target, {
-    get(current, property, receiver) {
-      if (typeof property !== "string") return Reflect.get(current, property, receiver);
-      return resolveRole(property) ?? Reflect.get(current, property, receiver);
-    },
-    has(current, property) {
-      return typeof property === "string" ? Reflect.has(current, property) || resolveRole(property) !== void 0 : Reflect.has(current, property);
-    },
-    ownKeys(current) {
-      return [.../* @__PURE__ */ new Set([...Reflect.ownKeys(current), ...listProjectAgentRoles(projectRoot)])];
-    },
-    getOwnPropertyDescriptor(current, property) {
-      const descriptor = Reflect.getOwnPropertyDescriptor(current, property);
-      if (descriptor || typeof property !== "string" || !resolveRole(property)) return descriptor;
-      return {
-        configurable: true,
-        enumerable: true,
-        writable: false,
-        value: resolveRole(property)
-      };
-    }
-  });
-}
-function loadProjectAgentIdentity(role, projectRoot) {
-  const identityPath = path11.join(roleDir(role, projectRoot), "identity.md");
-  try {
-    return readFileSync9(identityPath, "utf8").trim();
-  } catch {
-    return "";
-  }
-}
-function loadProjectAgentLearned(role, projectRoot) {
-  const learnedPath3 = path11.join(roleDir(role, projectRoot), "learned.md");
-  try {
-    return readFileSync9(learnedPath3, "utf8").trim();
-  } catch {
-    return "";
-  }
 }
-function loadRoleKnowledgeManifest(role, projectRoot) {
-  const projectPath = path11.join(roleDir(role, projectRoot), "knowledge.json");
-  try {
-    const raw = readFileSync9(projectPath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return BUILT_IN_KNOWLEDGE_MANIFESTS[role];
+
+// src/coordination/agents/project-agent-roster.ts
+var SYSTEM_AGENT_BUDGET_FLOORS = {
+  timeoutMs: 3e5,
+  idleTimeoutMs: 12e4,
+  maxIterations: 20,
+  maxToolCalls: 40,
+  maxTokens: 8192,
+  maxCostUsd: 0.25
+};
+function applySystemAgentBudgetFloors(config) {
+  for (const [field, floor] of Object.entries(SYSTEM_AGENT_BUDGET_FLOORS)) {
+    const value = config[field];
+    if (typeof value === "number" && value < floor) config[field] = floor;
   }
 }
 function applyProjectAgentConfig(base, projectConfig, options = {}) {
@@ -2972,8 +2924,6 @@ function applyProjectAgentConfig(base, projectConfig, options = {}) {
     result.modelPolicy = {
       allowed: projectConfig.modelPolicy.allowed.map((target) => ({ ...target })),
       fallbacks: projectConfig.modelPolicy.fallbacks?.map((target) => ({ ...target })),
-      // System roles must remain recoverable even when a preferred model is
-      // temporarily unavailable. Custom roles may opt into a hard boundary.
       strict: options.protectSystemRole ? false : projectConfig.modelPolicy.strict ?? false
     };
     result.fallbackModels = (projectConfig.modelPolicy.fallbacks ?? []).map(
@@ -3014,177 +2964,82 @@ function applyProjectAgentConfig(base, projectConfig, options = {}) {
   if (options.protectSystemRole) applySystemAgentBudgetFloors(result);
   return result;
 }
-var SYSTEM_AGENT_BUDGET_FLOORS = {
-  timeoutMs: 3e5,
-  idleTimeoutMs: 12e4,
-  maxIterations: 20,
-  maxToolCalls: 40,
-  maxTokens: 8192,
-  maxCostUsd: 0.25
-};
-function applySystemAgentBudgetFloors(config) {
-  for (const [field, floor] of Object.entries(SYSTEM_AGENT_BUDGET_FLOORS)) {
-    const value = config[field];
-    if (typeof value === "number" && value < floor) config[field] = floor;
-  }
-}
-function buildProjectContextualizedPrompt(basePrompt, role, projectRoot, options = {}) {
-  const contextStart = "<!-- wrongstack:project-agent-context:start -->";
-  const contextEnd = "<!-- wrongstack:project-agent-context:end -->";
-  if (process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"]) return basePrompt;
-  const cleanBase = basePrompt.replace(
-    /\s*<!-- wrongstack:project-agent-context:start -->[\s\S]*?<!-- wrongstack:project-agent-context:end -->\s*/g,
-    "\n"
-  ).trim();
-  const parts = [cleanBase];
-  const identity = options.identityOverride ?? loadProjectAgentIdentity(role, projectRoot);
-  if (identity) {
-    parts.push(`
-
-# Project custom identity
-
-${identity}`);
-  }
-  const learningPolicy = loadProjectAgentLearningPolicy(role, projectRoot);
-  let learnedContent = "";
-  let learnedLabel = "";
-  if (learningPolicy.enabled) {
-    const consolidated = loadProjectAgentConsolidated(role, projectRoot);
-    const rawLearned = loadProjectAgentLearned(role, projectRoot);
-    if (consolidated) {
-      const meta = loadConsolidationMetadata(role, projectRoot);
-      const rawEntries = parseStructuredLearnedEntriesFromContent(
-        rawLearned,
-        splitLearnedEntries(rawLearned)
-      );
-      const rawBytes = Buffer.byteLength(rawLearned, "utf8");
-      const freshEntries = meta === void 0 ? [] : rawEntries.filter((entry) => entry.capturedAt > meta.consolidatedAt);
-      const stale = meta === void 0 || freshEntries.length > 0 || rawEntries.length > meta.sourceEntryCount || rawBytes > meta.sourceBytes;
-      if (!stale) {
-        learnedContent = consolidated;
-        learnedLabel = "Consolidated knowledge for this project";
-      } else if (freshEntries.length > 0) {
-        const delta = freshEntries.map((entry) => `- **${entry.what}**`).join("\n");
-        learnedContent = `${consolidated}
-
----
-
-## Recently captured (pending next optimization)
-
-${delta}`;
-        learnedLabel = "Consolidated knowledge for this project";
-      } else {
-        learnedContent = rawLearned;
-        learnedLabel = "Learned instructions for this project (structured: what / why / how)";
-      }
-    } else {
-      learnedContent = rawLearned;
-      learnedLabel = "Learned instructions for this project (structured: what / why / how)";
-    }
-  }
-  if (learnedContent) {
-    const meaningful = learnedContent.replace(/<!--[\s\S]*?-->/g, "").trim();
-    if (meaningful.length > 0) {
-      parts.push(`
-
-# ${learnedLabel}
-
-${learnedContent}`);
-    }
-  }
-  const effectiveProjectRoot = projectRoot || process.cwd();
-  const learnedFilePath = path11.join(
-    effectiveProjectRoot,
-    ".wrongstack",
-    "agents",
-    role,
-    "learned.md"
-  );
-  if (learningPolicy.enabled) {
-    parts.push(
-      `
-
-## Knowledge capture
-
-The file below stores **learning data for this project's "${role}" agent** \u2014 not your memory, not a session log. It is read back into the system prompt of every future "${role}" invocation, so each entry must teach a future agent how to act. On every capture the runtime **merges your new entry with every prior entry and rewrites the whole buffer as a structured instruction list** \u2014 grouped by category ("What to do", "What to avoid", "Patterns to follow", "Project facts"), with each item decomposed into **what** (the rule), **why** (the reason), and **how** (the concrete commands, file paths, or package names that anchor the rule). When you discover a durable principle that future invocations should follow, end your response with a \`## LEARNED\` block. The runtime persists it to:
-
-  \`\`\`
-  ${learnedFilePath}
-  \`\`\`
-
-**Write directives, not narratives.** Each LEARNED entry should be:
-
-- A **rule or principle** that applies across sessions, not a description of what happened in this one.
-- A short **imperative or statement** (1\u20133 sentences), starting with a verb like "Always verify\u2026", "Use X for Y", "Avoid\u2026", "Never assume\u2026".
-- **Generic** \u2014 no commit SHAs, timestamps, specific line numbers, or PR/issue numbers. File paths, package names, and command names are fine when they anchor the lesson.
-- **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):
-
-\`\`\`
-## LEARNED
-When I worked on the telegram plugin today, commit 9c7682b84 had a race condition in poll-lock at line 42 because writeFileSync wasn't using the 'wx' flag.
-\`\`\`
-
-**Good** (directive \u2014 persists, then merges into the structured list):
-
-\`\`\`
-## LEARNED
-Always use the 'wx' (exclusive create) flag with writeFileSync when implementing concurrent lock acquisition in \`packages/core/src/.../poll-lock.ts\` \u2014 filesystem-level atomicity guarantees only one writer wins.
-\`\`\`
-
-Capture only durable, cross-session knowledge \u2014 never ephemeral task details.`
-    );
-  }
-  const knowledge = loadRoleKnowledgeManifest(role, projectRoot);
-  if (knowledge) {
-    const knowledgeSections = [];
-    if (knowledge.checklist.length > 0) {
-      knowledgeSections.push(
-        `Verify these before answering:
-${knowledge.checklist.map((item) => `- ${item}`).join("\n")}`
-      );
-    }
-    const liveQueries = Object.entries(knowledge.liveQueries ?? {});
-    if (liveQueries.length > 0) {
-      const threshold = Number.isFinite(knowledge.verifyThreshold) ? knowledge.verifyThreshold : 0.5;
-      knowledgeSections.push(
-        `When your confidence in any of the following is below ${threshold}, fetch the live value rather than recalling it:
-` + liveQueries.map(
-          ([topic, query]) => `- **${topic}** \u2014 ${query.description}: \`${query.registry}\` \u2192 field \`${query.key}\``
-        ).join("\n")
-      );
-    }
-    if (knowledgeSections.length > 0) {
-      parts.push(`
-
-## Current knowledge requirements
-
-${knowledgeSections.join("\n\n")}`);
+function createProjectAgentRoster(baseRoster, projectRoot) {
+  const target = { ...baseRoster };
+  const resolveRole = (role, resolving = /* @__PURE__ */ new Set()) => {
+    if (resolving.has(role)) return void 0;
+    const isBuiltIn = Object.hasOwn(target, role);
+    if (!isBuiltIn && !listProjectAgentRoles(projectRoot).includes(role)) return void 0;
+    resolving.add(role);
+    const profile = loadProjectAgentProfile(role, projectRoot);
+    const template = isBuiltIn ? target[role] : profile ? resolveRole(profile.baseRole, resolving) ?? target["generic"] : target["generic"];
+    resolving.delete(role);
+    if (!template) return void 0;
+    const base = isBuiltIn ? template : {
+      ...template,
+      id: role,
+      role,
+      name: profile?.name ?? role,
+      ...profile ? {
+        dispatch: {
+          summary: profile.purpose,
+          keywords: [
+            ...profile.taskTypes,
+            ...new Set(
+              `${profile.purpose} ${profile.taskTypes.join(" ")}`.toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length >= 3)
+            )
+          ]
+        }
+      } : {}
+    };
+    return applyProjectAgentConfig(base, loadProjectAgentConfig(role, projectRoot), {
+      protectSystemRole: isBuiltIn && !profile
+    });
+  };
+  return new Proxy(target, {
+    get(current, property, receiver) {
+      if (typeof property !== "string") return Reflect.get(current, property, receiver);
+      return resolveRole(property) ?? Reflect.get(current, property, receiver);
+    },
+    has(current, property) {
+      return typeof property === "string" ? Reflect.has(current, property) || resolveRole(property) !== void 0 : Reflect.has(current, property);
+    },
+    ownKeys(current) {
+      return [.../* @__PURE__ */ new Set([...Reflect.ownKeys(current), ...listProjectAgentRoles(projectRoot)])];
+    },
+    getOwnPropertyDescriptor(current, property) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(current, property);
+      if (descriptor || typeof property !== "string" || !resolveRole(property)) return descriptor;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: resolveRole(property)
+      };
     }
-  }
-  const developedSkills = listProjectSkillAugmentations(role, projectRoot);
-  if (developedSkills.length > 0) {
-    parts.push(
-      `
-
-## Project-developed skills
+  });
+}
 
-These skills have been extended with practice learned in this project: ${developedSkills.map((skill) => `\`${skill}\``).join(", ")}. Their project addendum is attached to the skill body \u2014 follow it over the generic method when the two differ.`
-    );
+// src/coordination/agents/project-agent-capture.ts
+import { existsSync as existsSync4, readFileSync as readFileSync9 } from "node:fs";
+import * as path11 from "node:path";
+function loadProjectAgentLearned(role, projectRoot) {
+  const learnedPath3 = path11.join(roleDir(role, projectRoot), "learned.md");
+  try {
+    return readFileSync9(learnedPath3, "utf8").trim();
+  } catch {
+    return "";
   }
-  const additions = parts.slice(1).join("\n\n").trim();
-  if (!additions) return cleanBase;
-  return `${cleanBase}
-
-${contextStart}
-${additions}
-${contextEnd}`;
+}
+function listProjectAgentLearnedEntries(role, projectRoot) {
+  return splitLearnedEntries(loadProjectAgentLearned(role, projectRoot));
+}
+function parseStructuredLearnedEntries(role, projectRoot) {
+  const raw = loadProjectAgentLearned(role, projectRoot);
+  return parseStructuredLearnedEntriesFromContent(
+    raw,
+    listProjectAgentLearnedEntries(role, projectRoot)
+  );
 }
 function resolveCaptureKey(role, projectRoot) {
   return `${path11.resolve(projectRoot ?? process.cwd())}\0${assertProjectAgentRole(role)}`;
@@ -3286,16 +3141,6 @@ function detectLearnedConflicts(projectRoot) {
   }
   return conflicts.sort((a, b) => b.similarity - a.similarity);
 }
-function listProjectAgentLearnedEntries(role, projectRoot) {
-  return splitLearnedEntries(loadProjectAgentLearned(role, projectRoot));
-}
-function parseStructuredLearnedEntries(role, projectRoot) {
-  const raw = loadProjectAgentLearned(role, projectRoot);
-  return parseStructuredLearnedEntriesFromContent(
-    raw,
-    listProjectAgentLearnedEntries(role, projectRoot)
-  );
-}
 function captureLearnedFromAgentOutput(output, role, projectRoot, isManual = false) {
   return captureLearnedFromAgentOutputDetailed(output, role, projectRoot, isManual).captured;
 }
@@ -3443,11 +3288,188 @@ function hintLearnedNeedsSummarization(role, projectRoot) {
   return `Learned wisdom for role "${role}" is ${bytes} B (soft limit ${LEARNED_SOFT_LIMIT}). Schedule a low-priority consolidation pass.`;
 }
 
+// src/coordination/agents/project-agent-identity.ts
+function loadProjectAgentIdentity(role, projectRoot) {
+  const identityPath = path12.join(roleDir(role, projectRoot), "identity.md");
+  try {
+    return readFileSync10(identityPath, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+function loadRoleKnowledgeManifest(role, projectRoot) {
+  const projectPath = path12.join(roleDir(role, projectRoot), "knowledge.json");
+  try {
+    const raw = readFileSync10(projectPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return BUILT_IN_KNOWLEDGE_MANIFESTS[role];
+  }
+}
+function buildProjectContextualizedPrompt(basePrompt, role, projectRoot, options = {}) {
+  const contextStart = "<!-- wrongstack:project-agent-context:start -->";
+  const contextEnd = "<!-- wrongstack:project-agent-context:end -->";
+  if (process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"]) return basePrompt;
+  const cleanBase = basePrompt.replace(
+    /\s*<!-- wrongstack:project-agent-context:start -->[\s\S]*?<!-- wrongstack:project-agent-context:end -->\s*/g,
+    "\n"
+  ).trim();
+  const parts = [cleanBase];
+  const identity = options.identityOverride ?? loadProjectAgentIdentity(role, projectRoot);
+  if (identity) {
+    parts.push(`
+
+# Project custom identity
+
+${identity}`);
+  }
+  const learningPolicy = loadProjectAgentLearningPolicy(role, projectRoot);
+  let learnedContent = "";
+  let learnedLabel = "";
+  if (learningPolicy.enabled) {
+    const consolidated = loadProjectAgentConsolidated(role, projectRoot);
+    const rawLearned = loadProjectAgentLearned(role, projectRoot);
+    if (consolidated) {
+      const meta = loadConsolidationMetadata(role, projectRoot);
+      const rawEntries = parseStructuredLearnedEntriesFromContent(
+        rawLearned,
+        splitLearnedEntries(rawLearned)
+      );
+      const rawBytes = Buffer.byteLength(rawLearned, "utf8");
+      const freshEntries = meta === void 0 ? [] : rawEntries.filter((entry) => entry.capturedAt > meta.consolidatedAt);
+      const stale = meta === void 0 || freshEntries.length > 0 || rawEntries.length > meta.sourceEntryCount || rawBytes > meta.sourceBytes;
+      if (!stale) {
+        learnedContent = consolidated;
+        learnedLabel = "Consolidated knowledge for this project";
+      } else if (freshEntries.length > 0) {
+        const delta = freshEntries.map((entry) => `- **${entry.what}**`).join("\n");
+        learnedContent = `${consolidated}
+
+---
+
+## Recently captured (pending next optimization)
+
+${delta}`;
+        learnedLabel = "Consolidated knowledge for this project";
+      } else {
+        learnedContent = rawLearned;
+        learnedLabel = "Learned instructions for this project (structured: what / why / how)";
+      }
+    } else {
+      learnedContent = rawLearned;
+      learnedLabel = "Learned instructions for this project (structured: what / why / how)";
+    }
+  }
+  if (learnedContent) {
+    const meaningful = learnedContent.replace(/<!--[\s\S]*?-->/g, "").trim();
+    if (meaningful.length > 0) {
+      parts.push(`
+
+# ${learnedLabel}
+
+${learnedContent}`);
+    }
+  }
+  const effectiveProjectRoot = projectRoot || process.cwd();
+  const learnedFilePath = path12.join(
+    effectiveProjectRoot,
+    ".wrongstack",
+    "agents",
+    role,
+    "learned.md"
+  );
+  if (learningPolicy.enabled) {
+    parts.push(
+      `
+
+## Knowledge capture
+
+The file below stores **learning data for this project's "${role}" agent** \u2014 not your memory, not a session log. It is read back into the system prompt of every future "${role}" invocation, so each entry must teach a future agent how to act. On every capture the runtime **merges your new entry with every prior entry and rewrites the whole buffer as a structured instruction list** \u2014 grouped by category ("What to do", "What to avoid", "Patterns to follow", "Project facts"), with each item decomposed into **what** (the rule), **why** (the reason), and **how** (the concrete commands, file paths, or package names that anchor the rule). When you discover a durable principle that future invocations should follow, end your response with a \`## LEARNED\` block. The runtime persists it to:
+
+  \`\`\`
+  ${learnedFilePath}
+  \`\`\`
+
+**Write directives, not narratives.** Each LEARNED entry should be:
+
+- A **rule or principle** that applies across sessions, not a description of what happened in this one.
+- A short **imperative or statement** (1\u20133 sentences), starting with a verb like "Always verify\u2026", "Use X for Y", "Avoid\u2026", "Never assume\u2026".
+- **Generic** \u2014 no commit SHAs, timestamps, specific line numbers, or PR/issue numbers. File paths, package names, and command names are fine when they anchor the lesson.
+- **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):
+
+\`\`\`
+## LEARNED
+When I worked on the telegram plugin today, commit 9c7682b84 had a race condition in poll-lock at line 42 because writeFileSync wasn't using the 'wx' flag.
+\`\`\`
+
+**Good** (directive \u2014 persists, then merges into the structured list):
+
+\`\`\`
+## LEARNED
+Always use the 'wx' (exclusive create) flag with writeFileSync when implementing concurrent lock acquisition in \`packages/core/src/.../poll-lock.ts\` \u2014 filesystem-level atomicity guarantees only one writer wins.
+\`\`\`
+
+Capture only durable, cross-session knowledge \u2014 never ephemeral task details.`
+    );
+  }
+  const knowledge = loadRoleKnowledgeManifest(role, projectRoot);
+  if (knowledge) {
+    const knowledgeSections = [];
+    if (knowledge.checklist.length > 0) {
+      knowledgeSections.push(
+        `Verify these before answering:
+${knowledge.checklist.map((item) => `- ${item}`).join("\n")}`
+      );
+    }
+    const liveQueries = Object.entries(knowledge.liveQueries ?? {});
+    if (liveQueries.length > 0) {
+      const threshold = Number.isFinite(knowledge.verifyThreshold) ? knowledge.verifyThreshold : 0.5;
+      knowledgeSections.push(
+        `When your confidence in any of the following is below ${threshold}, fetch the live value rather than recalling it:
+` + liveQueries.map(
+          ([topic, query]) => `- **${topic}** \u2014 ${query.description}: \`${query.registry}\` \u2192 field \`${query.key}\``
+        ).join("\n")
+      );
+    }
+    if (knowledgeSections.length > 0) {
+      parts.push(`
+
+## Current knowledge requirements
+
+${knowledgeSections.join("\n\n")}`);
+    }
+  }
+  const developedSkills = listProjectSkillAugmentations(role, projectRoot);
+  if (developedSkills.length > 0) {
+    parts.push(
+      `
+
+## Project-developed skills
+
+These skills have been extended with practice learned in this project: ${developedSkills.map((skill) => `\`${skill}\``).join(", ")}. Their project addendum is attached to the skill body \u2014 follow it over the generic method when the two differ.`
+    );
+  }
+  const additions = parts.slice(1).join("\n\n").trim();
+  if (!additions) return cleanBase;
+  return `${cleanBase}
+
+${contextStart}
+${additions}
+${contextEnd}`;
+}
+
 // src/coordination/agents/agent-prompts.ts
 var promptCache = /* @__PURE__ */ new Map();
 var candidateCache = /* @__PURE__ */ new Map();
 var TECH_VERSION_POLICY_KEY = "\0__tech_version_policy__";
-var techVersionPolicyBody;
+var techVersionPolicyCache = /* @__PURE__ */ new Map();
 var INLINE_TECH_VERSION_POLICY = `# Mandatory modern technology policy
 
 You are bound to the current stable version of every library, framework and
@@ -3514,63 +3536,89 @@ package you use. The latest stable is preferred; the latest *published* is
     **"This package does not exist on the registry."** and the role must
     propose a real, maintained alternative.`;
 function loadTechVersionPolicy() {
-  if (techVersionPolicyBody !== void 0) return techVersionPolicyBody;
-  const fromDisk = policyBody();
-  techVersionPolicyBody = fromDisk || INLINE_TECH_VERSION_POLICY;
-  return techVersionPolicyBody;
+  const envDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"] ?? "";
+  const cached = techVersionPolicyCache.get(envDir);
+  if (cached !== void 0) return cached;
+  const fromDisk = policyBody(envDir);
+  const body = fromDisk || INLINE_TECH_VERSION_POLICY;
+  techVersionPolicyCache.set(envDir, body);
+  return body;
 }
-function policyCandidateDirs() {
-  const here = path12.dirname(fileURLToPath(import.meta.url));
+function policyCandidateDirs(envDir) {
+  const here = path13.dirname(fileURLToPath(import.meta.url));
   const profileInstructions = resolveWstackPaths({ projectRoot: process.cwd() }).globalInstructions;
   return [
-    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"),
+    ...envDir ? [path13.resolve(envDir)] : [],
+    path13.resolve(here, "../../../../instructions/agents"),
+    path13.resolve(here, "../../../instructions/agents"),
+    path13.resolve(here, "../../instructions/agents"),
+    path13.resolve(here, "../instructions/agents"),
+    path13.resolve(here, "instructions/agents"),
+    path13.join(profileInstructions, "agents"),
     profileInstructions
   ].filter((dir, index, all) => all.indexOf(dir) === index);
 }
-function policyBody() {
-  const here = path12.dirname(fileURLToPath(import.meta.url));
+function policyBody(envDir) {
+  const here = path13.dirname(fileURLToPath(import.meta.url));
   const roots = [
-    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")
+    path13.resolve(here, "_policy/tech-version.md"),
+    path13.resolve(here, "../_policy/tech-version.md"),
+    path13.resolve(here, "../../../instructions/agents/_policy/tech-version.md"),
+    path13.resolve(here, "../../instructions/agents/_policy/tech-version.md"),
+    path13.resolve(here, "../instructions/agents/_policy/tech-version.md"),
+    path13.resolve(here, "../../../../instructions/agents/_policy/tech-version.md"),
+    path13.resolve(here, "instructions/agents/_policy/tech-version.md")
   ];
+  if (envDir) {
+    roots.unshift(path13.resolve(envDir, "_policy/tech-version.md"));
+  }
   for (const file of roots) {
     try {
-      return readFileSync10(file, "utf8").trim();
+      return readFileSync11(file, "utf8").trim();
     } catch {
     }
   }
-  for (const dir of policyCandidateDirs()) {
+  for (const dir of policyCandidateDirs(envDir)) {
     try {
-      return readFileSync10(path12.join(dir, "_policy", "tech-version.md"), "utf8").trim();
+      return readFileSync11(path13.join(dir, "_policy", "tech-version.md"), "utf8").trim();
     } catch {
     }
   }
   return "";
 }
+var OVERLAY_FILES = ["identity.md", "learned.md", "consolidated.md"];
+function agentOverlayFingerprint(id, projectRoot) {
+  if (process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"]) return "";
+  let roleDir2;
+  try {
+    roleDir2 = path13.join(projectRoot, ".wrongstack", "agents", assertProjectAgentRole(id));
+  } catch {
+    return "";
+  }
+  let fp = "";
+  for (const name of OVERLAY_FILES) {
+    try {
+      const st = statSync2(path13.join(roleDir2, name));
+      fp += `${name}:${st.mtimeMs}:${st.size};`;
+    } catch {
+    }
+  }
+  return fp;
+}
 function agentPrompt(id) {
   if (id === TECH_VERSION_POLICY_KEY) return loadTechVersionPolicy();
   const envDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"] ?? "";
   const policyOn = process.env["WRONGSTACK_AGENT_POLICY"] === "on";
   const cacheBypass = globalThis.__WS_DISABLE_PROMPT_CACHE__ === true;
   const promptProjectRoot = process.env["WRONGSTACK_PROJECT_ROOT"] || process.cwd();
-  const cacheKey = `${envDir}\0${policyOn ? 1 : 0}\0${promptProjectRoot}\0${id}`;
+  const cacheKey = `${envDir}\0${policyOn ? 1 : 0}\0${promptProjectRoot}\0${agentOverlayFingerprint(id, promptProjectRoot)}\0${id}`;
   const cached = cacheBypass ? void 0 : promptCache.get(cacheKey);
   if (cached !== void 0) return cached;
   const fileName = `${id}.md`;
   let resolved = "";
-  for (const dir of agentPromptDirCandidates(envDir)) {
+  for (const dir of agentPromptDirCandidates(envDir, promptProjectRoot)) {
     try {
-      resolved = readFileSync10(path12.join(dir, fileName), "utf8").trim();
+      resolved = readFileSync11(path13.join(dir, fileName), "utf8").trim();
       break;
     } catch {
     }
@@ -3591,21 +3639,21 @@ ${policy}`;
   if (!cacheBypass) promptCache.set(cacheKey, resolved);
   return resolved;
 }
-function agentPromptDirCandidates(envDir) {
-  const profileInstructions = resolveWstackPaths({ projectRoot: process.cwd() }).globalInstructions;
-  const candKey = `${envDir}\0${profileInstructions}`;
+function agentPromptDirCandidates(envDir, projectRoot) {
+  const profileInstructions = resolveWstackPaths({ projectRoot }).globalInstructions;
+  const candKey = `${envDir}\0${projectRoot}\0${profileInstructions}`;
   const cached = candidateCache.get(candKey);
   if (cached !== void 0) return cached;
-  const here = path12.dirname(fileURLToPath(import.meta.url));
+  const here = path13.dirname(fileURLToPath(import.meta.url));
   const explicitDir = envDir || void 0;
   const candidates = [
-    ...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")
+    ...explicitDir ? [path13.resolve(explicitDir)] : [],
+    path13.join(profileInstructions, "agents"),
+    path13.resolve(here, "../../../../instructions/agents"),
+    path13.resolve(here, "../../../instructions/agents"),
+    path13.resolve(here, "../../instructions/agents"),
+    path13.resolve(here, "../instructions/agents"),
+    path13.resolve(here, "instructions/agents")
   ];
   const ordered = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
   candidateCache.set(candKey, ordered);
@@ -6227,7 +6275,7 @@ export {
   directiveWasApplied,
   enforceLearnedBudget,
   evaluateAutoOptimize,
-  existsSync4 as existsSync,
+  existsSync5 as existsSync,
   getAgentDefinition,
   getProjectAgentLearnStats,
   hintLearnedNeedsSummarization,