@wrongstack/core 0.300.0 → 0.301.0

package/dist/coordination/agents/index.js

@@ -1,56 +1,3 @@
-// src/coordination/agents/types.ts
-var HOUR = 60 * 60 * 1e3;
-var LIGHT_BUDGET = {
-  timeoutMs: 3 * HOUR,
-  maxIterations: 3e3,
-  maxToolCalls: 8e3
-};
-var MEDIUM_BUDGET = {
-  timeoutMs: 5 * HOUR,
-  maxIterations: 5e3,
-  maxToolCalls: 14e3
-};
-var HEAVY_BUDGET = {
-  timeoutMs: 10 * HOUR,
-  maxIterations: 8e3,
-  maxToolCalls: 2e4
-};
-var TOOLS = {
-  /** Pure read/inspect — safe for analysis and review agents. */
-  read: ["read", "grep", "glob", "search", "tree", "mailbox"],
-  /** Read + structured inspection (logs, diffs, json, dependency audit). */
-  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"],
-  /** Read + edit (no shell). For agents that write code/docs but don't run it. */
-  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"],
-  /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
-  build: [
-    "read",
-    "grep",
-    "glob",
-    "search",
-    "tree",
-    "write",
-    "edit",
-    "replace",
-    "patch",
-    "bash",
-    "exec",
-    "lint",
-    "format",
-    "typecheck",
-    "test",
-    "mailbox"
-  ],
-  /** Version control. */
-  vcs: ["read", "grep", "glob", "git", "diff"],
-  /** Dependency management + CVE audit. */
-  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
-  /** Documentation authoring. */
-  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"],
-  /** Web research. */
-  research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
-};
-
 // src/coordination/agents/agent-prompts.ts
 import { readFileSync as readFileSync7, statSync as statSync2 } from "node:fs";
 import * as path8 from "node:path";
@@ -73,6 +20,9 @@ function canonicalProjectRoot(absRoot) {
     const commonDirFile = path.join(gitDir, "commondir");
     if (!fs.statSync(commonDirFile).isFile()) return checkoutRoot;
     const commonDir = path.resolve(gitDir, fs.readFileSync(commonDirFile, "utf8").trim());
+    const worktreesDir = path.dirname(gitDir);
+    if (path.basename(worktreesDir).toLowerCase() !== "worktrees") return checkoutRoot;
+    if (path.resolve(worktreesDir, "..") !== commonDir) return checkoutRoot;
     if (path.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
     return path.dirname(commonDir);
   } catch {
@@ -95,7 +45,7 @@ function safeProfileName(name) {
   const safe = (name ?? "").replace(/[/\\:]/g, "_").replace(/\.\./g, "_").trim();
   return safe || "default";
 }
-function activeProfileName(globalRoot) {
+function bootstrapProfileName(globalRoot) {
   try {
     const parsed = JSON.parse(fs.readFileSync(path.join(globalRoot, "config.json"), "utf8"));
     return safeProfileName(
@@ -113,7 +63,7 @@ function wstackGlobalRoot() {
 function resolveWstackPaths(opts) {
   const globalRoot = opts.globalRoot ?? (opts.userHome ? path.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const homeDir = opts.userHome ?? os.homedir();
-  const profileName = safeProfileName(opts.profileName ?? activeProfileName(globalRoot));
+  const profileName = safeProfileName(opts.profileName ?? bootstrapProfileName(globalRoot));
   const profileDir = path.join(globalRoot, "profiles", profileName);
   const hash = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
@@ -183,7 +133,12 @@ function resolveWstackPaths(opts) {
     projectRequirementIntakes: path.join(projectDir, "requirement-intakes"),
     syncConfig: path.join(profileDir, "sync.json"),
     configHistoryDir: path.join(globalRoot, "config-history"),
-    projectStatus: (projectHash2) => path.join(globalRoot, "projects", projectHash2, "status.json")
+    projectStatus: (statusProjectSlug) => {
+      if (!/^[a-z0-9](?:[a-z0-9-]{0,39})-[a-f0-9]{6}$/.test(statusProjectSlug)) {
+        throw new Error(`Invalid project slug: ${statusProjectSlug}`);
+      }
+      return path.join(globalRoot, "projects", statusProjectSlug, "status.json");
+    }
   };
 }
 
@@ -228,6 +183,8 @@ var ToolCapabilities = {
   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. */
@@ -298,6 +255,294 @@ function clampSubagentCapabilities(requested, ceiling = WIDE_SUBAGENT_CAPABILITI
   };
 }
 
+// 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"]
+  },
+  {
+    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"
+    ],
+    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"]
+  }
+];
+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 isKnownRuntimeCapability(id) {
+  return CAPABILITY_BY_ID.has(id);
+}
+function inferRuntimeCapabilities(toolNames) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const rawName of toolNames) {
+    const id = runtimeCapabilityForTool(rawName);
+    if (id) ids.add(id);
+  }
+  return [...ids];
+}
+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 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 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];
+}
+function isDeprecatedRuntimeToolAlias(name) {
+  return TOOL_ALIASES.has(name) || name.startsWith("mcp__");
+}
+
 // src/coordination/agents/project-agent-config-validation.ts
 import * as path2 from "node:path";
 var PROJECT_AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
@@ -437,73 +682,28 @@ function validateProjectAgentAvailability(value) {
   }
 }
 
-// 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
-  },
-  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
-  },
-  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
-  }
-};
+// src/coordination/agents/project-agent-consolidation.ts
+import {
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  rmSync as rmSync2
+} from "node:fs";
+import * as path4 from "node:path";
 
-// src/coordination/agents/project-agent-learning-policy.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+// 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(/^# Learned wisdom for .+$/im, "").replace(/<!--[\s\S]*?-->/g, "").trim()
+  ).filter(Boolean);
+}
 
 // src/coordination/agents/project-agent-paths.ts
 import { randomUUID } from "node:crypto";
@@ -547,54 +747,199 @@ function projectAgentProfilePath(role, projectRoot) {
   return path3.join(roleDir(role, projectRoot), "profile.json");
 }
 
-// src/coordination/agents/project-agent-learning-policy.ts
-var DEFAULT_LEARNING_POLICY = {
-  enabled: true,
-  lifetimeCaptureCount: 0
-};
-function loadProjectAgentLearningPolicy(role, projectRoot) {
+// src/coordination/agents/project-agent-consolidation.ts
+function learnedPath(role, projectRoot) {
+  return path4.join(roleDir(role, projectRoot), "learned.md");
+}
+function loadProjectAgentLearnedText(role, projectRoot) {
   try {
-    const parsed = JSON.parse(
-      readFileSync2(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 } : {}
-    };
+    return readFileSync2(learnedPath(role, projectRoot), "utf8").trim();
   } catch {
-    return { ...DEFAULT_LEARNING_POLICY };
+    return "";
   }
 }
-function updateProjectAgentLearningPolicy(role, patch, projectRoot) {
-  const current = loadProjectAgentLearningPolicy(role, projectRoot);
-  const updated = {
-    ...current,
-    ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {}
-  };
-  writeTextAtomically(
-    learningPolicyPath(role, projectRoot),
-    `${JSON.stringify(updated, null, 2)}
-`
-  );
-  return updated;
-}
-
-// 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 listProjectAgentLearnedTextEntries(role, projectRoot) {
+  return splitLearnedEntries(loadProjectAgentLearnedText(role, projectRoot));
 }
-function splitLearnedEntries(body) {
-  return body.split(/\n---\n+/).map((entry) => entry.trim()).map(
-    (entry) => entry.replace(/^# Learned wisdom for .+$/im, "").replace(/<!--[\s\S]*?-->/g, "").trim()
-  ).filter(Boolean);
+function consolidationPath(role, projectRoot) {
+  return path4.join(roleDir(role, projectRoot), "consolidated.md");
+}
+function consolidationMetaPath(role, projectRoot) {
+  return path4.join(roleDir(role, projectRoot), "consolidation.json");
+}
+function loadProjectAgentConsolidated(role, projectRoot) {
+  try {
+    return readFileSync2(consolidationPath(role, projectRoot), "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+function loadConsolidationMetadata(role, projectRoot) {
+  try {
+    const raw = readFileSync2(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 isConsolidated(role, projectRoot) {
+  return existsSync(consolidationMetaPath(role, projectRoot));
+}
+function saveProjectAgentConsolidated(role, content, projectRoot, metadata) {
+  if (!content.trim()) {
+    return consolidationPath(assertProjectAgentRole(role), projectRoot);
+  }
+  const normalizedRole = assertProjectAgentRole(role);
+  const dir = roleDir(normalizedRole, projectRoot);
+  mkdirSync2(dir, { recursive: true });
+  const fp = consolidationPath(normalizedRole, projectRoot);
+  writeTextAtomically(fp, content);
+  const rawEntries = listProjectAgentLearnedTextEntries(normalizedRole, projectRoot);
+  const rawBytes = Buffer.byteLength(loadProjectAgentLearnedText(normalizedRole, projectRoot), "utf8");
+  const meta = {
+    consolidatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceEntryCount: rawEntries.length,
+    sourceBytes: rawBytes,
+    consolidatedBytes: Buffer.byteLength(content, "utf8"),
+    trigger: metadata?.trigger ?? "manual",
+    ...metadata?.model ? { model: metadata.model } : {}
+  };
+  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 {
+    }
+  }
+}
+function buildConsolidationInstruction(role, projectRoot) {
+  const normalizedRole = assertProjectAgentRole(role);
+  const rawEntries = listProjectAgentLearnedTextEntries(normalizedRole, projectRoot);
+  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.`,
+    "",
+    "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.",
+    "",
+    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}`
+    );
+  }
+  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)
+  };
 }
 
+// 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
+  },
+  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
+  },
+  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
+  }
+};
+
 // src/coordination/agents/project-agent-learning-normalize.ts
 var LEARNED_SOFT_LIMIT = 8192;
 var LEARNED_HARD_LIMIT = 16384;
@@ -712,6 +1057,41 @@ function normalizeForComparison(text) {
   return text.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim().split(/\s+/).sort().join(" ");
 }
 
+// src/coordination/agents/project-agent-learning-policy.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+var DEFAULT_LEARNING_POLICY = {
+  enabled: true,
+  lifetimeCaptureCount: 0
+};
+function loadProjectAgentLearningPolicy(role, projectRoot) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync3(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 } : {}
+    };
+  } catch {
+    return { ...DEFAULT_LEARNING_POLICY };
+  }
+}
+function updateProjectAgentLearningPolicy(role, patch, projectRoot) {
+  const current = loadProjectAgentLearningPolicy(role, projectRoot);
+  const updated = {
+    ...current,
+    ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {}
+  };
+  writeTextAtomically(
+    learningPolicyPath(role, projectRoot),
+    `${JSON.stringify(updated, null, 2)}
+`
+  );
+  return updated;
+}
+
 // src/coordination/agents/project-agent-learning-structured.ts
 function parseLearnedEntryStamp(entry) {
   const structuredMatch = entry.match(
@@ -839,311 +1219,86 @@ function mergeStructuredEntries(existing, fresh) {
   };
   const merged = existing.filter((entry) => tokenOverlap(entry.key, freshEntry.key) < 0.55);
   merged.push(freshEntry);
-  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");
-  }
-  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 stamp = `<!-- learned-stamp: category=${entry.category}; capturedAt=${entry.capturedAt} -->`;
-      sections.push(stamp);
-      sections.push(`- **${entry.what}**`);
-      sections.push(`  - *Why:* ${entry.why}`);
-      if (entry.how) {
-        for (const line of entry.how.split("\n"))
-          sections.push(`  - *How:* ${line.replace(/^- /, "")}`);
-      }
-      sections.push("");
-    }
-  }
-  const footer = ["---", `*Last capture: ${capturedAt} \xB7 ${entries.length} entries*`, ""];
-  return [...headerLines, ...sections, ...footer].join("\n");
-}
-
-// 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";
-function learnedPath(role, projectRoot) {
-  return path4.join(roleDir(role, projectRoot), "learned.md");
-}
-function loadProjectAgentLearnedText(role, projectRoot) {
-  try {
-    return readFileSync3(learnedPath(role, projectRoot), "utf8").trim();
-  } catch {
-    return "";
-  }
-}
-function listProjectAgentLearnedTextEntries(role, projectRoot) {
-  return splitLearnedEntries(loadProjectAgentLearnedText(role, projectRoot));
-}
-function consolidationPath(role, projectRoot) {
-  return path4.join(roleDir(role, projectRoot), "consolidated.md");
-}
-function consolidationMetaPath(role, projectRoot) {
-  return path4.join(roleDir(role, projectRoot), "consolidation.json");
-}
-function loadProjectAgentConsolidated(role, projectRoot) {
-  try {
-    return readFileSync3(consolidationPath(role, projectRoot), "utf8").trim();
-  } catch {
-    return "";
-  }
-}
-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 isConsolidated(role, projectRoot) {
-  return existsSync(consolidationMetaPath(role, projectRoot));
-}
-function saveProjectAgentConsolidated(role, content, projectRoot, metadata) {
-  if (!content.trim()) {
-    return consolidationPath(assertProjectAgentRole(role), projectRoot);
-  }
-  const normalizedRole = assertProjectAgentRole(role);
-  const dir = roleDir(normalizedRole, projectRoot);
-  mkdirSync2(dir, { recursive: true });
-  const fp = consolidationPath(normalizedRole, projectRoot);
-  writeTextAtomically(fp, content);
-  const rawEntries = listProjectAgentLearnedTextEntries(normalizedRole, projectRoot);
-  const rawBytes = Buffer.byteLength(loadProjectAgentLearnedText(normalizedRole, projectRoot), "utf8");
-  const meta = {
-    consolidatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    sourceEntryCount: rawEntries.length,
-    sourceBytes: rawBytes,
-    consolidatedBytes: Buffer.byteLength(content, "utf8"),
-    trigger: metadata?.trigger ?? "manual",
-    ...metadata?.model ? { model: metadata.model } : {}
-  };
-  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 {
-    }
-  }
-}
-function buildConsolidationInstruction(role, projectRoot) {
-  const normalizedRole = assertProjectAgentRole(role);
-  const rawEntries = listProjectAgentLearnedTextEntries(normalizedRole, projectRoot);
-  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.`,
-    "",
-    "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.",
-    "",
-    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}`
-    );
-  }
-  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)
-  };
-}
-
-// src/coordination/agents/project-agent-profile.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync4 } from "node:fs";
-import * as path5 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 parsed = JSON.parse(
-      readFileSync4(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 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.");
-  }
-  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}`,
-    "",
-    `You are the project-specific "${name}" agent (role: ${role}).`,
-    "",
-    "## Purpose",
-    "",
-    purpose,
-    "",
-    "## Primary task types",
-    "",
-    ...taskTypes.map((item) => `- ${item}`),
+  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}\``,
     "",
-    "Learn durable project conventions from completed work, keep conclusions evidence-based, and stay within this assigned purpose.",
+    "> 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.",
     ""
-  ].join("\n");
-  mkdirSync3(dir, { recursive: true });
-  writeTextAtomically(path5.join(dir, "identity.md"), identity);
-  writeTextAtomically(
-    projectAgentProfilePath(role, projectRoot),
-    `${JSON.stringify(profile, null, 2)}
-`
-  );
-  return profile;
+  ];
+  if (entries.length === 0) {
+    return headerLines.join("\n") + [
+      "_No learned entries yet._",
+      "",
+      "---",
+      `*Last capture: ${capturedAt} \xB7 0 entries*`,
+      ""
+    ].join("\n");
+  }
+  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 stamp = `<!-- learned-stamp: category=${entry.category}; capturedAt=${entry.capturedAt} -->`;
+      sections.push(stamp);
+      sections.push(`- **${entry.what}**`);
+      sections.push(`  - *Why:* ${entry.why}`);
+      if (entry.how) {
+        for (const line of entry.how.split("\n"))
+          sections.push(`  - *How:* ${line.replace(/^- /, "")}`);
+      }
+      sections.push("");
+    }
+  }
+  const footer = ["---", `*Last capture: ${capturedAt} \xB7 ${entries.length} entries*`, ""];
+  return [...headerLines, ...sections, ...footer].join("\n");
 }
 
 // src/coordination/agents/project-agent-files.ts
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync5,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readdirSync,
+  readFileSync as readFileSync4,
   rmSync as rmSync3
 } from "node:fs";
-import * as path6 from "node:path";
+import * as path5 from "node:path";
 function updateProjectAgentLearned(role, content, projectRoot, mode = "append") {
   const dir = roleDir(role, projectRoot);
-  mkdirSync4(dir, { recursive: true });
-  const filePath = path6.join(dir, "learned.md");
+  mkdirSync3(dir, { recursive: true });
+  const filePath = path5.join(dir, "learned.md");
   const existing = (() => {
     try {
-      return readFileSync5(filePath, "utf8");
+      return readFileSync4(filePath, "utf8");
     } catch {
       return "";
     }
@@ -1158,24 +1313,24 @@ ${content.trimStart()}` : content;
 }
 function updateProjectAgentIdentity(role, content, projectRoot) {
   const dir = roleDir(role, projectRoot);
-  mkdirSync4(dir, { recursive: true });
-  const filePath = path6.join(dir, "identity.md");
+  mkdirSync3(dir, { recursive: true });
+  const filePath = path5.join(dir, "identity.md");
   writeTextAtomically(filePath, content);
   return filePath;
 }
 function updateProjectAgentConfig(role, config, projectRoot) {
   const validated = validateProjectAgentConfig(config);
   const dir = roleDir(role, projectRoot);
-  mkdirSync4(dir, { recursive: true });
-  const filePath = path6.join(dir, "config.json");
+  mkdirSync3(dir, { recursive: true });
+  const filePath = path5.join(dir, "config.json");
   writeTextAtomically(filePath, `${JSON.stringify(validated, null, 2)}
 `);
   return filePath;
 }
 function updateProjectAgentKnowledge(role, manifest, projectRoot) {
   const dir = roleDir(role, projectRoot);
-  mkdirSync4(dir, { recursive: true });
-  const filePath = path6.join(dir, "knowledge.json");
+  mkdirSync3(dir, { recursive: true });
+  const filePath = path5.join(dir, "knowledge.json");
   writeTextAtomically(filePath, `${JSON.stringify(manifest, null, 2)}
 `);
   return filePath;
@@ -1184,14 +1339,14 @@ function resetProjectAgentIdentity(role, projectRoot) {
   const removed = [];
   if (!role || role === "*") {
     const dir2 = agentsDir(projectRoot);
-    if (existsSync3(dir2)) {
+    if (existsSync2(dir2)) {
       rmSync3(dir2, { recursive: true, force: true });
       removed.push(dir2);
     }
     return removed;
   }
   const dir = roleDir(role, projectRoot);
-  if (existsSync3(dir)) {
+  if (existsSync2(dir)) {
     rmSync3(dir, { recursive: true, force: true });
     removed.push(dir);
   }
@@ -1199,20 +1354,20 @@ function resetProjectAgentIdentity(role, projectRoot) {
 }
 function refreshProjectAgentIdentity(role, projectRoot) {
   const dir = roleDir(role, projectRoot);
-  mkdirSync4(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   for (const file of ["learned.md", "identity.md", "consolidated.md", "consolidation.json"]) {
-    const fp = path6.join(dir, file);
+    const fp = path5.join(dir, file);
     try {
       rmSync3(fp, { force: true });
     } catch {
     }
   }
   writeTextAtomically(
-    path6.join(dir, "learned.md"),
+    path5.join(dir, "learned.md"),
     renderLearnedInstructions(role, [], (/* @__PURE__ */ new Date()).toISOString())
   );
   writeTextAtomically(
-    path6.join(dir, "identity.md"),
+    path5.join(dir, "identity.md"),
     `# Project identity for ${role}
 
 <!-- Describe how this agent should behave in the context of this project. -->
@@ -1223,9 +1378,9 @@ function refreshProjectAgentIdentity(role, projectRoot) {
 function listProjectAgentRoles(projectRoot) {
   const dir = agentsDir(projectRoot);
   try {
-    return readdirSync2(dir).filter((name) => {
+    return readdirSync(dir).filter((name) => {
       if (!isProjectAgentRoleName(name)) return false;
-      const sub = path6.join(dir, name);
+      const sub = path5.join(dir, name);
       try {
         return [
           "learned.md",
@@ -1236,7 +1391,7 @@ function listProjectAgentRoles(projectRoot) {
           "profile.json",
           "consolidated.md",
           "consolidation.json"
-        ].some((file) => existsSync3(path6.join(sub, file)));
+        ].some((file) => existsSync2(path5.join(sub, file)));
       } catch {
         return false;
       }
@@ -1246,6 +1401,96 @@ function listProjectAgentRoles(projectRoot) {
   }
 }
 
+// src/coordination/agents/project-agent-profile.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "node:fs";
+import * as path6 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 parsed = JSON.parse(
+      readFileSync5(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 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.");
+  }
+  const dir = roleDir(role, projectRoot);
+  if (existsSync3(dir) && readdirSync2(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}`,
+    "",
+    `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");
+  mkdirSync4(dir, { recursive: true });
+  writeTextAtomically(path6.join(dir, "identity.md"), identity);
+  writeTextAtomically(
+    projectAgentProfilePath(role, projectRoot),
+    `${JSON.stringify(profile, null, 2)}
+`
+  );
+  return profile;
+}
+
 // src/coordination/agents/project-agent-identity.ts
 function createProjectAgentRoster(baseRoster, projectRoot) {
   const target = { ...baseRoster };
@@ -1341,6 +1586,7 @@ function applyProjectAgentConfig(base, projectConfig, options = {}) {
   const result = { ...base };
   if (projectConfig.tools !== void 0) {
     result.tools = options.protectSystemRole ? base.tools === void 0 ? void 0 : [.../* @__PURE__ */ new Set([...base.tools, ...projectConfig.tools])] : [...projectConfig.tools];
+    result.capabilities = inferRuntimeCapabilities(result.tools ?? []);
   }
   if (projectConfig.skillNames !== void 0) result.skillNames = [...projectConfig.skillNames];
   if (projectConfig.provider !== void 0) result.provider = projectConfig.provider;
@@ -1941,6 +2187,64 @@ function isDirectory(candidate) {
   }
 }
 
+// src/coordination/agents/types.ts
+var HOUR = 60 * 60 * 1e3;
+var LIGHT_BUDGET = {
+  timeoutMs: 3 * HOUR,
+  maxIterations: 3e3,
+  maxToolCalls: 8e3
+};
+var MEDIUM_BUDGET = {
+  timeoutMs: 5 * HOUR,
+  maxIterations: 5e3,
+  maxToolCalls: 14e3
+};
+var HEAVY_BUDGET = {
+  timeoutMs: 10 * HOUR,
+  maxIterations: 8e3,
+  maxToolCalls: 2e4
+};
+var TOOLS = {
+  /** Pure read/inspect — safe for analysis and review agents. */
+  read: ["read", "grep", "glob", "search", "tree", "mailbox"],
+  /** Read + structured inspection (logs, diffs, json, dependency audit). */
+  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"],
+  /** Read + edit (no shell). For agents that write code/docs but don't run it. */
+  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"],
+  /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
+  build: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    "write",
+    "edit",
+    "replace",
+    "patch",
+    "bash",
+    "exec",
+    "lint",
+    "format",
+    "typecheck",
+    "test",
+    "mailbox"
+  ],
+  /** Version control. */
+  vcs: ["read", "grep", "glob", "git", "diff"],
+  /** Dependency management + CVE audit. */
+  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
+  /** Documentation authoring. */
+  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"],
+  /** Web research. */
+  research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
+};
+var SPECIALIST_TOOLS = {
+  browser: toolsForRuntimeCapabilities(["browser.interact"]),
+  memory: toolsForRuntimeCapabilities(["memory.manage"]),
+  mcp: toolsForRuntimeCapabilities(["mcp.dynamic"])
+};
+
 // src/coordination/agents/phase1-discovery.ts
 var DISCOVERY_AGENTS = [
   {
@@ -1976,7 +2280,7 @@ var DISCOVERY_AGENTS = [
       id: "search",
       name: "Search",
       role: "search",
-      tools: [...TOOLS.read],
+      tools: [...TOOLS.read, "codebase-search"],
       prompt: agentPrompt("search")
     },
     budget: MEDIUM_BUDGET,
@@ -2438,14 +2742,7 @@ var WAVE1_AGENTS = [
     capability: {
       phase: "domain",
       summary: "Android platform specialist: Kotlin, Jetpack Compose, Android SDK, lifecycle and Play Store delivery.",
-      keywords: [
-        ...ANDROID_META.signals,
-        "android",
-        "kotlin",
-        "compose",
-        "gradle",
-        "playstore"
-      ]
+      keywords: [...ANDROID_META.signals, "android", "kotlin", "compose", "gradle", "playstore"]
     }
   },
   {
@@ -2460,14 +2757,7 @@ var WAVE1_AGENTS = [
     capability: {
       phase: "domain",
       summary: "Desktop application specialist: Electron or Tauri, native packaging, IPC and OS integration.",
-      keywords: [
-        ...DESKTOP_META.signals,
-        "desktop",
-        "electron",
-        "tauri",
-        "ipc",
-        "tray"
-      ]
+      keywords: [...DESKTOP_META.signals, "desktop", "electron", "tauri", "ipc", "tray"]
     }
   },
   {
@@ -2543,7 +2833,7 @@ var WAVE1_AGENTS = [
       id: "platform-engineer",
       name: "Platform Engineer",
       role: "platform-engineer",
-      tools: [...TOOLS.build, "install", "git", "node-modern"],
+      tools: [...TOOLS.build, "install", "git"],
       prompt: agentPrompt("platform-engineer")
     },
     budget: MEDIUM_BUDGET,
@@ -2787,8 +3077,7 @@ var WAVE2_AGENTS = [
       id: "resilience-engineer",
       name: "Resilience Engineer",
       role: "resilience-engineer",
-      tools: [...TOOLS.build, "logs", "observability"],
-      // uniqueness guaranteed by 'observability' vs chaos-engineer's 'test'
+      tools: [...TOOLS.build, "logs"],
       prompt: agentPrompt("resilience-engineer")
     },
     budget: MEDIUM_BUDGET,
@@ -2811,8 +3100,7 @@ var WAVE2_AGENTS = [
       id: "chaos-engineer",
       name: "Chaos Engineer",
       role: "chaos-engineer",
-      tools: [...TOOLS.build, "logs", "observability"],
-      // uniqueness guaranteed by 'observability' vs chaos-engineer's 'test'
+      tools: [...TOOLS.build, "logs"],
       prompt: agentPrompt("chaos-engineer")
     },
     budget: MEDIUM_BUDGET,
@@ -2953,21 +3241,7 @@ var VERIFY_AGENTS = [
       id: "e2e",
       name: "E2E",
       role: "e2e",
-      tools: [
-        ...TOOLS.build,
-        "fetch",
-        "playwright_navigate",
-        "playwright_screenshot",
-        "playwright_click",
-        "playwright_type",
-        "playwright_evaluate",
-        "playwright_select_option",
-        "playwright_hover",
-        "playwright_fill_form",
-        "playwright_wait_for",
-        "playwright_press_key",
-        "playwright_drag"
-      ],
+      tools: [...TOOLS.build, "fetch", ...SPECIALIST_TOOLS.browser],
       prompt: agentPrompt("e2e")
     },
     budget: HEAVY_BUDGET,
@@ -3002,21 +3276,7 @@ var VERIFY_AGENTS = [
       id: "browser",
       name: "Browser",
       role: "browser",
-      tools: [
-        ...TOOLS.read,
-        "fetch",
-        "playwright_navigate",
-        "playwright_screenshot",
-        "playwright_click",
-        "playwright_type",
-        "playwright_evaluate",
-        "playwright_select_option",
-        "playwright_hover",
-        "playwright_fill_form",
-        "playwright_wait_for",
-        "playwright_press_key",
-        "playwright_drag"
-      ],
+      tools: [...TOOLS.read, "fetch", ...SPECIALIST_TOOLS.browser],
       prompt: agentPrompt("browser")
     },
     budget: MEDIUM_BUDGET,
@@ -3717,27 +3977,7 @@ var DELIVERY_AGENTS = [
       id: "devops",
       name: "DevOps",
       role: "devops",
-      tools: [
-        ...TOOLS.build,
-        "mcp__ssh__ssh_list_servers",
-        "mcp__ssh__ssh_connection_status",
-        "mcp__ssh__ssh_execute",
-        "mcp__ssh__ssh_execute_sudo",
-        "mcp__ssh__ssh_upload",
-        "mcp__ssh__ssh_download",
-        "mcp__ssh__ssh_sync",
-        "mcp__ssh__ssh_deploy",
-        "mcp__ssh__ssh_health_check",
-        "mcp__ssh__ssh_service_status",
-        "mcp__ssh__ssh_process_manager",
-        "mcp__ssh__ssh_tunnel",
-        "mcp__ssh__ssh_backup_create",
-        "mcp__ssh__ssh_backup_list",
-        "mcp__ssh__ssh_backup_restore",
-        "mcp__ssh__ssh_db_list",
-        "mcp__ssh__ssh_db_query",
-        "mcp__ssh__ssh_profile"
-      ],
+      tools: [...TOOLS.build, ...SPECIALIST_TOOLS.mcp],
       prompt: agentPrompt("devops")
     },
     budget: MEDIUM_BUDGET,
@@ -3938,7 +4178,7 @@ var WAVE3_AGENTS = [
       id: "messaging",
       name: "Messaging",
       role: "messaging",
-      tools: [...TOOLS.build, "logs", "observability"],
+      tools: [...TOOLS.build, "logs"],
       prompt: agentPrompt("messaging")
     },
     budget: HEAVY_BUDGET,
@@ -4379,7 +4619,7 @@ var WAVE4_AGENTS = [
       id: "memory-curator",
       name: "Memory Curator",
       role: "memory-curator",
-      tools: [...TOOLS.read, "memory"],
+      tools: [...TOOLS.read, ...SPECIALIST_TOOLS.memory],
       prompt: agentPrompt("memory-curator")
     },
     budget: LIGHT_BUDGET,
@@ -4401,7 +4641,7 @@ var WAVE4_AGENTS = [
       id: "fleet-coordinator",
       name: "Fleet Coordinator",
       role: "fleet-coordinator",
-      tools: [...TOOLS.read, "plan", "multi-agent"],
+      tools: [...TOOLS.read, "plan"],
       prompt: agentPrompt("fleet-coordinator")
     },
     budget: MEDIUM_BUDGET,
@@ -4527,8 +4767,20 @@ var ROLE_SKILL_SETS = {
   cost: skillSet("audit-log", "tech-stack", "observability", "research-web"),
   "tech-stack": skillSet("tech-stack", "research-web", "security-scanner", "node-modern"),
   // ── Wave 1: Platform and systems engineering ──────────────────────────
-  android: skillSet("react-modern", "typescript-strict", "testing", "security-scanner", "tech-stack"),
-  desktop: skillSet("node-modern", "typescript-strict", "testing", "security-scanner", "tech-stack"),
+  android: skillSet(
+    "react-modern",
+    "typescript-strict",
+    "testing",
+    "security-scanner",
+    "tech-stack"
+  ),
+  desktop: skillSet(
+    "node-modern",
+    "typescript-strict",
+    "testing",
+    "security-scanner",
+    "tech-stack"
+  ),
   realtime: skillSet(
     "api-design",
     "observability",
@@ -4632,26 +4884,9 @@ var ROLE_SKILL_SETS = {
     "security-scanner",
     "tech-stack"
   ),
-  "benchmark-engineer": skillSet(
-    "observability",
-    "testing",
-    "output-standards",
-    "tech-stack"
-  ),
-  "memory-curator": skillSet(
-    "mnemosyne",
-    "audit-log",
-    "testing",
-    "output-standards",
-    "tech-stack"
-  ),
-  "fleet-coordinator": skillSet(
-    "multi-agent",
-    "sdd",
-    "output-standards",
-    "testing",
-    "tech-stack"
-  ),
+  "benchmark-engineer": skillSet("observability", "testing", "output-standards", "tech-stack"),
+  "memory-curator": skillSet("mnemosyne", "audit-log", "testing", "output-standards", "tech-stack"),
+  "fleet-coordinator": skillSet("multi-agent", "sdd", "output-standards", "testing", "tech-stack"),
   // ── Wave 2: Security, resilience, governance and agent platform ────────
   "threat-modeler": skillSet(
     "security-scanner",
@@ -4703,6 +4938,7 @@ var SHADOW_AGENT_SKILLS = skillSet(
   "observability",
   "security-scanner"
 );
+var MAX_EAGER_ROSTER_SKILLS = 3;
 function assignSkillsToAgents(definitions) {
   return definitions.map((definition) => {
     const role = definition.config.role;
@@ -4716,7 +4952,8 @@ function assignSkillsToAgents(definitions) {
       ...definition,
       config: {
         ...definition.config,
-        skillNames: [...skills]
+        capabilities: inferRuntimeCapabilities(definition.config.tools ?? []),
+        skillNames: skills.slice(0, MAX_EAGER_ROSTER_SKILLS)
       }
     };
   });
@@ -4789,7 +5026,9 @@ export {
   PLANNING_AGENTS,
   REVIEW_AGENTS,
   ROLE_SKILL_SETS,
+  RUNTIME_CAPABILITY_MANIFEST,
   SHADOW_AGENT_SKILLS,
+  SPECIALIST_TOOLS,
   TOOLS,
   VERIFY_AGENTS,
   WAVE1_AGENTS,
@@ -4822,7 +5061,10 @@ export {
   getAgentDefinition,
   getProjectAgentLearnStats,
   hintLearnedNeedsSummarization,
+  inferRuntimeCapabilities,
   isConsolidated,
+  isDeprecatedRuntimeToolAlias,
+  isKnownRuntimeCapability,
   listProjectAgentLearnedEntries,
   listProjectAgentRoles,
   loadConsolidationMetadata,
@@ -4834,14 +5076,20 @@ export {
   loadProjectAgentProfile,
   loadRoleKnowledgeManifest,
   mergeStructuredEntries,
+  missingRequiredRuntimeTools,
+  missingRuntimeCapabilities,
   normalizeLearnedEntry,
+  normalizeRuntimeToolName,
   parseLearnedEntryStamp,
   parseStructuredLearnedEntries,
   refreshProjectAgentIdentity,
   renderLearnedInstructions,
   resetProjectAgentIdentity,
+  runtimeCapabilityForTool,
+  runtimeToolReferencesFromText,
   saveProjectAgentConsolidated,
   slugifyProjectAgentRole,
+  toolsForRuntimeCapabilities,
   updateProjectAgentConfig,
   updateProjectAgentIdentity,
   updateProjectAgentKnowledge,