opencode-swarm 7.77.3 → 7.77.5

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.77.3",
+    version: "7.77.5",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -504,6 +504,14 @@ async function bunWrite(filePath, data) {
     } catch {}
     throw lastError;
   }
+  try {
+    const dirFd = await fsPromises.open(dir, "r");
+    try {
+      await dirFd.sync();
+    } finally {
+      await dirFd.close();
+    }
+  } catch {}
   const stats = await fsPromises.stat(filePath);
   return stats.size;
 }
@@ -828,14 +836,23 @@ function validateSwarmPath(directory, filename) {
   return resolved;
 }
 async function readSwarmFileAsync(directory, filename) {
-  try {
-    const resolvedPath = _internals.validateSwarmPath(directory, filename);
-    const file = bunFile(resolvedPath);
-    const content = await file.text();
-    return content;
-  } catch {
-    return null;
+  const maxAttempts = 5;
+  const retryDelayMs = 10;
+  for (let attempt = 0;attempt < maxAttempts; attempt++) {
+    try {
+      const resolvedPath = _internals.validateSwarmPath(directory, filename);
+      const file = bunFile(resolvedPath);
+      const content = await file.text();
+      return content;
+    } catch (err) {
+      const isNotFound = err?.code === "ENOENT";
+      if (!isNotFound || attempt === maxAttempts - 1) {
+        return null;
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, retryDelayMs));
+    }
   }
+  return null;
 }
 var _internals;
 var init_utils2 = __esm(() => {
@@ -17544,7 +17561,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect"]
     },
     write_final_council_evidence: {
-      description: "write final council evidence for project completion",
+      description: "Persist project-scoped final council evidence to .swarm/evidence/final-council.json. PREREQUISITE: dispatch critic, reviewer, sme, test_engineer, and explorer as project-scoped Agent tasks and collect their CouncilMemberVerdict JSON \u2014 this tool synthesizes only. Rejects on insufficient quorum or CONCERNS with unresolved requiredFixes; normalizes verdicts to approved/concerns/rejected. Architect-only.",
       agents: ["architect"]
     },
     skill_generate: {
@@ -20381,7 +20398,7 @@ GFS4: `);
     }
     function ReadStream$open() {
       var that = this;
-      open(that.path, that.flags, that.mode, function(err, fd) {
+      open2(that.path, that.flags, that.mode, function(err, fd) {
         if (err) {
           if (that.autoClose)
             that.destroy();
@@ -20401,7 +20418,7 @@ GFS4: `);
     }
     function WriteStream$open() {
       var that = this;
-      open(that.path, that.flags, that.mode, function(err, fd) {
+      open2(that.path, that.flags, that.mode, function(err, fd) {
         if (err) {
           that.destroy();
           that.emit("error", err);
@@ -20418,8 +20435,8 @@ GFS4: `);
       return new fs6.WriteStream(path8, options);
     }
     var fs$open = fs6.open;
-    fs6.open = open;
-    function open(path8, flags, mode, cb) {
+    fs6.open = open2;
+    function open2(path8, flags, mode, cb) {
       if (typeof mode === "function")
         cb = mode, mode = null;
       return go$open(path8, flags, mode, cb);
@@ -21571,6 +21588,9 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 async function loadEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
   const relativePath = path9.join("evidence", sanitizedTaskId, "evidence.json");
+  if (relativePath.length > 4096) {
+    return { status: "not_found" };
+  }
   const evidencePath = validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -23065,6 +23085,291 @@ var init_stored_input_args = __esm(() => {
   storedInputArgs = new Map;
 });
 
+// src/commands/command-dispatch.ts
+function normalizeSwarmCommandInput(command, argumentText) {
+  if (command !== "swarm" && !command.startsWith("swarm-")) {
+    return { isSwarmCommand: false, tokens: [] };
+  }
+  if (command === "swarm") {
+    return {
+      isSwarmCommand: true,
+      tokens: argumentText.trim().split(/\s+/).filter(Boolean)
+    };
+  }
+  const subcommand = command.slice("swarm-".length);
+  const extraArgs = argumentText.trim().split(/\s+/).filter(Boolean);
+  return {
+    isSwarmCommand: true,
+    tokens: [subcommand, ...extraArgs].filter(Boolean)
+  };
+}
+function canonicalCommandKey(resolved) {
+  return resolved.entry.aliasOf ?? resolved.key;
+}
+function formatCommandNotFound(tokens) {
+  const attemptedCommand = tokens[0] || "";
+  const MAX_DISPLAY = 100;
+  const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
+  const similar = _internals11.findSimilarCommands(attemptedCommand);
+  const header = `Command \`/swarm ${displayCommand}\` not found.`;
+  const suggestions = similar.length > 0 ? `Did you mean:
+${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
+`)}` : "";
+  const footer = "Run `/swarm help` for all commands.";
+  return [header, suggestions, footer].filter(Boolean).join(`
+
+`);
+}
+async function executeSwarmCommand(args) {
+  const {
+    directory,
+    agents,
+    sessionID,
+    tokens,
+    packageRoot,
+    buildHelpText,
+    policy
+  } = args;
+  let text;
+  const resolved = resolveCommand(tokens);
+  if (!resolved) {
+    text = tokens.length === 0 && buildHelpText ? buildHelpText() : formatCommandNotFound(tokens);
+  } else {
+    const policyResult = policy?.(resolved) ?? { allowed: true };
+    if (!policyResult.allowed) {
+      text = policyResult.message;
+    } else {
+      try {
+        text = await resolved.entry.handler({
+          directory,
+          args: resolved.remainingArgs,
+          sessionID,
+          agents,
+          packageRoot,
+          source: "chat"
+        });
+      } catch (_err) {
+        const cmdName = tokens[0] || "unknown";
+        const errMsg = _err instanceof Error ? _err.message : String(_err);
+        text = `Error executing /swarm ${cmdName}: ${errMsg}`;
+      }
+      if (resolved.warning) {
+        text = `${resolved.warning}
+
+${text}`;
+      }
+    }
+  }
+  return {
+    text,
+    resolved: resolved ?? undefined,
+    canonicalKey: resolved ? canonicalCommandKey(resolved) : undefined
+  };
+}
+var init_command_dispatch = __esm(() => {
+  init_registry();
+});
+
+// src/commands/tool-policy.ts
+function lazySet(getValues) {
+  let cached2 = null;
+  const ensure = () => {
+    if (cached2 === null)
+      cached2 = new Set(getValues());
+    return cached2;
+  };
+  return new Proxy({}, {
+    get(_target, prop) {
+      const set2 = ensure();
+      const value = Reflect.get(set2, prop);
+      return typeof value === "function" ? value.bind(set2) : value;
+    }
+  });
+}
+function lazyArray(getValues) {
+  let cached2 = null;
+  const ensure = () => {
+    if (cached2 === null)
+      cached2 = getValues();
+    return cached2;
+  };
+  return new Proxy([], {
+    get(_target, prop) {
+      const arr = ensure();
+      const value = Reflect.get(arr, prop);
+      return typeof value === "function" ? value.bind(arr) : value;
+    }
+  });
+}
+function classifySwarmCommandToolUse(resolved) {
+  const canonicalKey = canonicalCommandKey(resolved);
+  const args = resolved.remainingArgs;
+  if (!SWARM_COMMAND_TOOL_ALLOWLIST.has(canonicalKey)) {
+    if (HUMAN_ONLY_SWARM_COMMANDS.has(canonicalKey)) {
+      return {
+        allowed: false,
+        message: `/swarm ${canonicalKey} is a human-only command. ` + `Present the situation to the user and ask them to run \`/swarm ${canonicalKey}\` themselves ` + `(or \`bunx opencode-swarm run ${canonicalKey}\` from a terminal). ` + `You MUST NOT run it yourself via Bash, swarm_command, or any other tool \u2014 ` + `the runtime guardrail will block such attempts.`
+      };
+    }
+    return {
+      allowed: false,
+      message: `/swarm ${canonicalKey} is not available through the chat tool yet.
+
+` + `Use the canonical CLI path for now: \`bunx opencode-swarm run ${canonicalKey}\`.
+` + `Commands with state changes, auto-heal behavior, or subprocesses need confirmation gates before chat-tool support.`
+    };
+  }
+  if (canonicalKey === "config doctor" && args.some((arg) => arg === "--fix" || arg === "-f")) {
+    return {
+      allowed: false,
+      message: "/swarm config doctor --fix is not available through swarm_command. Run the CLI command directly when you intend to modify config files."
+    };
+  }
+  if (NO_ARGS.has(canonicalKey) && args.length > 0) {
+    return {
+      allowed: false,
+      message: `/swarm ${canonicalKey} does not accept arguments through swarm_command.`
+    };
+  }
+  if (canonicalKey === "knowledge") {
+    if (args.length === 0)
+      return { allowed: true };
+    if (args.length === 1 && (args[0] === "list" || args[0] === "unactionable"))
+      return { allowed: true };
+    return {
+      allowed: false,
+      message: "Only `/swarm knowledge`, `/swarm knowledge list`, and `/swarm knowledge unactionable` are available through swarm_command. Knowledge migrate/quarantine/restore/retry-hardening are intentionally excluded."
+    };
+  }
+  if (canonicalKey === "memory") {
+    if (args.length === 0)
+      return { allowed: true };
+    return {
+      allowed: false,
+      message: "Use `/swarm memory status`, `/swarm memory pending`, `/swarm memory recall-log`, `/swarm memory stale`, `/swarm memory export`, or `/swarm memory evaluate --json` through swarm_command. Memory import, migrate, and compact are intentionally excluded from chat-tool execution."
+    };
+  }
+  if (canonicalKey === "memory evaluate") {
+    if (args.length === 0)
+      return { allowed: true };
+    if (args.length === 1 && args[0] === "--json")
+      return { allowed: true };
+    return {
+      allowed: false,
+      message: "Usage through swarm_command: `/swarm memory evaluate --json`. Custom fixture directories are only available through direct user command execution."
+    };
+  }
+  if (canonicalKey === "sdd status") {
+    if (args.length === 0)
+      return { allowed: true };
+    if (args.length === 1 && args[0] === "--json")
+      return { allowed: true };
+    return {
+      allowed: false,
+      message: "Usage through swarm_command: `/swarm sdd status` or `/swarm sdd status --json`."
+    };
+  }
+  if (canonicalKey === "sdd validate") {
+    if (args.length === 0)
+      return { allowed: true };
+    if (args.length === 1 && args[0] === "--json")
+      return { allowed: true };
+    if (args.length === 2 && args[0] === "--change" && /^[A-Za-z0-9_.-]{1,128}$/.test(args[1])) {
+      return { allowed: true };
+    }
+    return {
+      allowed: false,
+      message: "Usage through swarm_command: `/swarm sdd validate`, `/swarm sdd validate --json`, or `/swarm sdd validate --change <id>`."
+    };
+  }
+  if (canonicalKey === "memory pending" || canonicalKey === "memory recall-log" || canonicalKey === "memory stale") {
+    if (args.length === 0)
+      return { allowed: true };
+    if (args.length === 2 && args[0] === "--limit" && /^\d+$/.test(args[1])) {
+      return { allowed: true };
+    }
+    return {
+      allowed: false,
+      message: `Usage through swarm_command: \`/swarm ${canonicalKey}\` or ` + `\`/swarm ${canonicalKey} --limit <n>\`.`
+    };
+  }
+  if (canonicalKey === "retrieve") {
+    if (args.length !== 1 || !SUMMARY_ID_PATTERN.test(args[0])) {
+      return {
+        allowed: false,
+        message: "Usage through swarm_command: `/swarm retrieve <summary-id>` with a single summary ID such as S1."
+      };
+    }
+  }
+  if (canonicalKey === "benchmark") {
+    const allowedFlags = new Set(["--cumulative", "--ci-gate"]);
+    const invalid = args.filter((arg) => !allowedFlags.has(arg));
+    if (invalid.length > 0) {
+      return {
+        allowed: false,
+        message: "Only `--cumulative` and `--ci-gate` are supported for `/swarm benchmark` through swarm_command."
+      };
+    }
+  }
+  if (canonicalKey === "show-plan") {
+    if (args.length > 1 || args[0] && !/^\d+$/.test(args[0])) {
+      return {
+        allowed: false,
+        message: "Usage through swarm_command: `/swarm show-plan` or `/swarm show-plan <phase-number>`."
+      };
+    }
+  }
+  if (canonicalKey === "evidence") {
+    if (args.length > 1 || args[0] && !TASK_ID_PATTERN.test(args[0])) {
+      return {
+        allowed: false,
+        message: "Usage through swarm_command: `/swarm evidence` or `/swarm evidence <task-id>`."
+      };
+    }
+  }
+  if (canonicalKey === "help" && args.length > 2) {
+    return {
+      allowed: false,
+      message: "Usage through swarm_command: `/swarm help` or `/swarm help <command>`."
+    };
+  }
+  return { allowed: true };
+}
+function classifySwarmCommandChatFallbackUse(resolved) {
+  const canonicalKey = canonicalCommandKey(resolved);
+  const args = resolved.remainingArgs;
+  if (canonicalKey === "config doctor" && args.some((arg) => arg === "--fix" || arg === "-f")) {
+    return {
+      allowed: false,
+      message: "/swarm config doctor --fix is not available through chat fallback because it can modify configuration files. Run the CLI command directly when you intend to apply fixes."
+    };
+  }
+  if (canonicalKey === "knowledge migrate" || canonicalKey === "knowledge quarantine" || canonicalKey === "knowledge restore" || canonicalKey === "memory import" || canonicalKey === "memory migrate" || canonicalKey === "memory compact" || canonicalKey === "sdd project") {
+    return {
+      allowed: false,
+      message: `/swarm ${canonicalKey} is not available through chat fallback because it mutates .swarm state. ` + "Run the CLI command directly after confirming the intended state change."
+    };
+  }
+  return { allowed: true };
+}
+var SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, NO_ARGS, SUMMARY_ID_PATTERN, TASK_ID_PATTERN;
+var init_tool_policy = __esm(() => {
+  init_command_dispatch();
+  init_registry();
+  SWARM_COMMAND_TOOL_COMMANDS = lazyArray(() => VALID_COMMANDS.filter((cmd) => {
+    const policy = COMMAND_REGISTRY[cmd]?.toolPolicy;
+    return policy === "agent" || policy === "human-only";
+  }).sort());
+  SWARM_COMMAND_TOOL_ALLOWLIST = lazySet(() => VALID_COMMANDS.filter((cmd) => COMMAND_REGISTRY[cmd]?.toolPolicy === "agent"));
+  HUMAN_ONLY_SWARM_COMMANDS = lazySet(() => VALID_COMMANDS.filter((cmd) => {
+    const policy = COMMAND_REGISTRY[cmd]?.toolPolicy;
+    return policy === "human-only" || policy === "restricted";
+  }));
+  NO_ARGS = lazySet(() => VALID_COMMANDS.filter((cmd) => COMMAND_REGISTRY[cmd]?.toolNoArgs === true));
+  SUMMARY_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+  TASK_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,64}$/;
+});
+
 // src/sandbox/executor.ts
 var init_executor = () => {};
 
@@ -23197,6 +23502,7 @@ var init_helpers = __esm(() => {
 
 // src/hooks/guardrails/tool-before.ts
 var init_tool_before = __esm(() => {
+  init_tool_policy();
   init_constants();
   init_schema();
   init_executor();
@@ -37041,7 +37347,7 @@ function resetToRemoteBranch(cwd, options) {
   const prunedBranches = [];
   try {
     const currentBranch = getCurrentBranch(cwd);
-    const defaultRemoteBranch = _internals13.detectDefaultRemoteBranch(cwd);
+    const defaultRemoteBranch = _internals14.detectDefaultRemoteBranch(cwd);
     if (!defaultRemoteBranch) {
       return {
         success: false,
@@ -37223,7 +37529,7 @@ function resetToRemoteBranch(cwd, options) {
 function resetToMainAfterMerge(cwd, options) {
   const warnings = [];
   try {
-    const defaultBranch = _internals13.detectDefaultRemoteBranch(cwd);
+    const defaultBranch = _internals14.detectDefaultRemoteBranch(cwd);
     if (!defaultBranch) {
       return {
         success: false,
@@ -37250,7 +37556,7 @@ function resetToMainAfterMerge(cwd, options) {
     }
     if (currentBranch === defaultBranch) {
       try {
-        const logOutput = _internals13.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
+        const logOutput = _internals14.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
         if (logOutput.trim().length > 0) {
           return {
             success: false,
@@ -37265,11 +37571,11 @@ function resetToMainAfterMerge(cwd, options) {
       } catch {}
     } else {
       try {
-        _internals13.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
+        _internals14.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
       } catch {
         try {
-          const localSha = _internals13.gitExec(["rev-parse", "HEAD"], cwd).trim();
-          const remoteSha = _internals13.gitExec(["rev-parse", targetBranch], cwd).trim();
+          const localSha = _internals14.gitExec(["rev-parse", "HEAD"], cwd).trim();
+          const remoteSha = _internals14.gitExec(["rev-parse", targetBranch], cwd).trim();
           if (localSha !== remoteSha) {
             return {
               success: false,
@@ -37295,7 +37601,7 @@ function resetToMainAfterMerge(cwd, options) {
       }
     }
     try {
-      _internals13.gitExec(["fetch", "--prune", "origin"], cwd);
+      _internals14.gitExec(["fetch", "--prune", "origin"], cwd);
     } catch (err) {
       return {
         success: false,
@@ -37311,7 +37617,7 @@ function resetToMainAfterMerge(cwd, options) {
     let switchedBranch = false;
     if (currentBranch !== defaultBranch) {
       try {
-        _internals13.gitExec(["checkout", defaultBranch], cwd);
+        _internals14.gitExec(["checkout", defaultBranch], cwd);
         switchedBranch = true;
       } catch (err) {
         return {
@@ -37326,7 +37632,7 @@ function resetToMainAfterMerge(cwd, options) {
       }
     }
     try {
-      _internals13.gitExec(["reset", "--hard", targetBranch], cwd);
+      _internals14.gitExec(["reset", "--hard", targetBranch], cwd);
     } catch (err) {
       return {
         success: false,
@@ -37347,7 +37653,7 @@ function resetToMainAfterMerge(cwd, options) {
           while (Date.now() < endTime) {}
         }
         try {
-          _internals13.gitExec(["checkout", "--", "."], cwd);
+          _internals14.gitExec(["checkout", "--", "."], cwd);
           discardSucceeded = true;
           break;
         } catch {}
@@ -37358,18 +37664,18 @@ function resetToMainAfterMerge(cwd, options) {
       changesDiscarded = discardSucceeded;
     }
     try {
-      _internals13.gitExec(["clean", "-fd"], cwd);
+      _internals14.gitExec(["clean", "-fd"], cwd);
     } catch {
       warnings.push("Could not clean untracked files");
     }
     let branchDeleted = false;
     if (switchedBranch && previousBranch !== defaultBranch) {
       try {
-        const mergedOutput = _internals13.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const mergedOutput = _internals14.gitExec(["branch", "--merged", defaultBranch], cwd);
         const isMerged = mergedOutput.split(`
 `).some((line) => line.trim() === previousBranch || line.trim() === `* ${previousBranch}`);
         if (isMerged) {
-          _internals13.gitExec(["branch", "-d", previousBranch], cwd);
+          _internals14.gitExec(["branch", "-d", previousBranch], cwd);
           branchDeleted = true;
         } else {
           warnings.push(`Branch ${previousBranch} is not merged into ${defaultBranch} \u2014 keeping it`);
@@ -37380,7 +37686,7 @@ function resetToMainAfterMerge(cwd, options) {
     }
     if (options?.pruneBranches) {
       try {
-        const mergedOutput = _internals13.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const mergedOutput = _internals14.gitExec(["branch", "--merged", defaultBranch], cwd);
         const mergedLines = mergedOutput.split(`
 `);
         for (const line of mergedLines) {
@@ -37389,7 +37695,7 @@ function resetToMainAfterMerge(cwd, options) {
             continue;
           }
           try {
-            _internals13.gitExec(["branch", "-d", trimmedLine], cwd);
+            _internals14.gitExec(["branch", "-d", trimmedLine], cwd);
           } catch {
             warnings.push(`Could not prune branch: ${trimmedLine}`);
           }
@@ -37419,10 +37725,10 @@ function resetToMainAfterMerge(cwd, options) {
     };
   }
 }
-var GIT_TIMEOUT_MS2 = 30000, _internals13;
+var GIT_TIMEOUT_MS2 = 30000, _internals14;
 var init_branch = __esm(() => {
   init_logger();
-  _internals13 = {
+  _internals14 = {
     gitExec: gitExec2,
     detectDefaultRemoteBranch,
     getDefaultBaseBranch,
@@ -37641,18 +37947,18 @@ async function atomicWriteFile(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await bunWrite(tempPath, content);
-    _internals14.renameSync(tempPath, targetPath);
+    _internals15.renameSync(tempPath, targetPath);
   } finally {
     try {
-      _internals14.unlinkSync(tempPath);
+      _internals15.unlinkSync(tempPath);
     } catch {}
   }
 }
-var _internals14;
+var _internals15;
 var init_task_file = __esm(() => {
   init_bun_compat();
   init_lock();
-  _internals14 = {
+  _internals15 = {
     renameSync: renameSync6,
     unlinkSync: unlinkSync4
   };
@@ -40313,7 +40619,7 @@ async function activateProposal(directory, slug, force = false, options = {}) {
   try {
     await stampSourceEntries(directory, cleanSlug, fm.sourceKnowledgeIds);
     try {
-      _internals15.unlinkSync(from);
+      _internals16.unlinkSync(from);
     } catch {}
     return {
       activated: true,
@@ -40418,7 +40724,7 @@ async function autoApplyProposals(directory, llmDelegate) {
         }
       } else if (verdict === "REJECT") {
         try {
-          _internals15.unlinkSync(proposal.path);
+          _internals16.unlinkSync(proposal.path);
           warn(`[skill-generator] auto-apply rejected proposal "${proposal.slug}"; deleted ${proposal.path}`);
           result.rejected.push(proposal.slug);
         } catch (delErr) {
@@ -40528,7 +40834,7 @@ async function regenerateSkill(directory, slug, options = {}) {
       matchedEntries = all.filter((e) => idSet.has(e.id));
       if (matchedEntries.length === idSet.size && idSet.size > 0 && matchedEntries.every((e) => e.status === "archived")) {
         try {
-          await _internals15.retireSkill(directory, cleanSlug, "auto-retire: all source knowledge entries archived at regeneration time");
+          await _internals16.retireSkill(directory, cleanSlug, "auto-retire: all source knowledge entries archived at regeneration time");
         } catch {}
         return {
           regenerated: false,
@@ -40551,7 +40857,7 @@ async function regenerateSkill(directory, slug, options = {}) {
     const activeEntries = matchedEntries.filter((e) => e.status !== "archived");
     if (activeEntries.length === 0) {
       try {
-        await _internals15.retireSkill(directory, cleanSlug, "auto-retire: all matched source knowledge entries archived at regeneration time");
+        await _internals16.retireSkill(directory, cleanSlug, "auto-retire: all matched source knowledge entries archived at regeneration time");
       } catch {}
       return {
         regenerated: false,
@@ -40668,7 +40974,7 @@ async function regenerateSkill(directory, slug, options = {}) {
     evaluation
   };
 }
-var SLUG_PATTERN2, DEFAULT_SKILL_MIN_CONFIDENCE = 0.7, DEFAULT_SKILL_MIN_CONFIRMATIONS = 2, STRONG_SKILL_OUTCOME_COUNT = 3, MIN_CLUSTER_SIZE = 2, JACCARD_THRESHOLD = 0.5, AUTO_APPLY_BATCH_LIMIT = 5, _internals15;
+var SLUG_PATTERN2, DEFAULT_SKILL_MIN_CONFIDENCE = 0.7, DEFAULT_SKILL_MIN_CONFIRMATIONS = 2, STRONG_SKILL_OUTCOME_COUNT = 3, MIN_CLUSTER_SIZE = 2, JACCARD_THRESHOLD = 0.5, AUTO_APPLY_BATCH_LIMIT = 5, _internals16;
 var init_skill_generator = __esm(() => {
   init_knowledge_events();
   init_knowledge_store();
@@ -40677,7 +40983,7 @@ var init_skill_generator = __esm(() => {
   init_skill_changelog();
   init_skill_evaluator();
   SLUG_PATTERN2 = /^[a-z0-9][a-z0-9-]{0,63}$/;
-  _internals15 = {
+  _internals16 = {
     sanitizeSlug,
     isValidSlug: isValidSlug2,
     selectCandidateEntries,
@@ -40900,9 +41206,9 @@ function parseFeedbackMarker(raw) {
 function readFeedbackAppliedEntryIds(directory) {
   const resolved = resolveLogPath(directory);
   const processed = new Set;
-  if (!_internals16.existsSync(resolved))
+  if (!_internals17.existsSync(resolved))
     return processed;
-  const raw = _internals16.readFileSync(resolved, "utf-8");
+  const raw = _internals17.readFileSync(resolved, "utf-8");
   for (const line of raw.split(`
 `)) {
     const trimmed = line.trim();
@@ -40923,15 +41229,15 @@ function appendFeedbackAppliedMarker(directory, processedEntryIds) {
     return;
   const resolved = resolveLogPath(directory);
   const dir = path20.dirname(resolved);
-  if (!_internals16.existsSync(dir)) {
-    _internals16.mkdirSync(dir, { recursive: true });
+  if (!_internals17.existsSync(dir)) {
+    _internals17.mkdirSync(dir, { recursive: true });
   }
   const marker = {
     type: "feedback_applied",
     timestamp: new Date().toISOString(),
     processedEntryIds: [...new Set(processedEntryIds)]
   };
-  _internals16.appendFileSync(resolved, `${JSON.stringify(marker)}
+  _internals17.appendFileSync(resolved, `${JSON.stringify(marker)}
 `, "utf-8");
 }
 function appendSkillUsageEntry(directory, entry) {
@@ -40968,11 +41274,11 @@ function appendSkillUsageEntry(directory, entry) {
   }
   const resolved = validateSwarmPath(directory, "skill-usage.jsonl");
   const dir = path20.dirname(resolved);
-  if (!_internals16.existsSync(dir)) {
-    _internals16.mkdirSync(dir, { recursive: true });
+  if (!_internals17.existsSync(dir)) {
+    _internals17.mkdirSync(dir, { recursive: true });
   }
   const fullEntry = {
-    id: _internals16.generateId(),
+    id: _internals17.generateId(),
     skillPath,
     agentName,
     taskID,
@@ -40982,21 +41288,21 @@ function appendSkillUsageEntry(directory, entry) {
     ...reviewerNotes !== undefined && { reviewerNotes },
     ...skillVersion !== undefined && { skillVersion }
   };
-  _internals16.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
+  _internals17.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
 `, "utf-8");
   try {
-    const stat5 = _internals16.statSync(resolved);
+    const stat5 = _internals17.statSync(resolved);
     if (stat5.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
-      _internals16.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
+      _internals17.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
     }
   } catch {}
 }
 function readSkillUsageEntries(directory, options) {
   const resolved = resolveLogPath(directory);
-  if (!_internals16.existsSync(resolved)) {
+  if (!_internals17.existsSync(resolved)) {
     return [];
   }
-  const raw = _internals16.readFileSync(resolved, "utf-8");
+  const raw = _internals17.readFileSync(resolved, "utf-8");
   const entries = [];
   for (const line of raw.split(`
 `)) {
@@ -41035,20 +41341,20 @@ function readSkillUsageEntries(directory, options) {
 }
 function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEFAULT) {
   const logPath = resolveLogPath(directory);
-  if (!_internals16.existsSync(logPath))
+  if (!_internals17.existsSync(logPath))
     return [];
   try {
     const normalizedMaxBytes = Number.isFinite(maxBytes) ? maxBytes : TAIL_BYTES_DEFAULT;
     const boundedMaxBytes = Math.min(Math.max(1, normalizedMaxBytes), MAX_TAIL_BYTES);
-    const stat5 = _internals16.statSync(logPath);
+    const stat5 = _internals17.statSync(logPath);
     const start = Math.max(0, stat5.size - boundedMaxBytes);
-    const fd = _internals16.openSync(logPath, "r");
+    const fd = _internals17.openSync(logPath, "r");
     try {
       const readLen = stat5.size - start;
       if (readLen === 0)
         return [];
       const buf = Buffer.alloc(readLen);
-      _internals16.readSync(fd, buf, 0, buf.length, start);
+      _internals17.readSync(fd, buf, 0, buf.length, start);
       const content = buf.toString("utf-8");
       let usable;
       if (start > 0) {
@@ -41075,7 +41381,7 @@ function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEF
       }
       return entries;
     } finally {
-      _internals16.closeSync(fd);
+      _internals17.closeSync(fd);
     }
   } catch {
     return [];
@@ -41112,7 +41418,7 @@ function computeComplianceByVersion(entries, skillPath) {
 }
 function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   const resolved = resolveLogPath(directory);
-  if (!_internals16.existsSync(resolved)) {
+  if (!_internals17.existsSync(resolved)) {
     return { pruned: 0, remaining: 0 };
   }
   const allEntries = readSkillUsageEntries(directory);
@@ -41148,13 +41454,13 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
 `).concat(`
 `);
   try {
-    _internals16.writeFileSync(tmpPath, content, "utf-8");
-    _internals16.renameSync(tmpPath, resolved);
+    _internals17.writeFileSync(tmpPath, content, "utf-8");
+    _internals17.renameSync(tmpPath, resolved);
   } catch (writeErr) {
     const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
     try {
-      if (_internals16.existsSync(tmpPath)) {
-        _internals16.writeFileSync(tmpPath, "", "utf-8");
+      if (_internals17.existsSync(tmpPath)) {
+        _internals17.writeFileSync(tmpPath, "", "utf-8");
       }
     } catch {}
     return { pruned: 0, remaining: allEntries.length, error: msg };
@@ -41176,10 +41482,10 @@ async function resolveSourceKnowledgeIds(directory, skillPath) {
     if (!isContained) {
       return [];
     }
-    if (!_internals16.existsSync(absolute)) {
+    if (!_internals17.existsSync(absolute)) {
       return [];
     }
-    const content = _internals16.readFileSync(absolute, "utf-8");
+    const content = _internals17.readFileSync(absolute, "utf-8");
     return parseGeneratedFromKnowledge(content);
   } catch (err) {
     console.warn("[skill-usage-log] resolveSourceKnowledgeIds failed (fail-open):", err instanceof Error ? err.message : String(err));
@@ -41279,11 +41585,11 @@ async function applySkillUsageFeedback(directory, options) {
   }
   return { processed, bumps };
 }
-var _internals16, TAIL_BYTES_DEFAULT, MAX_TAIL_BYTES, SKILL_USAGE_LOG_ROTATE_BYTES, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL = 500, COMPLIANCE_BOOST = 0.05, VIOLATION_DECAY = 0.1;
+var _internals17, TAIL_BYTES_DEFAULT, MAX_TAIL_BYTES, SKILL_USAGE_LOG_ROTATE_BYTES, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL = 500, COMPLIANCE_BOOST = 0.05, VIOLATION_DECAY = 0.1;
 var init_skill_usage_log = __esm(() => {
   init_knowledge_store();
   init_utils2();
-  _internals16 = {
+  _internals17 = {
     generateId: () => crypto3.randomUUID(),
     appendFileSync: fs9.appendFileSync.bind(fs9),
     readFileSync: fs9.readFileSync.bind(fs9),
@@ -42079,7 +42385,7 @@ function rankSkillsForContext(skills, taskContext, directory) {
   const results = [];
   for (const skillPath of skills) {
     const skillEntries = allEntries.filter((e) => e.skillPath === skillPath);
-    const metadata = _internals17.readSkillMetadata(skillPath, directory);
+    const metadata = _internals18.readSkillMetadata(skillPath, directory);
     const score = computeSkillRelevanceScore(skillPath, taskContext, skillEntries, metadata);
     const entriesWithVerdict = skillEntries.filter((e) => e.complianceVerdict !== undefined && e.complianceVerdict !== "not_checked");
     const compliantCount = entriesWithVerdict.filter((e) => e.complianceVerdict === "compliant").length;
@@ -42134,7 +42440,7 @@ function formatSkillIndexWithContext(skills, directory) {
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
-      const meta3 = _internals17.readSkillMetadata(sp, directory);
+      const meta3 = _internals18.readSkillMetadata(sp, directory);
       return `  - file:${meta3.path} - ${meta3.name}: ${meta3.description}`;
     }).join(`
 `);
@@ -42142,7 +42448,7 @@ function formatSkillIndexWithContext(skills, directory) {
   const lines = [];
   for (const skillPath of skills) {
     const stats = getSkillStats(skillPath, directory);
-    const meta3 = _internals17.readSkillMetadata(skillPath, directory);
+    const meta3 = _internals18.readSkillMetadata(skillPath, directory);
     const compliancePct = Math.round(stats.complianceRate * 100);
     const topAgentNames = stats.topAgents.slice(0, 3).map((a) => a.agent).join(", ");
     lines.push(`  - file:${meta3.path} - ${meta3.name}: ${meta3.description} (used: ${stats.totalUsage}, compliance: ${compliancePct}%)` + (stats.topAgents.length > 0 ? ` \u2192 ${topAgentNames}` : ""));
@@ -42150,12 +42456,12 @@ function formatSkillIndexWithContext(skills, directory) {
   return lines.join(`
 `);
 }
-var FREQUENCY_CAP = 10, FREQUENCY_WEIGHT = 0.3, COMPLIANCE_WEIGHT = 0.3, RECENCY_WEIGHT = 0.15, TASK_DIVERSITY_WEIGHT = 0.05, CONTEXT_WEIGHT = 0.2, WORKFLOW_BOOST = 0.1, SKILL_TRIGGER_BOOST = 0.3, SKILL_TRIGGER_MIN_LENGTH = 3, MAX_SKILL_TRIGGERS = 20, MAX_SKILL_TRIGGER_LENGTH = 120, WORKFLOW_BOOST_MIN_CONTEXT = 0.05, RECENCY_DECAY_MS, SKILL_FRONTMATTER_READ_BYTES, _internals17, MIN_KEYWORD_LENGTH = 3;
+var FREQUENCY_CAP = 10, FREQUENCY_WEIGHT = 0.3, COMPLIANCE_WEIGHT = 0.3, RECENCY_WEIGHT = 0.15, TASK_DIVERSITY_WEIGHT = 0.05, CONTEXT_WEIGHT = 0.2, WORKFLOW_BOOST = 0.1, SKILL_TRIGGER_BOOST = 0.3, SKILL_TRIGGER_MIN_LENGTH = 3, MAX_SKILL_TRIGGERS = 20, MAX_SKILL_TRIGGER_LENGTH = 120, WORKFLOW_BOOST_MIN_CONTEXT = 0.05, RECENCY_DECAY_MS, SKILL_FRONTMATTER_READ_BYTES, _internals18, MIN_KEYWORD_LENGTH = 3;
 var init_skill_scoring = __esm(() => {
   init_skill_usage_log();
   RECENCY_DECAY_MS = 30 * 24 * 60 * 60 * 1000;
   SKILL_FRONTMATTER_READ_BYTES = 16 * 1024;
-  _internals17 = {
+  _internals18 = {
     computeSkillRelevanceScore: null,
     rankSkillsForContext: null,
     getSkillStats: null,
@@ -42167,16 +42473,16 @@ var init_skill_scoring = __esm(() => {
     computeContextMatchScore: null,
     computeTriggerMatchBoost: null
   };
-  _internals17.computeSkillRelevanceScore = computeSkillRelevanceScore;
-  _internals17.rankSkillsForContext = rankSkillsForContext;
-  _internals17.getSkillStats = getSkillStats;
-  _internals17.formatSkillIndexWithContext = formatSkillIndexWithContext;
-  _internals17.parseSkillFrontmatter = parseSkillFrontmatter;
-  _internals17.readSkillMetadata = readSkillMetadata;
-  _internals17.extractSkillName = extractSkillName;
-  _internals17.computeRecencyScore = computeRecencyScore;
-  _internals17.computeContextMatchScore = computeContextMatchScore;
-  _internals17.computeTriggerMatchBoost = computeTriggerMatchBoost;
+  _internals18.computeSkillRelevanceScore = computeSkillRelevanceScore;
+  _internals18.rankSkillsForContext = rankSkillsForContext;
+  _internals18.getSkillStats = getSkillStats;
+  _internals18.formatSkillIndexWithContext = formatSkillIndexWithContext;
+  _internals18.parseSkillFrontmatter = parseSkillFrontmatter;
+  _internals18.readSkillMetadata = readSkillMetadata;
+  _internals18.extractSkillName = extractSkillName;
+  _internals18.computeRecencyScore = computeRecencyScore;
+  _internals18.computeContextMatchScore = computeContextMatchScore;
+  _internals18.computeTriggerMatchBoost = computeTriggerMatchBoost;
 });
 
 // src/hooks/skill-propagation-gate.ts
@@ -42281,10 +42587,10 @@ function parseYamlValue(value) {
 }
 function loadRoutingSkills(directory, targetAgent) {
   const routingPath = path24.join(directory, ".opencode", "skill-routing.yaml");
-  if (!_internals18.existsSync(routingPath))
+  if (!_internals19.existsSync(routingPath))
     return [];
   try {
-    const content = _internals18.readFileSync(routingPath, "utf-8");
+    const content = _internals19.readFileSync(routingPath, "utf-8");
     const config3 = parseSimpleYaml(content);
     if (!config3?.routing)
       return [];
@@ -42301,11 +42607,11 @@ function discoverAvailableSkills(directory) {
   const results = [];
   for (const root of SKILL_SEARCH_ROOTS) {
     const rootPath = path24.join(directory, root);
-    if (!_internals18.existsSync(rootPath))
+    if (!_internals19.existsSync(rootPath))
       continue;
     let entries;
     try {
-      entries = _internals18.readdirSync(rootPath);
+      entries = _internals19.readdirSync(rootPath);
     } catch {
       continue;
     }
@@ -42313,11 +42619,11 @@ function discoverAvailableSkills(directory) {
       if (entry.startsWith("."))
         continue;
       const skillDir = path24.join(rootPath, entry);
-      if (_internals18.existsSync(path24.join(skillDir, "retired.marker")))
+      if (_internals19.existsSync(path24.join(skillDir, "retired.marker")))
         continue;
       const skillFile = path24.join(skillDir, "SKILL.md");
       try {
-        if (_internals18.statSync(skillDir).isDirectory() && _internals18.existsSync(skillFile)) {
+        if (_internals19.statSync(skillDir).isDirectory() && _internals19.existsSync(skillFile)) {
           results.push(path24.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
         }
       } catch (err) {
@@ -42349,7 +42655,7 @@ function parseDelegationArgs(args) {
   }
   if (!targetAgent)
     return null;
-  const skillsField = prompt ? _internals18.extractSkillsFieldFromPrompt(prompt) : "";
+  const skillsField = prompt ? _internals19.extractSkillsFieldFromPrompt(prompt) : "";
   return { targetAgent, skillsField };
 }
 function extractSkillsFieldFromPrompt(prompt) {
@@ -42390,10 +42696,10 @@ function writeWarnEvent(directory, record3) {
   const filePath = path24.join(directory, ".swarm", "events.jsonl");
   try {
     const dir = path24.dirname(filePath);
-    if (!_internals18.existsSync(dir)) {
-      _internals18.mkdirSync(dir, { recursive: true });
+    if (!_internals19.existsSync(dir)) {
+      _internals19.mkdirSync(dir, { recursive: true });
     }
-    _internals18.appendFileSync(filePath, `${JSON.stringify(record3)}
+    _internals19.appendFileSync(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
   } catch (err) {
     warn(`[skill-propagation-gate] failed to write warning event: ${err instanceof Error ? err.message : String(err)}`);
@@ -42444,19 +42750,19 @@ async function skillPropagationGateBefore(directory, input, config3) {
   const baseAgent = stripKnownSwarmPrefix(agentRaw);
   if (baseAgent !== "architect")
     return { blocked: false, reason: null, recommendedSkills: undefined };
-  const parsed = _internals18.parseDelegationArgs(input.args);
+  const parsed = _internals19.parseDelegationArgs(input.args);
   if (!parsed)
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
-  if (!_internals18.SKILL_CAPABLE_AGENTS.has(targetBase))
+  if (!_internals19.SKILL_CAPABLE_AGENTS.has(targetBase))
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const sessionID = typeof input.sessionID === "string" ? input.sessionID : "unknown";
-  const availableSkills = _internals18.discoverAvailableSkills(directory);
+  const availableSkills = _internals19.discoverAvailableSkills(directory);
   const skillsValue = parsed.skillsField.trim();
   if (skillsValue && skillsValue.toLowerCase() !== "none") {
     const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
-    const taskId = _internals18.extractTaskIdFromPrompt(prompt);
-    const skillPaths = _internals18.parseSkillPaths(skillsValue);
+    const taskId = _internals19.extractTaskIdFromPrompt(prompt);
+    const skillPaths = _internals19.parseSkillPaths(skillsValue);
     let coderSkillPaths = [];
     if (prompt) {
       for (const line of prompt.split(`
@@ -42464,7 +42770,7 @@ async function skillPropagationGateBefore(directory, input, config3) {
         const trimmed = line.trim();
         if (trimmed.startsWith("SKILLS_USED_BY_CODER:")) {
           const fieldVal = trimmed.slice("SKILLS_USED_BY_CODER:".length).trim();
-          coderSkillPaths = _internals18.parseSkillPaths(fieldVal);
+          coderSkillPaths = _internals19.parseSkillPaths(fieldVal);
           break;
         }
       }
@@ -42472,7 +42778,7 @@ async function skillPropagationGateBefore(directory, input, config3) {
     const allPaths = [...new Set([...skillPaths, ...coderSkillPaths])];
     for (const skillPath of allPaths) {
       try {
-        _internals18.appendSkillUsageEntry(directory, {
+        _internals19.appendSkillUsageEntry(directory, {
           skillPath,
           agentName: targetBase,
           taskID: taskId,
@@ -42489,18 +42795,18 @@ async function skillPropagationGateBefore(directory, input, config3) {
   let scored = [];
   if (skillsValue.toLowerCase() !== "none" && availableSkills.length > 0) {
     try {
-      const sessionEntries = _internals18.readSkillUsageEntriesTail(directory, {
+      const sessionEntries = _internals19.readSkillUsageEntriesTail(directory, {
         sessionID
       });
-      if (sessionEntries.length > _internals18.MAX_SCORING_SESSION_ENTRIES) {
+      if (sessionEntries.length > _internals19.MAX_SCORING_SESSION_ENTRIES) {
         scoringSkipped = true;
-        warn(`[skill-propagation-gate] skipping scoring \u2014 tail window has ${sessionEntries.length} session entries (limit: ${_internals18.MAX_SCORING_SESSION_ENTRIES})`);
+        warn(`[skill-propagation-gate] skipping scoring \u2014 tail window has ${sessionEntries.length} session entries (limit: ${_internals19.MAX_SCORING_SESSION_ENTRIES})`);
       } else {
         const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
         scored = availableSkills.map((skillPath) => {
           const skillEntries = sessionEntries.filter((e) => e.skillPath === skillPath);
-          const metadata = _internals18.readSkillMetadata(skillPath, directory);
-          const score = _internals18.computeSkillRelevanceScore(skillPath, prompt, skillEntries, metadata);
+          const metadata = _internals19.readSkillMetadata(skillPath, directory);
+          const score = _internals19.computeSkillRelevanceScore(skillPath, prompt, skillEntries, metadata);
           return { skillPath, score, usageCount: skillEntries.length };
         }).sort((a, b) => b.score - a.score || b.usageCount - a.usageCount);
         if (scored.length > 0) {
@@ -42514,12 +42820,12 @@ async function skillPropagationGateBefore(directory, input, config3) {
     }
   }
   try {
-    const routingPaths = _internals18.loadRoutingSkills(directory, targetBase);
+    const routingPaths = _internals19.loadRoutingSkills(directory, targetBase);
     if (routingPaths.length > 0) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
         const routedSkillDir = path24.dirname(path24.join(directory, routingPath));
-        if (_internals18.existsSync(path24.join(routedSkillDir, "retired.marker")))
+        if (_internals19.existsSync(path24.join(routedSkillDir, "retired.marker")))
           continue;
         if (!existingPaths.has(routingPath)) {
           scored.push({
@@ -42545,12 +42851,12 @@ async function skillPropagationGateBefore(directory, input, config3) {
       } else if (typeof scored !== "undefined" && scored.length > 0) {
         skillsForIndex = scored.map((r) => r.skillPath);
       }
-      const formattedIndex = _internals18.formatSkillIndexWithContext(skillsForIndex, directory);
+      const formattedIndex = _internals19.formatSkillIndexWithContext(skillsForIndex, directory);
       if (formattedIndex.length > 0) {
         const contextPath = path24.join(directory, ".swarm", "context.md");
         let existingContent = "";
-        if (_internals18.existsSync(contextPath)) {
-          existingContent = _internals18.readFileSync(contextPath, "utf-8");
+        if (_internals19.existsSync(contextPath)) {
+          existingContent = _internals19.readFileSync(contextPath, "utf-8");
         }
         const sectionHeader = "## Available Skills";
         const newSection = `${sectionHeader}
@@ -42570,10 +42876,10 @@ ${newSection}`;
           }
         }
         const swarmDir = path24.dirname(contextPath);
-        if (!_internals18.existsSync(swarmDir)) {
-          _internals18.mkdirSync(swarmDir, { recursive: true });
+        if (!_internals19.existsSync(swarmDir)) {
+          _internals19.mkdirSync(swarmDir, { recursive: true });
         }
-        _internals18.writeFileSync(contextPath, updatedContent, "utf-8");
+        _internals19.writeFileSync(contextPath, updatedContent, "utf-8");
       }
     } catch (err) {
       warn(`[skill-propagation-gate] failed to write skill index to context.md: ${err instanceof Error ? err.message : String(err)}`);
@@ -42599,7 +42905,7 @@ ${newSection}`;
   });
   const warningMsg = `Skill propagation warning: Delegating to ${targetBase} without SKILLS field. ` + `Available skills: ${skillNames.join(", ")}`;
   try {
-    _internals18.writeWarnEvent(directory, {
+    _internals19.writeWarnEvent(directory, {
       type: "skill_propagation_warn",
       timestamp: new Date().toISOString(),
       tool: toolName,
@@ -42626,7 +42932,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
   let dedupKeys = new Set;
   let existingEntries = [];
   try {
-    existingEntries = _internals18.readSkillUsageEntriesTail(directory, {
+    existingEntries = _internals19.readSkillUsageEntriesTail(directory, {
       sessionID
     });
     dedupKeys = new Set(existingEntries.map((e, i) => {
@@ -42664,7 +42970,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
       }
       const coderMatch = trimmed.match(CODER_SKILLS_PATTERN);
       if (coderMatch) {
-        const parsed = _internals18.parseSkillPaths(coderMatch[1]);
+        const parsed = _internals19.parseSkillPaths(coderMatch[1]);
         skillPaths.push(...parsed);
       }
     }
@@ -42697,7 +43003,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
         if (isDuplicate(skillPath, "reviewer", resolvedTaskID))
           continue;
         try {
-          _internals18.appendSkillUsageEntry(directory, {
+          _internals19.appendSkillUsageEntry(directory, {
             skillPath,
             agentName: "reviewer",
             taskID: resolvedTaskID,
@@ -42741,15 +43047,15 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
         skillsField = trimmed.slice("SKILLS:".length).trim();
       }
       if (currentTargetAgent && skillsField && skillsField.toLowerCase() !== "none") {
-        const skillPaths = _internals18.parseSkillPaths(skillsField);
-        const taskId = _internals18.extractTaskIdFromPrompt(text);
+        const skillPaths = _internals19.parseSkillPaths(skillsField);
+        const taskId = _internals19.extractTaskIdFromPrompt(text);
         for (const skillPath of skillPaths) {
           if (hadRecordingError)
             break;
           if (isDuplicate(skillPath, currentTargetAgent, taskId))
             continue;
           try {
-            _internals18.appendSkillUsageEntry(directory, {
+            _internals19.appendSkillUsageEntry(directory, {
               skillPath,
               agentName: currentTargetAgent,
               taskID: taskId,
@@ -42769,7 +43075,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
     break;
   }
 }
-var SKILL_CAPABLE_AGENTS, SKILL_SEARCH_ROOTS, MAX_SCORING_SESSION_ENTRIES = 500, _internals18, COMPLIANCE_PATTERN, CODER_SKILLS_PATTERN, REVIEWER_TASK_PATTERN;
+var SKILL_CAPABLE_AGENTS, SKILL_SEARCH_ROOTS, MAX_SCORING_SESSION_ENTRIES = 500, _internals19, COMPLIANCE_PATTERN, CODER_SKILLS_PATTERN, REVIEWER_TASK_PATTERN;
 var init_skill_propagation_gate = __esm(() => {
   init_schema();
   init_logger();
@@ -42788,7 +43094,7 @@ var init_skill_propagation_gate = __esm(() => {
     ".opencode/skills/generated",
     ".claude/skills"
   ];
-  _internals18 = {
+  _internals19 = {
     readdirSync: fs11.readdirSync.bind(fs11),
     existsSync: fs11.existsSync.bind(fs11),
     statSync: fs11.statSync.bind(fs11),
@@ -42817,16 +43123,16 @@ var init_skill_propagation_gate = __esm(() => {
   COMPLIANCE_PATTERN = /SKILL_COMPLIANCE\s*:\s*(COMPLIANT|PARTIAL|VIOLATED)(?:\s*(?:\u2014|-)\s*(.*))?\s*$/i;
   CODER_SKILLS_PATTERN = /SKILLS_USED_BY_CODER\s*:\s*(.+)/i;
   REVIEWER_TASK_PATTERN = /TASK\s*:\s*(\S+)/i;
-  _internals18.skillPropagationGateBefore = skillPropagationGateBefore;
-  _internals18.skillPropagationTransformScan = skillPropagationTransformScan;
-  _internals18.writeWarnEvent = writeWarnEvent;
-  _internals18.discoverAvailableSkills = discoverAvailableSkills;
-  _internals18.parseDelegationArgs = parseDelegationArgs;
-  _internals18.parseSkillPaths = parseSkillPaths;
-  _internals18.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
-  _internals18.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
-  _internals18.formatSkillIndexWithContext = formatSkillIndexWithContext;
-  _internals18.loadRoutingSkills = loadRoutingSkills;
+  _internals19.skillPropagationGateBefore = skillPropagationGateBefore;
+  _internals19.skillPropagationTransformScan = skillPropagationTransformScan;
+  _internals19.writeWarnEvent = writeWarnEvent;
+  _internals19.discoverAvailableSkills = discoverAvailableSkills;
+  _internals19.parseDelegationArgs = parseDelegationArgs;
+  _internals19.parseSkillPaths = parseSkillPaths;
+  _internals19.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
+  _internals19.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
+  _internals19.formatSkillIndexWithContext = formatSkillIndexWithContext;
+  _internals19.loadRoutingSkills = loadRoutingSkills;
 });
 
 // src/hooks/micro-reflector.ts
@@ -43427,7 +43733,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     } catch {}
   }
   if (!options?.skipAutoPromotion) {
-    await _internals19.runAutoPromotion(directory, config3);
+    await _internals20.runAutoPromotion(directory, config3);
   }
   return { stored, reinforced, skipped, rejected, quarantined };
 }
@@ -43510,7 +43816,7 @@ function createKnowledgeCuratorHook(directory, config3, options = {}) {
       recordSeenRetroSection(evidenceKey, evidenceHash, Date.now());
       const projectName2 = evidenceData.project_name ?? "unknown";
       const phaseNumber2 = typeof evidenceData.phase_number === "number" ? evidenceData.phase_number : 1;
-      await _internals19.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3, {
+      await _internals20.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3, {
         llmDelegate: options.llmDelegateFactory?.(sessionID),
         enrichmentQuota: options.enrichmentQuota
       });
@@ -43535,14 +43841,14 @@ function createKnowledgeCuratorHook(directory, config3, options = {}) {
     const projectName = projectNameMatch ? projectNameMatch[1].trim() : "unknown";
     const phaseMatch = /^Phase:\s*(\d+)/m.exec(planContent);
     const phaseNumber = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
-    await _internals19.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3, {
+    await _internals20.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3, {
       llmDelegate: options.llmDelegateFactory?.(sessionID),
       enrichmentQuota: options.enrichmentQuota
     });
   };
   return safeHook(handler);
 }
-var seenRetroSections, MAX_TRACKED_RETRO_SECTIONS = 500, ENRICHMENT_ALLOWED_FIELDS, ENRICHMENT_LLM_TIMEOUT_MS = 60000, MESO_INSIGHT_BATCH_LIMIT = 20, KNOWLEDGE_CATEGORIES, OUTCOME_PROMOTION_BLOCK = -0.3, _internals19;
+var seenRetroSections, MAX_TRACKED_RETRO_SECTIONS = 500, ENRICHMENT_ALLOWED_FIELDS, ENRICHMENT_LLM_TIMEOUT_MS = 60000, MESO_INSIGHT_BATCH_LIMIT = 20, KNOWLEDGE_CATEGORIES, OUTCOME_PROMOTION_BLOCK = -0.3, _internals20;
 var init_knowledge_curator = __esm(() => {
   init_skill_improver_quota();
   init_synonym_map();
@@ -43575,7 +43881,7 @@ var init_knowledge_curator = __esm(() => {
     "todo",
     "other"
   ]);
-  _internals19 = {
+  _internals20 = {
     isWriteToEvidenceFile,
     curateAndStoreSwarm,
     runAutoPromotion,
@@ -44823,7 +45129,7 @@ async function executeWriteRetro(args, directory) {
     }, null, 2);
   }
 }
-var write_retro, _internals20;
+var write_retro, _internals21;
 var init_write_retro = __esm(() => {
   init_zod();
   init_evidence_schema();
@@ -44870,13 +45176,13 @@ var init_write_retro = __esm(() => {
           task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
           metadata: args.metadata
         };
-        return await _internals20.executeWriteRetro(writeRetroArgs, directory);
+        return await _internals21.executeWriteRetro(writeRetroArgs, directory);
       } catch {
         return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
       }
     }
   });
-  _internals20 = {
+  _internals21 = {
     executeWriteRetro,
     write_retro
   };
@@ -44886,7 +45192,7 @@ var init_write_retro = __esm(() => {
 var exports_curator_postmortem = {};
 __export(exports_curator_postmortem, {
   runCuratorPostMortem: () => runCuratorPostMortem,
-  _internals: () => _internals21
+  _internals: () => _internals22
 });
 import { existsSync as existsSync19, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
 import * as path29 from "path";
@@ -45240,13 +45546,13 @@ ${llmOutput}`;
     warnings
   };
 }
-var _internals21;
+var _internals22;
 var init_curator_postmortem = __esm(() => {
   init_manager();
   init_knowledge_events();
   init_knowledge_store();
   init_utils2();
-  _internals21 = {
+  _internals22 = {
     collectKnowledgeSummary,
     collectRetrospectives,
     collectDriftReports,
@@ -46758,9 +47064,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals22.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals22.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
-  const staticEdges = await _internals22.getStaticEdges(directory);
+  const commitMap = await _internals23.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals23.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
+  const staticEdges = await _internals23.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -46848,7 +47154,7 @@ ${rows}
 These pairs likely share an architectural concern invisible to static analysis.
 Consider adding explicit documentation or extracting the shared concern.`;
 }
-var co_change_analyzer, _internals22;
+var co_change_analyzer, _internals23;
 var init_co_change_analyzer = __esm(() => {
   init_zod();
   init_create_tool();
@@ -46880,11 +47186,11 @@ var init_co_change_analyzer = __esm(() => {
         npmiThreshold,
         maxCommitsToAnalyze
       };
-      const pairs = await _internals22.detectDarkMatter(directory, options);
-      return _internals22.formatDarkMatterOutput(pairs);
+      const pairs = await _internals23.detectDarkMatter(directory, options);
+      return _internals23.formatDarkMatterOutput(pairs);
     }
   });
-  _internals22 = {
+  _internals23 = {
     parseGitLog,
     buildCoChangeMatrix,
     getStaticEdges,
@@ -46915,7 +47221,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals22.detectDarkMatter(directory, options);
+    pairs = await _internals23.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -50967,7 +51273,7 @@ function isCommandAvailable(command) {
   const isWindows = process.platform === "win32";
   const cmd = isWindows ? `${command}.exe` : command;
   try {
-    const result = _internals23.spawnSyncImpl(isWindows ? ["where", cmd] : ["which", cmd], {
+    const result = _internals24.spawnSyncImpl(isWindows ? ["where", cmd] : ["which", cmd], {
       cwd: process.cwd(),
       stdin: "ignore",
       stdout: "ignore",
@@ -51117,7 +51423,7 @@ async function discoverBuildCommands(workingDir, options) {
   const scope = options?.scope ?? "all";
   const changedFiles = options?.changedFiles ?? [];
   const _filesToCheck = filterByScope(workingDir, scope, changedFiles);
-  const profileResult = await _internals23.discoverBuildCommandsFromProfiles(workingDir);
+  const profileResult = await _internals24.discoverBuildCommandsFromProfiles(workingDir);
   const profileCommands = profileResult.commands;
   const profileSkipped = profileResult.skipped;
   const coveredEcosystems = new Set;
@@ -51180,7 +51486,7 @@ function clearToolchainCache() {
 function getEcosystems() {
   return ECOSYSTEMS.map((e) => e.ecosystem);
 }
-var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000, _internals23, build_discovery;
+var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000, _internals24, build_discovery;
 var init_discovery = __esm(() => {
   init_dist();
   init_detector();
@@ -51298,7 +51604,7 @@ var init_discovery = __esm(() => {
     php: ["php-composer"]
   };
   toolchainCache = new Map;
-  _internals23 = {
+  _internals24 = {
     isCommandAvailable,
     discoverBuildCommandsFromProfiles,
     discoverBuildCommands,
@@ -51577,7 +51883,7 @@ var exports_evidence_summary_service = {};
 __export(exports_evidence_summary_service, {
   isAutoSummaryEnabled: () => isAutoSummaryEnabled,
   buildEvidenceSummary: () => buildEvidenceSummary,
-  _internals: () => _internals24,
+  _internals: () => _internals25,
   REQUIRED_EVIDENCE_TYPES: () => REQUIRED_EVIDENCE_TYPES,
   EVIDENCE_SUMMARY_VERSION: () => EVIDENCE_SUMMARY_VERSION
 });
@@ -51615,7 +51921,7 @@ function getTaskStatus(task, bundle) {
   if (task?.status) {
     return task.status;
   }
-  const entries = _internals24.normalizeBundleEntries(bundle);
+  const entries = _internals25.normalizeBundleEntries(bundle);
   if (entries.length > 0) {
     return "completed";
   }
@@ -51641,7 +51947,7 @@ function evidenceCompleteFromEntries(entries) {
   };
 }
 function isEvidenceComplete(bundle) {
-  return evidenceCompleteFromEntries(_internals24.normalizeBundleEntries(bundle));
+  return evidenceCompleteFromEntries(_internals25.normalizeBundleEntries(bundle));
 }
 function getTaskBlockers(task, summary, status) {
   const blockers = [];
@@ -51661,9 +51967,9 @@ async function buildTaskSummary(directory, task, taskId) {
   const bundle = result.status === "found" ? result.bundle : null;
   const gateEvidence = await readDurableGateEvidence(directory, taskId);
   const phase = task?.phase ?? 0;
-  const status = _internals24.getTaskStatus(task, bundle);
-  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals24.normalizeBundleEntries(bundle), gateEvidence);
-  let evidenceCheck = _internals24.evidenceCompleteFromEntries(entries);
+  const status = _internals25.getTaskStatus(task, bundle);
+  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals25.normalizeBundleEntries(bundle), gateEvidence);
+  let evidenceCheck = _internals25.evidenceCompleteFromEntries(entries);
   if (gateEvidence) {
     const gateStatus = getDurableGateEvidenceStatus(gateEvidence);
     evidenceCheck = gateStatus.isComplete ? { isComplete: true, missingEvidence: [] } : {
@@ -51671,7 +51977,7 @@ async function buildTaskSummary(directory, task, taskId) {
       missingEvidence: gateStatus.missingGates.map((gate) => `gate:${gate}`)
     };
   }
-  const blockers = _internals24.getTaskBlockers(task, evidenceCheck, status);
+  const blockers = _internals25.getTaskBlockers(task, evidenceCheck, status);
   const hasReview = entries.some((e) => e.type === "review");
   const hasTest = entries.some((e) => e.type === "test");
   const hasApproval = entries.some((e) => e.type === "approval");
@@ -51700,12 +52006,12 @@ async function buildPhaseSummary(directory, phase) {
   const taskSummaries = [];
   const _taskMap = new Map(phase.tasks.map((t) => [t.id, t]));
   for (const task of phase.tasks) {
-    const summary = await _internals24.buildTaskSummary(directory, task, task.id);
+    const summary = await _internals25.buildTaskSummary(directory, task, task.id);
     taskSummaries.push(summary);
   }
   const extraTaskIds = taskIds.filter((id) => !phaseTaskIds.has(id));
   for (const taskId of extraTaskIds) {
-    const summary = await _internals24.buildTaskSummary(directory, undefined, taskId);
+    const summary = await _internals25.buildTaskSummary(directory, undefined, taskId);
     if (summary.phase === phase.id) {
       taskSummaries.push(summary);
     }
@@ -51806,7 +52112,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
   let totalTasks = 0;
   let completedTasks = 0;
   for (const phase of phasesToProcess) {
-    const summary = await _internals24.buildPhaseSummary(directory, phase);
+    const summary = await _internals25.buildPhaseSummary(directory, phase);
     phaseSummaries.push(summary);
     totalTasks += summary.totalTasks;
     completedTasks += summary.completedTasks;
@@ -51828,7 +52134,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
     overallBlockers,
     summaryText: ""
   };
-  artifact.summaryText = _internals24.generateSummaryText(artifact);
+  artifact.summaryText = _internals25.generateSummaryText(artifact);
   log("[EvidenceSummary] Summary built", {
     phases: phaseSummaries.length,
     totalTasks,
@@ -51847,7 +52153,7 @@ function isAutoSummaryEnabled(automationConfig) {
   }
   return automationConfig.capabilities?.evidence_auto_summaries === true;
 }
-var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals24;
+var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals25;
 var init_evidence_summary_service = __esm(() => {
   init_gate_bridge();
   init_manager2();
@@ -51862,7 +52168,7 @@ var init_evidence_summary_service = __esm(() => {
     "retrospective"
   ]);
   REQUIRED_EVIDENCE_TYPES = ["review", "test"];
-  _internals24 = {
+  _internals25 = {
     buildEvidenceSummary,
     isAutoSummaryEnabled,
     normalizeBundleEntries,
@@ -51918,7 +52224,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals25.loadEvidence(directory, taskId);
+  const result = await _internals26.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -51941,13 +52247,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals25.listEvidenceTaskIds(directory);
+  const taskIds = await _internals26.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals25.loadEvidence(directory, taskId);
+    const result = await _internals26.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -52061,10 +52367,10 @@ async function handleEvidenceSummaryCommand(directory) {
   return lines.join(`
 `);
 }
-var _internals25;
+var _internals26;
 var init_evidence_service = __esm(() => {
   init_manager2();
-  _internals25 = {
+  _internals26 = {
     loadEvidence,
     listEvidenceTaskIds
   };
@@ -52592,7 +52898,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals26.validatePlanPhases(plan)) {
+  if (!_internals27.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -52734,9 +53040,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals26.parseSessionState(sessionContent);
+  const sessionState = _internals27.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals26.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals27.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -52755,8 +53061,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals26.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals26.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals27.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals27.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -52920,13 +53226,13 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals26;
+var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals27;
 var init_handoff_service = __esm(() => {
   init_utils2();
   init_manager();
   init_utils();
   RTL_OVERRIDE_PATTERN = /[\u202e\u202d\u202c\u200f]/g;
-  _internals26 = {
+  _internals27 = {
     getHandoffData,
     formatHandoffMarkdown,
     formatContinuationPrompt,
@@ -53069,22 +53375,22 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals27.writeSnapshot(directory, swarmState), () => _internals27.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals28.writeSnapshot(directory, swarmState), () => _internals28.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals27.writeSnapshot(directory, swarmState), () => _internals27.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals28.writeSnapshot(directory, swarmState), () => _internals28.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _writeInFlight, _internals27;
+var _writeInFlight, _internals28;
 var init_snapshot_writer = __esm(() => {
   init_utils2();
   init_state();
   init_utils();
   init_bun_compat();
   _writeInFlight = Promise.resolve();
-  _internals27 = {
+  _internals28 = {
     writeSnapshot,
     createSnapshotWriterHook,
     flushPendingSnapshot
@@ -53404,7 +53710,7 @@ function validateAndSanitizeGithubUrl(rawUrl, resource) {
 }
 function detectGitRemote(cwd) {
   try {
-    const result = _internals28.spawnSync("git", ["remote", "get-url", "origin"], {
+    const result = _internals29.spawnSync("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 5000,
@@ -53449,7 +53755,7 @@ function parseGitRemoteUrl(remoteUrl) {
   }
   return null;
 }
-var MAX_URL_LEN = 2048, IPV4_PRIVATE, IPV4_LOOPBACK, IPV4_LINK_LOCAL, IPV4_PRIVATE_172, IPV4_PRIVATE_192, IPV4_ZERO_NETWORK, IPV6_LINK_LOCAL, IPV6_UNIQUE_LOCAL, _internals28;
+var MAX_URL_LEN = 2048, IPV4_PRIVATE, IPV4_LOOPBACK, IPV4_LINK_LOCAL, IPV4_PRIVATE_172, IPV4_PRIVATE_192, IPV4_ZERO_NETWORK, IPV6_LINK_LOCAL, IPV6_UNIQUE_LOCAL, _internals29;
 var init_url_security = __esm(() => {
   IPV4_PRIVATE = /^10\./;
   IPV4_LOOPBACK = /^127\./;
@@ -53459,7 +53765,7 @@ var init_url_security = __esm(() => {
   IPV4_ZERO_NETWORK = /^0\./;
   IPV6_LINK_LOCAL = /^fe80:/i;
   IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-  _internals28 = { spawnSync: spawnSync3 };
+  _internals29 = { spawnSync: spawnSync3 };
 });
 
 // src/commands/issue.ts
@@ -53633,9 +53939,9 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals29.parseContextMd(contextContent);
+  const rawEntries = _internals30.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals29.writeSentinel(sentinelPath, 0, 0);
+    await _internals30.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -53646,10 +53952,10 @@ async function migrateContextToKnowledge(directory, config3) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals29.inferProjectName(directory);
+  const projectName = _internals30.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config3.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals29.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals30.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -53669,8 +53975,8 @@ async function migrateContextToKnowledge(directory, config3) {
     const entry = {
       id: randomUUID3(),
       tier: "swarm",
-      lesson: _internals29.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals29.inferCategoryFromText(raw.text),
+      lesson: _internals30.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals30.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -53693,7 +53999,7 @@ async function migrateContextToKnowledge(directory, config3) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals29.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals30.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -53703,7 +54009,7 @@ async function migrateContextToKnowledge(directory, config3) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config3) {
-  const legacyHivePath = _internals29.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals30.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path41.join(path41.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync27(sentinelPath)) {
@@ -53726,7 +54032,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals29.writeSentinel(sentinelPath, 0, 0);
+    await _internals30.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -53774,7 +54080,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals29.truncateLesson(lesson),
+        lesson: _internals30.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -53793,7 +54099,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
         encounter_score: 1
       };
       try {
-        await _internals29.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals30.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -53809,7 +54115,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       dropped++;
     }
   }
-  await _internals29.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals30.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -53820,7 +54126,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals29.splitIntoSections(content);
+  const sections = _internals30.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -53836,7 +54142,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals29.extractBullets(section.body);
+    const bullets = _internals30.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -53845,9 +54151,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals29.truncateLesson(bullet),
+        text: _internals30.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals29.inferCategoryFromText(bullet)
+        categoryHint: _internals30.inferCategoryFromText(bullet)
       });
     }
   }
@@ -53953,12 +54259,12 @@ function resolveLegacyHiveKnowledgePath() {
   }
   return path41.join(dataDir, "hive-knowledge.jsonl");
 }
-var _internals29;
+var _internals30;
 var init_knowledge_migrator = __esm(() => {
   init_logger();
   init_knowledge_store();
   init_knowledge_validator();
-  _internals29 = {
+  _internals30 = {
     appendKnowledge,
     migrateContextToKnowledge,
     migrateKnowledgeToExternal,
@@ -57552,9 +57858,9 @@ var init_memory2 = __esm(() => {
 
 // src/services/plan-service.ts
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals30.loadPlanJsonOnly(directory);
+  const plan = await _internals31.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals30.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals31.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -57597,7 +57903,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals30.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals31.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -57693,11 +57999,11 @@ async function handlePlanCommand(directory, args) {
   const planData = await getPlanData(directory, phaseArg);
   return formatPlanMarkdown(planData);
 }
-var _internals30;
+var _internals31;
 var init_plan_service = __esm(() => {
   init_utils2();
   init_manager();
-  _internals30 = {
+  _internals31 = {
     loadPlanJsonOnly,
     derivePlanMarkdown,
     readSwarmFileAsync
@@ -58040,7 +58346,7 @@ function formatRelativeTime(epochMs) {
   return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
 }
 async function handlePrMonitorStatusCommand(directory, _args, sessionID) {
-  const allActive = await _internals31.listActive(directory);
+  const allActive = await _internals32.listActive(directory);
   const sessionSubs = allActive.filter((record3) => record3.sessionID === sessionID);
   if (sessionSubs.length === 0) {
     return "No active PR subscriptions for this session.";
@@ -58069,10 +58375,10 @@ async function handlePrMonitorStatusCommand(directory, _args, sessionID) {
   return lines.join(`
 `);
 }
-var _internals31;
+var _internals32;
 var init_pr_monitor_status = __esm(() => {
   init_pr_subscriptions();
-  _internals31 = {
+  _internals32 = {
     formatRelativeTime,
     listActive
   };
@@ -58177,7 +58483,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const config3 = _internals32.loadPluginConfig(directory);
+    const config3 = _internals33.loadPluginConfig(directory);
     const prMonitorConfig = config3.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -58187,7 +58493,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals32.subscribe(directory, {
+    await _internals33.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -58211,12 +58517,12 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals32;
+var _internals33;
 var init_pr_subscribe = __esm(() => {
   init_pr_subscriptions();
   init_loader();
   init_pr_ref();
-  _internals32 = {
+  _internals33 = {
     loadPluginConfig,
     subscribe
   };
@@ -58240,9 +58546,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals33.parsePrRef(refToken, directory);
+  const prInfo = _internals34.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals33.looksLikePrRef(refToken)) {
+    if (_internals34.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -58263,8 +58569,8 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const correlationId = _internals33.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals33.unsubscribe(directory, correlationId);
+    const correlationId = _internals34.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals34.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -58291,11 +58597,11 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals33;
+var _internals34;
 var init_pr_unsubscribe = __esm(() => {
   init_pr_subscriptions();
   init_pr_ref();
-  _internals33 = {
+  _internals34 = {
     unsubscribe,
     buildCorrelationId,
     parsePrRef,
@@ -58699,7 +59005,7 @@ async function runAdditionalLint(linter, mode, cwd) {
     };
   }
 }
-var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals34;
+var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals35;
 var init_lint = __esm(() => {
   init_zod();
   init_discovery();
@@ -58731,15 +59037,15 @@ var init_lint = __esm(() => {
       }
       const { mode } = args;
       const cwd = directory;
-      const linter = await _internals34.detectAvailableLinter(directory);
+      const linter = await _internals35.detectAvailableLinter(directory);
       if (linter) {
-        const result = await _internals34.runLint(linter, mode, directory);
+        const result = await _internals35.runLint(linter, mode, directory);
         return JSON.stringify(result, null, 2);
       }
-      const additionalLinter = _internals34.detectAdditionalLinter(cwd);
+      const additionalLinter = _internals35.detectAdditionalLinter(cwd);
       if (additionalLinter) {
         warn(`[lint] Using ${additionalLinter} linter for this project`);
-        const result = await _internals34.runAdditionalLint(additionalLinter, mode, cwd);
+        const result = await _internals35.runAdditionalLint(additionalLinter, mode, cwd);
         return JSON.stringify(result, null, 2);
       }
       const errorResult = {
@@ -58753,7 +59059,7 @@ For Rust: rustup component add clippy`
       return JSON.stringify(errorResult, null, 2);
     }
   });
-  _internals34 = {
+  _internals35 = {
     detectAvailableLinter,
     runLint,
     detectAdditionalLinter,
@@ -59067,7 +59373,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
 }
 async function runSecretscan(directory) {
   try {
-    const result = await _internals35.secretscan.execute({ directory }, {});
+    const result = await _internals36.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -59082,7 +59388,7 @@ async function runSecretscan(directory) {
     return errorResult;
   }
 }
-var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS2, O_NOFOLLOW, secretscan, _internals35;
+var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS2, O_NOFOLLOW, secretscan, _internals36;
 var init_secretscan = __esm(() => {
   init_zod();
   init_path_security();
@@ -59454,7 +59760,7 @@ var init_secretscan = __esm(() => {
       }
     }
   });
-  _internals35 = {
+  _internals36 = {
     secretscan,
     runSecretscan
   };
@@ -60046,14 +60352,14 @@ function buildGoBackend() {
     selectEntryPoints
   };
 }
-var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals36;
+var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals37;
 var init_go = __esm(() => {
   init_default_backend();
   init_profiles();
   IMPORT_REGEX_SINGLE = /^\s*import\s+(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/gm;
   IMPORT_REGEX_GROUP = /^\s*import\s*\(([\s\S]*?)\)/gm;
   IMPORT_REGEX_GROUP_LINE = /(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/g;
-  _internals36 = { extractImports };
+  _internals37 = { extractImports };
 });
 
 // src/lang/backends/python.ts
@@ -60165,13 +60471,13 @@ function buildPythonBackend() {
     selectEntryPoints: selectEntryPoints2
   };
 }
-var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals37;
+var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals38;
 var init_python = __esm(() => {
   init_default_backend();
   init_profiles();
   IMPORT_REGEX_FROM_WITH_TARGETS = /^\s*from\s+(\.*[\w.]*)\s+import\s+(\([^)]*\)|[^\n#]+)/gm;
   IMPORT_REGEX_IMPORT = /^\s*import\s+([^\n#]+)/gm;
-  _internals37 = { extractImports: extractImports2 };
+  _internals38 = { extractImports: extractImports2 };
 });
 
 // src/test-impact/analyzer.ts
@@ -60395,7 +60701,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (PYTHON_EXTENSIONS.has(ext)) {
-    const modules = _internals37.extractImports(testFile, content);
+    const modules = _internals38.extractImports(testFile, content);
     for (const mod of modules) {
       const resolved = resolvePythonImport(testDir, mod);
       if (resolved !== null)
@@ -60404,7 +60710,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (GO_EXTENSIONS.has(ext)) {
-    const imports = _internals36.extractImports(testFile, content);
+    const imports = _internals37.extractImports(testFile, content);
     for (const importPath of imports) {
       const sourceFiles = resolveGoImport(testDir, importPath);
       for (const source of sourceFiles)
@@ -60431,8 +60737,8 @@ async function buildImpactMapInternal(cwd) {
   return impactMap;
 }
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals38.buildImpactMapInternal(cwd);
-  await _internals38.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals39.buildImpactMapInternal(cwd);
+  await _internals39.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
@@ -60446,7 +60752,7 @@ async function loadImpactMap(cwd, options) {
         const hasValidValues = Object.values(map3).every((v) => Array.isArray(v) && v.every((item) => typeof item === "string"));
         if (hasValidValues) {
           const generatedAt = new Date(data.generatedAt).getTime();
-          if (!_internals38.isCacheStale(map3, generatedAt)) {
+          if (!_internals39.isCacheStale(map3, generatedAt)) {
             return map3;
           }
           if (options?.skipRebuild) {
@@ -60466,13 +60772,13 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals38.buildImpactMap(cwd);
+  return _internals39.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
   if (!path53.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals38.validateProjectRoot(cwd);
+  _internals39.validateProjectRoot(cwd);
   const cacheDir2 = path53.join(cwd, ".swarm", "cache");
   const cachePath = path53.join(cacheDir2, "impact-map.json");
   if (!fs23.existsSync(cacheDir2)) {
@@ -60496,7 +60802,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals38.loadImpactMap(cwd);
+  const impactMap = await _internals39.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -60581,7 +60887,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     budgetExceeded
   };
 }
-var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals38;
+var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals39;
 var init_analyzer = __esm(() => {
   init_manager2();
   init_go();
@@ -60594,7 +60900,7 @@ var init_analyzer = __esm(() => {
   GO_EXTENSIONS = new Set([".go"]);
   EXTENSIONS_TO_TRY = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
   goModuleCache = new Map;
-  _internals38 = {
+  _internals39 = {
     validateProjectRoot,
     normalizePath,
     isCacheStale,
@@ -60977,7 +61283,7 @@ function batchAppendTestRuns(records, workingDir) {
   }
   const historyPath = getHistoryPath(workingDir);
   const historyDir = path54.dirname(historyPath);
-  _internals39.validateProjectRoot(workingDir);
+  _internals40.validateProjectRoot(workingDir);
   if (!fs24.existsSync(historyDir)) {
     fs24.mkdirSync(historyDir, { recursive: true });
   }
@@ -61100,7 +61406,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, HISTORY_WRITE_LOCK_TIMEOUT_MS = 5000, HISTORY_WRITE_LOCK_STALE_MS = 60000, HISTORY_WRITE_LOCK_BACKOFF_MS = 10, DANGEROUS_PROPERTY_NAMES, _internals39;
+var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, HISTORY_WRITE_LOCK_TIMEOUT_MS = 5000, HISTORY_WRITE_LOCK_STALE_MS = 60000, HISTORY_WRITE_LOCK_BACKOFF_MS = 10, DANGEROUS_PROPERTY_NAMES, _internals40;
 var init_history_store = __esm(() => {
   init_manager2();
   DANGEROUS_PROPERTY_NAMES = new Set([
@@ -61108,7 +61414,7 @@ var init_history_store = __esm(() => {
     "constructor",
     "prototype"
   ]);
-  _internals39 = {
+  _internals40 = {
     validateProjectRoot
   };
 });
@@ -61313,7 +61619,7 @@ function readPackageJsonRaw(dir) {
   }
 }
 function readPackageJson(dir) {
-  return _internals40.readPackageJsonRaw(dir);
+  return _internals41.readPackageJsonRaw(dir);
 }
 function readPackageJsonTestScript(dir) {
   return readPackageJson(dir)?.scripts?.test ?? null;
@@ -61483,7 +61789,7 @@ function buildTypescriptBackend() {
     selectEntryPoints: selectEntryPoints3
   };
 }
-var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals40;
+var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals41;
 var init_typescript = __esm(() => {
   init_default_backend();
   init_profiles();
@@ -61492,7 +61798,7 @@ var init_typescript = __esm(() => {
   IMPORT_REGEX_REQUIRE2 = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_DYNAMIC = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_REEXPORT2 = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
-  _internals40 = {
+  _internals41 = {
     readPackageJsonRaw,
     readPackageJsonTestScript,
     frameworkFromScriptsTest
@@ -61525,7 +61831,7 @@ __export(exports_dispatch, {
   pickedProfiles: () => pickedProfiles,
   pickBackend: () => pickBackend,
   clearDispatchCache: () => clearDispatchCache,
-  _internals: () => _internals41
+  _internals: () => _internals42
 });
 import * as fs28 from "fs";
 import * as path58 from "path";
@@ -61580,7 +61886,7 @@ function findManifestRoot(start) {
   return start;
 }
 function evictIfNeeded() {
-  if (cache.size <= _internals41.cacheCapacity)
+  if (cache.size <= _internals42.cacheCapacity)
     return;
   let oldestKey;
   let oldestOrder = Infinity;
@@ -61611,7 +61917,7 @@ async function pickBackend(dir) {
     evictIfNeeded();
     return null;
   }
-  const profiles = await _internals41.detectProjectLanguages(root);
+  const profiles = await _internals42.detectProjectLanguages(root);
   if (profiles.length === 0) {
     cache.set(cacheKey, {
       hash: hash4,
@@ -61643,12 +61949,12 @@ function clearDispatchCache() {
   manifestRootCache.clear();
   insertCounter = 0;
 }
-var _internals41, cache, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
+var _internals42, cache, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
 var init_dispatch = __esm(() => {
   init_backends();
   init_detector();
   init_registry_backend();
-  _internals41 = {
+  _internals42 = {
     detectProjectLanguages,
     cacheCapacity: 64
   };
@@ -63504,9 +63810,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals42.getPackageVersion(dir);
-    const changelogVersion = _internals42.getChangelogVersion(dir);
-    const versionFileVersion = _internals42.getVersionFileVersion(dir);
+    const packageVersion = _internals43.getPackageVersion(dir);
+    const changelogVersion = _internals43.getChangelogVersion(dir);
+    const versionFileVersion = _internals43.getVersionFileVersion(dir);
     const versions3 = [];
     if (packageVersion)
       versions3.push(`package.json: ${packageVersion}`);
@@ -63870,7 +64176,7 @@ async function runPreflight(dir, phase, config3) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals42.validateDirectoryPath(dir);
+    validatedDir = _internals43.validateDirectoryPath(dir);
   } catch (error93) {
     return {
       id: reportId,
@@ -63890,7 +64196,7 @@ async function runPreflight(dir, phase, config3) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals42.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals43.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error93) {
     return {
       id: reportId,
@@ -63931,12 +64237,12 @@ async function runPreflight(dir, phase, config3) {
   });
   const checks5 = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals42.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals43.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks5.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals42.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals43.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks5.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -63948,7 +64254,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals42.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals43.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -63960,7 +64266,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals42.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals43.runEvidenceCheck(validatedDir);
     checks5.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -63971,12 +64277,12 @@ async function runPreflight(dir, phase, config3) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals42.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals43.runRequirementCoverageCheck(validatedDir, phase);
   checks5.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals42.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals43.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -64039,10 +64345,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals42.runPreflight(directory, phase);
-  return _internals42.formatPreflightMarkdown(report);
+  const report = await _internals43.runPreflight(directory, phase);
+  return _internals43.formatPreflightMarkdown(report);
 }
-var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals42;
+var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals43;
 var init_preflight_service = __esm(() => {
   init_gate_bridge();
   init_manager2();
@@ -64061,7 +64367,7 @@ var init_preflight_service = __esm(() => {
     testScope: "convention",
     linter: "biome"
   };
-  _internals42 = {
+  _internals43 = {
     runPreflight,
     formatPreflightMarkdown,
     handlePreflightCommand,
@@ -65486,7 +65792,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals22.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals23.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -65856,7 +66162,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals43.hasActiveLeanTurbo();
+  const leanActive = _internals44.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -65875,7 +66181,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals43.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals44.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -65907,7 +66213,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals43.hasActiveFullAuto();
+  status.fullAutoActive = _internals44.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -66035,7 +66341,7 @@ async function countProposals(directory) {
     return 0;
   }
 }
-var _internals43;
+var _internals44;
 var init_status_service = __esm(() => {
   init_extractors();
   init_knowledge_escalator();
@@ -66045,7 +66351,7 @@ var init_status_service = __esm(() => {
   init_state3();
   init_compaction_service();
   init_context_budget_service();
-  _internals43 = {
+  _internals44 = {
     loadLeanTurboRunState,
     hasActiveLeanTurbo,
     hasActiveFullAuto
@@ -66136,7 +66442,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config: config3 } = _internals44.loadPluginConfigWithMeta(directory);
+      const { config: config3 } = _internals45.loadPluginConfigWithMeta(directory);
       if (config3.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -66191,7 +66497,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config: config3 } = _internals44.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals45.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -66261,13 +66567,13 @@ function buildStatusMessage2(session, directory, sessionID) {
   ].join(`
 `);
 }
-var _internals44;
+var _internals45;
 var init_turbo = __esm(() => {
   init_config();
   init_state();
   init_state3();
   init_logger();
-  _internals44 = {
+  _internals45 = {
     loadPluginConfigWithMeta
   };
 });
@@ -66333,342 +66639,6 @@ var init_write_retro2 = __esm(() => {
   init_write_retro();
 });
 
-// src/commands/command-dispatch.ts
-function normalizeSwarmCommandInput(command, argumentText) {
-  if (command !== "swarm" && !command.startsWith("swarm-")) {
-    return { isSwarmCommand: false, tokens: [] };
-  }
-  if (command === "swarm") {
-    return {
-      isSwarmCommand: true,
-      tokens: argumentText.trim().split(/\s+/).filter(Boolean)
-    };
-  }
-  const subcommand = command.slice("swarm-".length);
-  const extraArgs = argumentText.trim().split(/\s+/).filter(Boolean);
-  return {
-    isSwarmCommand: true,
-    tokens: [subcommand, ...extraArgs].filter(Boolean)
-  };
-}
-function canonicalCommandKey(resolved) {
-  return resolved.entry.aliasOf ?? resolved.key;
-}
-function formatCommandNotFound(tokens) {
-  const attemptedCommand = tokens[0] || "";
-  const MAX_DISPLAY = 100;
-  const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals45.findSimilarCommands(attemptedCommand);
-  const header = `Command \`/swarm ${displayCommand}\` not found.`;
-  const suggestions = similar.length > 0 ? `Did you mean:
-${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
-`)}` : "";
-  const footer = "Run `/swarm help` for all commands.";
-  return [header, suggestions, footer].filter(Boolean).join(`
-
-`);
-}
-async function executeSwarmCommand(args) {
-  const {
-    directory,
-    agents,
-    sessionID,
-    tokens,
-    packageRoot,
-    buildHelpText,
-    policy
-  } = args;
-  let text;
-  const resolved = resolveCommand(tokens);
-  if (!resolved) {
-    text = tokens.length === 0 && buildHelpText ? buildHelpText() : formatCommandNotFound(tokens);
-  } else {
-    const policyResult = policy?.(resolved) ?? { allowed: true };
-    if (!policyResult.allowed) {
-      text = policyResult.message;
-    } else {
-      try {
-        text = await resolved.entry.handler({
-          directory,
-          args: resolved.remainingArgs,
-          sessionID,
-          agents,
-          packageRoot,
-          source: "chat"
-        });
-      } catch (_err) {
-        const cmdName = tokens[0] || "unknown";
-        const errMsg = _err instanceof Error ? _err.message : String(_err);
-        text = `Error executing /swarm ${cmdName}: ${errMsg}`;
-      }
-      if (resolved.warning) {
-        text = `${resolved.warning}
-
-${text}`;
-      }
-    }
-  }
-  return {
-    text,
-    resolved: resolved ?? undefined,
-    canonicalKey: resolved ? canonicalCommandKey(resolved) : undefined
-  };
-}
-var init_command_dispatch = __esm(() => {
-  init_registry();
-});
-
-// src/commands/tool-policy.ts
-function classifySwarmCommandToolUse(resolved) {
-  const canonicalKey = canonicalCommandKey(resolved);
-  const args = resolved.remainingArgs;
-  if (!SWARM_COMMAND_TOOL_ALLOWLIST.has(canonicalKey)) {
-    if (HUMAN_ONLY_SWARM_COMMANDS.has(canonicalKey)) {
-      return {
-        allowed: false,
-        message: `/swarm ${canonicalKey} is a human-only command. ` + `Present the situation to the user and ask them to run \`/swarm ${canonicalKey}\` themselves ` + `(or \`bunx opencode-swarm run ${canonicalKey}\` from a terminal). ` + `You MUST NOT run it yourself via Bash, swarm_command, or any other tool \u2014 ` + `the runtime guardrail will block such attempts.`
-      };
-    }
-    return {
-      allowed: false,
-      message: `/swarm ${canonicalKey} is not available through the chat tool yet.
-
-` + `Use the canonical CLI path for now: \`bunx opencode-swarm run ${canonicalKey}\`.
-` + `Commands with state changes, auto-heal behavior, or subprocesses need confirmation gates before chat-tool support.`
-    };
-  }
-  if (canonicalKey === "config doctor" && args.some((arg) => arg === "--fix" || arg === "-f")) {
-    return {
-      allowed: false,
-      message: "/swarm config doctor --fix is not available through swarm_command. Run the CLI command directly when you intend to modify config files."
-    };
-  }
-  if (NO_ARGS.has(canonicalKey) && args.length > 0) {
-    return {
-      allowed: false,
-      message: `/swarm ${canonicalKey} does not accept arguments through swarm_command.`
-    };
-  }
-  if (canonicalKey === "knowledge") {
-    if (args.length === 0)
-      return { allowed: true };
-    if (args.length === 1 && (args[0] === "list" || args[0] === "unactionable"))
-      return { allowed: true };
-    return {
-      allowed: false,
-      message: "Only `/swarm knowledge`, `/swarm knowledge list`, and `/swarm knowledge unactionable` are available through swarm_command. Knowledge migrate/quarantine/restore/retry-hardening are intentionally excluded."
-    };
-  }
-  if (canonicalKey === "memory") {
-    if (args.length === 0)
-      return { allowed: true };
-    return {
-      allowed: false,
-      message: "Use `/swarm memory status`, `/swarm memory pending`, `/swarm memory recall-log`, `/swarm memory stale`, `/swarm memory export`, or `/swarm memory evaluate --json` through swarm_command. Memory import, migrate, and compact are intentionally excluded from chat-tool execution."
-    };
-  }
-  if (canonicalKey === "memory evaluate") {
-    if (args.length === 0)
-      return { allowed: true };
-    if (args.length === 1 && args[0] === "--json")
-      return { allowed: true };
-    return {
-      allowed: false,
-      message: "Usage through swarm_command: `/swarm memory evaluate --json`. Custom fixture directories are only available through direct user command execution."
-    };
-  }
-  if (canonicalKey === "sdd status") {
-    if (args.length === 0)
-      return { allowed: true };
-    if (args.length === 1 && args[0] === "--json")
-      return { allowed: true };
-    return {
-      allowed: false,
-      message: "Usage through swarm_command: `/swarm sdd status` or `/swarm sdd status --json`."
-    };
-  }
-  if (canonicalKey === "sdd validate") {
-    if (args.length === 0)
-      return { allowed: true };
-    if (args.length === 1 && args[0] === "--json")
-      return { allowed: true };
-    if (args.length === 2 && args[0] === "--change" && /^[A-Za-z0-9_.-]{1,128}$/.test(args[1])) {
-      return { allowed: true };
-    }
-    return {
-      allowed: false,
-      message: "Usage through swarm_command: `/swarm sdd validate`, `/swarm sdd validate --json`, or `/swarm sdd validate --change <id>`."
-    };
-  }
-  if (canonicalKey === "memory pending" || canonicalKey === "memory recall-log" || canonicalKey === "memory stale") {
-    if (args.length === 0)
-      return { allowed: true };
-    if (args.length === 2 && args[0] === "--limit" && /^\d+$/.test(args[1])) {
-      return { allowed: true };
-    }
-    return {
-      allowed: false,
-      message: `Usage through swarm_command: \`/swarm ${canonicalKey}\` or ` + `\`/swarm ${canonicalKey} --limit <n>\`.`
-    };
-  }
-  if (canonicalKey === "retrieve") {
-    if (args.length !== 1 || !SUMMARY_ID_PATTERN.test(args[0])) {
-      return {
-        allowed: false,
-        message: "Usage through swarm_command: `/swarm retrieve <summary-id>` with a single summary ID such as S1."
-      };
-    }
-  }
-  if (canonicalKey === "benchmark") {
-    const allowedFlags = new Set(["--cumulative", "--ci-gate"]);
-    const invalid = args.filter((arg) => !allowedFlags.has(arg));
-    if (invalid.length > 0) {
-      return {
-        allowed: false,
-        message: "Only `--cumulative` and `--ci-gate` are supported for `/swarm benchmark` through swarm_command."
-      };
-    }
-  }
-  if (canonicalKey === "show-plan") {
-    if (args.length > 1 || args[0] && !/^\d+$/.test(args[0])) {
-      return {
-        allowed: false,
-        message: "Usage through swarm_command: `/swarm show-plan` or `/swarm show-plan <phase-number>`."
-      };
-    }
-  }
-  if (canonicalKey === "evidence") {
-    if (args.length > 1 || args[0] && !TASK_ID_PATTERN.test(args[0])) {
-      return {
-        allowed: false,
-        message: "Usage through swarm_command: `/swarm evidence` or `/swarm evidence <task-id>`."
-      };
-    }
-  }
-  if (canonicalKey === "help" && args.length > 2) {
-    return {
-      allowed: false,
-      message: "Usage through swarm_command: `/swarm help` or `/swarm help <command>`."
-    };
-  }
-  return { allowed: true };
-}
-function classifySwarmCommandChatFallbackUse(resolved) {
-  const canonicalKey = canonicalCommandKey(resolved);
-  const args = resolved.remainingArgs;
-  if (canonicalKey === "config doctor" && args.some((arg) => arg === "--fix" || arg === "-f")) {
-    return {
-      allowed: false,
-      message: "/swarm config doctor --fix is not available through chat fallback because it can modify configuration files. Run the CLI command directly when you intend to apply fixes."
-    };
-  }
-  if (canonicalKey === "knowledge migrate" || canonicalKey === "knowledge quarantine" || canonicalKey === "knowledge restore" || canonicalKey === "memory import" || canonicalKey === "memory migrate" || canonicalKey === "memory compact" || canonicalKey === "sdd project") {
-    return {
-      allowed: false,
-      message: `/swarm ${canonicalKey} is not available through chat fallback because it mutates .swarm state. ` + "Run the CLI command directly after confirming the intended state change."
-    };
-  }
-  return { allowed: true };
-}
-var SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, NO_ARGS, SUMMARY_ID_PATTERN, TASK_ID_PATTERN;
-var init_tool_policy = __esm(() => {
-  init_command_dispatch();
-  SWARM_COMMAND_TOOL_COMMANDS = [
-    "agents",
-    "config",
-    "config doctor",
-    "doctor tools",
-    "status",
-    "show-plan",
-    "help",
-    "history",
-    "evidence",
-    "evidence summary",
-    "retrieve",
-    "diagnose",
-    "preflight",
-    "benchmark",
-    "knowledge",
-    "memory",
-    "memory status",
-    "memory pending",
-    "memory recall-log",
-    "memory compact",
-    "memory stale",
-    "memory export",
-    "memory evaluate",
-    "memory import",
-    "memory migrate",
-    "sdd",
-    "sdd status",
-    "sdd validate",
-    "sdd project",
-    "sync-plan",
-    "export",
-    "auto-proceed"
-  ];
-  SWARM_COMMAND_TOOL_ALLOWLIST = new Set([
-    "agents",
-    "config",
-    "config doctor",
-    "doctor tools",
-    "status",
-    "show-plan",
-    "help",
-    "history",
-    "evidence",
-    "evidence summary",
-    "retrieve",
-    "diagnose",
-    "preflight",
-    "benchmark",
-    "knowledge",
-    "memory",
-    "memory status",
-    "memory pending",
-    "memory recall-log",
-    "memory stale",
-    "memory export",
-    "memory evaluate",
-    "sdd",
-    "sdd status",
-    "sdd validate",
-    "sync-plan",
-    "export",
-    "auto-proceed"
-  ]);
-  HUMAN_ONLY_SWARM_COMMANDS = new Set([
-    "acknowledge-spec-drift",
-    "reset",
-    "reset-session",
-    "rollback",
-    "checkpoint",
-    "consolidate",
-    "memory import",
-    "memory migrate",
-    "memory compact",
-    "sdd project"
-  ]);
-  NO_ARGS = new Set([
-    "agents",
-    "config",
-    "config doctor",
-    "doctor tools",
-    "status",
-    "history",
-    "evidence summary",
-    "diagnose",
-    "preflight",
-    "sync-plan",
-    "export",
-    "memory",
-    "memory status",
-    "memory export"
-  ]);
-  SUMMARY_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
-  TASK_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,64}$/;
-});
-
 // src/commands/command-names.ts
 var COMMAND_NAMES, COMMAND_NAME_SET;
 var init_command_names = __esm(() => {
@@ -66886,7 +66856,7 @@ async function buildSwarmCommandPrompt(args) {
     packageRoot,
     registeredAgents
   } = args;
-  const resolved = _internals45.resolveCommand(tokens);
+  const resolved = _internals11.resolveCommand(tokens);
   if (!resolved) {
     if (tokens.length === 0) {
       return buildHelpText();
@@ -67059,7 +67029,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals45.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals11.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -67072,7 +67042,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals45.levenshteinDistance(qt, ct);
+          const dist = _internals11.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -67082,7 +67052,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals45.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals11.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -67114,11 +67084,11 @@ async function handleHelpCommand(ctx) {
     return buildHelpText2();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals45.resolveCommand(tokens);
+  const resolved = _internals11.resolveCommand(tokens);
   if (resolved) {
-    return _internals45.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals11.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals45.findSimilarCommands(targetCommand);
+  const similar = _internals11.findSimilarCommands(targetCommand);
   const { buildHelpText: fullHelp } = await Promise.resolve().then(() => (init_commands(), exports_commands));
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
@@ -67189,6 +67159,18 @@ function validateAliases() {
   }
   return { valid: errors5.length === 0, errors: errors5, warnings };
 }
+function validateToolPolicy() {
+  const warnings = [];
+  for (const [name, entry] of Object.entries(COMMAND_REGISTRY)) {
+    const cmdEntry = entry;
+    if (cmdEntry.aliasOf || cmdEntry.subcommandOf)
+      continue;
+    if (cmdEntry.toolPolicy === undefined) {
+      warnings.push(`Command '${name}' has no toolPolicy field \u2014 it will not be available through the swarm_command tool. Add toolPolicy: 'agent' | 'human-only' | 'restricted' | 'none'.`);
+    }
+  }
+  return { valid: warnings.length === 0, warnings };
+}
 function resolveCommand(tokens) {
   if (tokens.length === 0)
     return null;
@@ -67218,7 +67200,7 @@ function resolveCommand(tokens) {
   }
   return null;
 }
-var COMMAND_REGISTRY, VALID_COMMANDS, _internals45, validation;
+var COMMAND_REGISTRY, VALID_COMMANDS, _internals11, validation;
 var init_registry = __esm(() => {
   init_bundled_skills();
   init_acknowledge_spec_drift();
@@ -67274,19 +67256,23 @@ var init_registry = __esm(() => {
       handler: (ctx) => handleAcknowledgeSpecDriftCommand(ctx.directory, ctx.args, ctx.source === "cli" ? "cli" : ctx.source === "chat" ? "user" : "unknown"),
       description: "Acknowledge that the spec has drifted from the plan and suppress further warnings",
       args: "",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "restricted"
     },
     status: {
       handler: (ctx) => handleStatusCommand(ctx.directory, ctx.agents),
       description: "Show current swarm state",
       category: "core",
-      clashesWithNativeCcCommand: "/status"
+      clashesWithNativeCcCommand: "/status",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "show-plan": {
       handler: (ctx) => handlePlanCommand(ctx.directory, ctx.args),
       description: "Show current plan (optionally filter by phase number)",
       category: "core",
-      args: "[phase-number]"
+      args: "[phase-number]",
+      toolPolicy: "agent"
     },
     plan: {
       handler: (ctx) => handlePlanCommand(ctx.directory, ctx.args),
@@ -67300,32 +67286,41 @@ var init_registry = __esm(() => {
       handler: (ctx) => Promise.resolve(handleAgentsCommand(ctx.agents, undefined)),
       description: "List registered agents",
       category: "core",
-      clashesWithNativeCcCommand: "/agents"
+      clashesWithNativeCcCommand: "/agents",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     help: {
-      handler: (ctx) => _internals45.handleHelpCommand(ctx),
+      handler: (ctx) => _internals11.handleHelpCommand(ctx),
       description: "Show help for swarm commands",
       category: "core",
       args: "[command]",
-      details: "Without argument, shows full command listing. With argument, shows detailed help for a specific command."
+      details: "Without argument, shows full command listing. With argument, shows detailed help for a specific command.",
+      toolPolicy: "agent"
     },
     history: {
       handler: (ctx) => handleHistoryCommand(ctx.directory, ctx.args),
       description: "Show completed phases summary",
       category: "utility",
-      clashesWithNativeCcCommand: "/history"
+      clashesWithNativeCcCommand: "/history",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     config: {
       handler: (ctx) => handleConfigCommand(ctx.directory, ctx.args),
       description: "Show current resolved configuration",
       category: "config",
-      clashesWithNativeCcCommand: "/config"
+      clashesWithNativeCcCommand: "/config",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "config doctor": {
       handler: (ctx) => handleDoctorCommand(ctx.directory, ctx.args),
       description: "Run config doctor checks",
       subcommandOf: "config",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "config-doctor": {
       handler: (ctx) => handleDoctorCommand(ctx.directory, ctx.args),
@@ -67338,7 +67333,9 @@ var init_registry = __esm(() => {
     "doctor tools": {
       handler: (ctx) => handleDoctorToolsCommand(ctx.directory, ctx.args),
       description: "Run tool registration coherence check",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "doctor-tools": {
       handler: (ctx) => handleDoctorToolsCommand(ctx.directory, ctx.args),
@@ -67350,7 +67347,9 @@ var init_registry = __esm(() => {
     diagnose: {
       handler: (ctx) => handleDiagnoseCommand(ctx.directory, ctx.args),
       description: "Run health check on swarm state",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     diagnosis: {
       handler: (ctx) => handleDiagnoseCommand(ctx.directory, ctx.args),
@@ -67362,26 +67361,32 @@ var init_registry = __esm(() => {
     preflight: {
       handler: (ctx) => handlePreflightCommand(ctx.directory, ctx.args),
       description: "Run preflight automation checks",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "sync-plan": {
       handler: (ctx) => handleSyncPlanCommand(ctx.directory, ctx.args),
       description: "Ensure plan.json and plan.md are synced",
       args: "",
-      category: "config"
+      category: "config",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     benchmark: {
       handler: (ctx) => handleBenchmarkCommand(ctx.directory, ctx.args),
       description: "Show performance metrics [--cumulative] [--ci-gate]",
       args: "--cumulative, --ci-gate",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent"
     },
     learning: {
       handler: (ctx) => handleLearningCommand(ctx.directory, ctx.args),
       description: "Show learning metrics and violation trends",
       args: "--json, --phase <N>",
       details: "Computes aggregate learning metrics from knowledge events: violation-rate trends, directive application rates, escalation frequency, per-entry ROI, and never-applied entries. Surfaces a learning summary for the curator digest.",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent"
     },
     export: {
       handler: (ctx) => handleExportCommand(ctx.directory, ctx.args),
@@ -67389,14 +67394,17 @@ var init_registry = __esm(() => {
       args: "",
       details: "Exports the current plan and context as JSON to stdout. Useful for piping to external tools or debugging swarm state.",
       category: "utility",
-      clashesWithNativeCcCommand: "/export"
+      clashesWithNativeCcCommand: "/export",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     evidence: {
       handler: (ctx) => handleEvidenceCommand(ctx.directory, ctx.args),
       description: "Show evidence bundles [taskId]",
       args: "<taskId>",
       details: 'Displays review results, test verdicts, and other evidence bundles for the given task ID (e.g., "2.1").',
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent"
     },
     "evidence summary": {
       handler: (ctx) => handleEvidenceSummaryCommand(ctx.directory),
@@ -67404,7 +67412,9 @@ var init_registry = __esm(() => {
       subcommandOf: "evidence",
       args: "",
       details: "Generates a summary showing completion ratio across all tasks, lists blockers, and identifies missing evidence.",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "evidence-summary": {
       handler: (ctx) => handleEvidenceSummaryCommand(ctx.directory),
@@ -67464,13 +67474,15 @@ var init_registry = __esm(() => {
       description: "Archive old evidence bundles [--dry-run]",
       details: "Archives evidence bundles older than max_age_days (config, default 90) or beyond max_bundles cap (config, default 1000). --dry-run previews which bundles would be archived without deleting them. Applies two-tier retention: age-based first, then count-based on oldest remaining.",
       args: "--dry-run",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "none"
     },
     curate: {
       handler: (ctx) => handleCurateCommand(ctx.directory, ctx.args),
       description: "Run knowledge curation and hive promotion review",
       args: "",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "none"
     },
     consolidate: {
       handler: (ctx) => handleConsolidateCommand(ctx.directory, ctx.args, {
@@ -67479,13 +67491,15 @@ var init_registry = __esm(() => {
       description: "Run quota-bounded skill-improver consolidation and stage skill proposals",
       details: "Runs the same consolidation pass used by scheduled skill_improver trigger points: queue hardening, skill-improver proposal writing, and optional draft-skill generation. It never auto-activates skills. Use --respect-interval to obey the configured cadence instead of forcing a run.",
       args: "--force, --respect-interval, --evaluate",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "restricted"
     },
     "dark-matter": {
       handler: (ctx) => handleDarkMatterCommand(ctx.directory, ctx.args),
       description: "Detect hidden file couplings via co-change NPMI analysis",
       args: "--threshold <number>, --min-commits <number>",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "none"
     },
     finalize: {
       handler: (ctx) => handleCloseCommand(ctx.directory, ctx.args, {
@@ -67494,7 +67508,8 @@ var init_registry = __esm(() => {
       description: "Use /swarm finalize to finalize the swarm project and archive evidence",
       details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs safe git ff-only to main. Resets agent sessions and delegation chains. Reads .swarm/close-lessons.md for explicit lessons and runs curation. Use --skill-review to run the quota-bounded skill_improver in proposal mode.",
       args: "--prune-branches, --skill-review",
-      category: "core"
+      category: "core",
+      toolPolicy: "none"
     },
     close: {
       handler: (ctx) => handleCloseCommand(ctx.directory, ctx.args, {
@@ -67514,7 +67529,8 @@ var init_registry = __esm(() => {
       description: "Run the post-mortem agent: project-end synthesis, queue triage, and final curation pass",
       details: "Reads .swarm/ evidence (knowledge entries, events, curator digests, proposals, retrospectives, drift reports) and produces a post-mortem report at .swarm/post-mortem-{planId}.md. Idempotent: re-runs skip if report exists unless --force is passed.",
       args: "--force",
-      category: "core"
+      category: "core",
+      toolPolicy: "agent"
     },
     concurrency: {
       handler: (ctx) => handleConcurrencyCommand(ctx.directory, ctx.args, ctx.sessionID),
@@ -67531,115 +67547,133 @@ Subcommands:
 ` + `  concurrency reset             \u2014 Clear the session concurrency override
 ` + `
 ` + "Session-scoped \u2014 resets on new session.",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "none"
     },
     simulate: {
       handler: (ctx) => handleSimulateCommand(ctx.directory, ctx.args),
       description: "Dry-run hidden coupling analysis with configurable thresholds",
       args: "--threshold <number>, --min-commits <number>",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "none"
     },
     sdd: {
       handler: (ctx) => handleSddCommand(ctx.directory, ctx.args),
       description: "Manage OpenSpec-compatible SDD artifacts and effective spec projection",
       args: "status|validate|project [--json] [--change <id>] [--dry-run]",
       details: "Parent command for spec-driven development artifacts. Use sdd status to inspect .swarm/spec.md plus openspec/ artifacts, sdd validate to validate OpenSpec-compatible deltas, and sdd project to materialize the effective spec into .swarm/spec.md for planning.",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent"
     },
     "sdd status": {
       handler: (ctx) => handleSddStatusCommand(ctx.directory, ctx.args),
       description: "Show OpenSpec-compatible SDD status and effective spec source",
       subcommandOf: "sdd",
       args: "[--json]",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent"
     },
     "sdd validate": {
       handler: (ctx) => handleSddValidateCommand(ctx.directory, ctx.args),
       description: "Validate OpenSpec-compatible artifacts and effective spec projection",
       subcommandOf: "sdd",
       args: "[--json] [--change <id>]",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent"
     },
     "sdd project": {
       handler: (ctx) => handleSddProjectCommand(ctx.directory, ctx.args),
       description: "Materialize the OpenSpec-compatible effective spec into .swarm/spec.md",
       subcommandOf: "sdd",
       args: "[--dry-run] [--json] [--change <id>]",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "human-only"
     },
     analyze: {
       handler: (ctx) => handleAnalyzeCommand(ctx.directory, ctx.args),
       description: "Analyze spec.md vs plan.md for requirement coverage gaps",
       args: "",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     clarify: {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleClarifyCommand),
       description: "Clarify and refine an existing feature specification",
       args: "[description-text]",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     specify: {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleSpecifyCommand),
       description: "Generate or import a feature specification [description]",
       args: "[description-text]",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     brainstorm: {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleBrainstormCommand),
       description: "Enter architect MODE: BRAINSTORM \u2014 structured seven-phase planning workflow [topic]",
       args: "[topic-text]",
       details: "Triggers the architect to run the brainstorm workflow: CONTEXT SCAN, single-question DIALOGUE, APPROACHES, DESIGN SECTIONS, SPEC WRITE + SELF-REVIEW, QA GATE SELECTION, TRANSITION. Use for new plans where requirements need to be drawn out before writing spec.md / plan.md.",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     council: {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleCouncilCommand),
       description: "Enter architect MODE: COUNCIL \u2014 multi-model deliberation [question] [--preset <name>] [--spec-review]",
       args: "<question> [--preset <name>] [--spec-review]",
       details: "Triggers the architect to convene a three-agent General Council: Generalist (reviewer model), Skeptic (critic model), and Domain Expert (SME model). Use --preset <name> to choose a named member preset from council.general.presets. " + "The architect first runs 1\u20133 targeted web searches and passes a compiled RESEARCH CONTEXT " + "to all three agents before dispatching them in parallel. Agents deliberate using the NSED peer-review protocol (Round 1 independent analysis, Round 2 MAINTAIN/CONCEDE/NUANCE for disagreements). The architect synthesizes the final answer directly from convene_general_council output. --spec-review switches to single-pass advisory mode for spec review. Requires council.general.enabled: true and a search API key in the resolved config: global ~/.config/opencode/opencode-swarm.json, then project .opencode/opencode-swarm.json overrides.",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     "pr-review": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handlePrReviewCommand),
       description: "Launch deep PR review with multi-lane analysis [url] [--council]",
       args: "<pr-url|owner/repo#N|N> [--council]",
       details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, runs 6 parallel explorer lanes through the deterministic dispatch_lanes join barrier (correctness, security, dependencies, docs-intent-vs-actual, tests, performance-architecture), validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, synthesizes structured report. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     "pr-feedback": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handlePrFeedbackCommand),
       description: "Ingest and close known PR feedback (review comments, CI failures, conflicts) [pr] [instructions]",
       args: "[url|owner/repo#N|N] [instructions...]",
       details: "Triggers MODE: PR_FEEDBACK \u2014 ingests existing pull-request feedback (review threads, requested changes, CI/check failures, merge conflicts, stale branch state, pasted notes), verifies every claim against source, clusters related problems, fixes confirmed items, validates the branch, and reports closure status for every ledger item. Distinct from /swarm pr-review, which discovers new findings. The PR reference is optional: with none, the architect builds the ledger from the current PR/branch; text after the reference is forwarded as extra instructions. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolved against origin).",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     "pr subscribe": {
       handler: (ctx) => handlePrSubscribeCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "Subscribe the current session to PR state-change notifications",
       args: "<pr-url|owner/repo#N|N>",
       details: "Subscribes the current session to receive advisory notifications for the specified PR. When pr_monitor.enabled is true, the background polling worker will detect CI failures, new comments, merge conflicts, review state changes, and merge/close events. Notifications are delivered as session-scoped advisories with dedup tokens. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolved against origin). Requires pr_monitor.enabled: true in config.",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "human-only"
     },
     "pr unsubscribe": {
       handler: (ctx) => handlePrUnsubscribeCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "Unsubscribe the current session from PR state-change notifications",
       args: "<pr-url|owner/repo#N|N>",
       details: "Unsubscribes the current session from receiving advisory notifications for the specified PR. Removes the active subscription record. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolved against origin).",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "human-only"
     },
     "pr status": {
       handler: (ctx) => handlePrMonitorStatusCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "Show PR monitor subscription status for the current session",
       args: "",
       details: "Displays all active PR subscriptions for the current session. Shows PR URL, last checked time, watching status, and error count per subscription. Also shows total active subscriptions across all sessions.",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "deep-dive": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleDeepDiveCommand),
       description: "Launch deep codebase audit with parallel explorer waves, dual reviewers, and critic challenge [scope]",
       args: "<scope> [--profile standard|security|ux|architecture|full] [--max-explorers 1..8] [--json] [--skip-update] [--allow-dirty]",
       details: "Runs a read-only deep audit of the specified scope using parallel explorer waves (8-file cap per mission, ~3500 line guardrail), always 2 parallel reviewers for verification, and sequential critic challenge on HIGH/CRITICAL findings. Profiles select explorer lanes: standard (5 lanes), security, ux, architecture, full (all 8 lanes). Emits a structured findings report without mutating source code.",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     "deep dive": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleDeepDiveCommand),
@@ -67653,7 +67687,8 @@ Subcommands:
       description: "Launch a multi-source, fact-checked deep research pass and synthesize a cited report [question]",
       args: "<question> [--depth standard|exhaustive] [--max-researchers 1..6] [--rounds 1..4] [--brief]",
       details: "Runs the orchestrator-worker deep-research protocol: the architect decomposes the question into subtopics, gathers evidence with web_search and web_fetch across up to N iterative rounds, dispatches parallel sme synthesis workers, verifies every claim against cited sources with dual reviewers, challenges high-stakes claims with the critic, and presents a cited report in chat. Read-only \u2014 does not mutate source code, delegate to coder, or call declare_scope. Requires council.general.enabled and a search API key.",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     "deep research": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleDeepResearchCommand),
@@ -67667,7 +67702,8 @@ Subcommands:
       description: "Launch codebase-review-swarm for a quote-grounded full-repo or large-subsystem audit",
       args: "[scope] [--mode phase0|complete|defect|security|correctness|testing|ui|performance|ai-slop|enhancements|custom] [--tracks <list>] [--continue <run-id>] [--json] [--skip-update] [--allow-dirty]",
       details: "Runs the codebase-review-swarm workflow: Phase 0 inventory, selected-track depth planning, non-diluting review passes, coverage closure, reviewer validation, critic challenge, and .swarm/review-v8 artifacts. Materializes the bundled skill package if missing, then emits a MODE signal; the architect workflow must not mutate source files.",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     "codebase review": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleCodebaseReviewCommand),
@@ -67681,7 +67717,8 @@ Subcommands:
       description: "Generate or sync language-agnostic design docs (domain, technical-spec, behavior-spec, reference/) for the project under build [description]",
       args: "<description> [--out <dir>] [--lang <name>] [--update]",
       details: "Triggers the architect to enter MODE: DESIGN_DOCS \u2014 delegates to the docs_design agent to author/sync docs/domain.md, docs/technical-spec.md, docs/behavior-spec.md, and docs/reference/* (plus reference/traceability.json and design-changelog.md). Normative docs are 100% language-agnostic; all framework-specific material is quarantined under reference/. --update syncs existing docs to current code/spec instead of generating fresh. Requires design_docs.enabled: true.",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     "design docs": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleDesignDocsCommand),
@@ -67695,21 +67732,24 @@ Subcommands:
       description: "Ingest a GitHub issue into the swarm workflow [url] [--plan] [--trace] [--no-repro]",
       args: "<issue-url|owner/repo#N|N> [--plan] [--trace] [--no-repro]",
       details: "Triggers the architect to enter MODE: ISSUE_INGEST \u2014 ingests a GitHub issue, restructures it into a normalized intake note, localizes root cause through hypothesis-driven tracing, and outputs a resolution spec. --plan transitions to plan creation after spec generation. --trace runs the full fix-and-PR workflow (implies --plan). --no-repro skips the reproduction step. Supports full GitHub URL, owner/repo#N shorthand, or bare issue number (resolves against origin remote).",
-      category: "agent"
+      category: "agent",
+      toolPolicy: "none"
     },
     "qa-gates": {
       handler: (ctx) => handleQaGatesCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "View or modify QA gate profile for the current plan [enable|override <gate>...]",
       args: "[show|enable|override] <gate>...",
       details: "show: display spec-level, session-override, and effective QA gates for the current plan. enable: persist gate(s) into the locked-once profile (architect; rejected after critic approval lock). override: session-only ratchet-tighter enable. Valid gates: reviewer, test_engineer, council_mode, sme_enabled, critic_pre_plan, hallucination_guard, sast_enabled, mutation_test, phase_council, drift_check, final_council.",
-      category: "config"
+      category: "config",
+      toolPolicy: "none"
     },
     promote: {
       handler: (ctx) => handlePromoteCommand(ctx.directory, ctx.args),
       description: "Manually promote lesson to hive knowledge",
       details: "Promotes a lesson directly to hive knowledge (--category flag sets category) or references an existing swarm lesson by ID (--from-swarm). Validates lesson text before promotion. Either direct text or --from-swarm ID is required.",
       args: "--category <category>, --from-swarm <lesson-id>, <lesson-text>",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "none"
     },
     reset: {
       handler: (ctx) => handleResetCommand(ctx.directory, ctx.args),
@@ -67717,35 +67757,40 @@ Subcommands:
       details: "DELETES plan.md, context.md, and summaries/ directory from .swarm/. Stops background automation and clears in-memory queues. SAFETY: requires --confirm flag \u2014 without it, displays a warning and tips to export first.",
       args: "--confirm (required)",
       category: "utility",
-      clashesWithNativeCcCommand: "/reset"
+      clashesWithNativeCcCommand: "/reset",
+      toolPolicy: "restricted"
     },
     "reset-session": {
       handler: (ctx) => handleResetSessionCommand(ctx.directory, ctx.args),
       description: "Clear session state while preserving plan, evidence, and knowledge",
       details: "Deletes only .swarm/session/state.json and any other session files. Clears in-memory agent sessions and delegation chains. Preserves plan, evidence, and knowledge for cross-session continuity.",
       args: "",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "restricted"
     },
     rollback: {
       handler: (ctx) => handleRollbackCommand(ctx.directory, ctx.args),
       description: "Restore swarm state to a checkpoint <phase>",
       details: "Restores .swarm/ state by directly overwriting files from a checkpoint directory (checkpoints/phase-<N>). Writes rollback event to events.jsonl. Without phase argument, lists available checkpoints. Partial failures are reported but processing continues.",
       args: "<phase-number>",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "restricted"
     },
     retrieve: {
       handler: (ctx) => handleRetrieveCommand(ctx.directory, ctx.args),
       description: "Retrieve full output from a summary <id>",
       args: "<summary-id>",
       details: "Loads the full tool output that was previously summarized (referenced by IDs like S1, S2). Use when you need the complete output instead of the truncated summary.",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent"
     },
     handoff: {
       handler: (ctx) => handleHandoffCommand(ctx.directory, ctx.args),
       description: "Prepare state for clean model switch (new session)",
       args: "",
       details: "Generates handoff.md with full session state snapshot, including plan progress, recent decisions, and agent delegation history. Prepended to the next session prompt for seamless model switches.",
-      category: "core"
+      category: "core",
+      toolPolicy: "none"
     },
     turbo: {
       handler: (ctx) => handleTurboCommand(ctx.directory, ctx.args, ctx.sessionID),
@@ -67767,28 +67812,32 @@ Subcommands:
 ` + `  turbo status       \u2014 show detailed status including active strategy and lanes
 ` + `
 ` + "Session-scoped \u2014 resets on new session.",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "none"
     },
     "full-auto": {
       handler: (ctx) => handleFullAutoCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "Toggle Full-Auto Mode for the active session [on [mode]|off|status]",
       args: "on [assisted|supervised|strict], off, status",
       details: 'First-class toggle for Full-Auto Mode \u2014 autonomous execution with the critic reviewing escalations on your behalf. No config-level enablement is required: "on" activates immediately (unless full_auto.locked is true in config), "off" disarms the run and returns the session to normal interactive operation, "status" reports the durable run state. ' + 'An optional mode after "on" overrides full_auto.mode for this run: assisted (critic consulted only on policy escalations), supervised (default \u2014 risky/high-impact actions reviewed by the critic), strict (ALL plan mutations reviewed by the critic). ' + "While active, the critic answers architect questions and reviews phase boundaries, delegations, and risky actions on your behalf; only ESCALATE_TO_HUMAN verdicts halt the run for your input. The run state is durable (.swarm/full-auto-state.json) and survives restarts; toggle with no argument flips the current state.",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "none"
     },
     "auto-proceed": {
       handler: (ctx) => handleAutoProceedCommand(ctx.directory, ctx.args, ctx.sessionID),
       description: "Toggle or set auto-proceed override for the active session",
       args: "[on|off]",
       category: "config",
-      details: 'Without argument, toggles auto-proceed mode. With "on" or "off", sets the state explicitly.'
+      details: 'Without argument, toggles auto-proceed mode. With "on" or "off", sets the state explicitly.',
+      toolPolicy: "agent"
     },
     "write-retro": {
       handler: (ctx) => handleWriteRetroCommand(ctx.directory, ctx.args),
       description: "Write a retrospective evidence bundle for a completed phase <json>",
       details: "Writes retrospective evidence bundle to .swarm/evidence/retro-{phase}/evidence.json. Required JSON: phase, summary, task_count, task_complexity, total_tool_calls, coder_revisions, reviewer_rejections, test_failures, security_findings, integration_issues. Optional: lessons_learned (max 5), top_rejection_reasons, task_id, metadata.",
       args: "<json: {phase, summary, task_count, task_complexity, ...}>",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "none"
     },
     "knowledge migrate": {
       handler: (ctx) => handleKnowledgeMigrateCommand(ctx.directory, ctx.args),
@@ -67832,75 +67881,89 @@ Subcommands:
     knowledge: {
       handler: (ctx) => handleKnowledgeListCommand(ctx.directory, ctx.args),
       description: "List knowledge entries",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent"
     },
     memory: {
       handler: (ctx) => handleMemoryCommand(ctx.directory, ctx.args),
       description: "Show Swarm memory commands",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "memory status": {
       handler: (ctx) => handleMemoryStatusCommand(ctx.directory, ctx.args),
       description: "Show Swarm memory provider, JSONL, and migration status",
       subcommandOf: "memory",
       args: "",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "memory pending": {
       handler: (ctx) => handleMemoryPendingCommand(ctx.directory, ctx.args),
       description: "Show pending Swarm memory proposals and rejection reasons",
       subcommandOf: "memory",
       args: "--limit <n>",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent"
     },
     "memory recall-log": {
       handler: (ctx) => handleMemoryRecallLogCommand(ctx.directory, ctx.args),
       description: "Summarize Swarm memory recall usage",
       subcommandOf: "memory",
       args: "--limit <n>",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent"
     },
     "memory compact": {
       handler: (ctx) => handleMemoryCompactCommand(ctx.directory, ctx.args),
       description: "Compact deleted, superseded, and expired scratch memories",
       subcommandOf: "memory",
       args: "--confirm",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "human-only"
     },
     "memory stale": {
       handler: (ctx) => handleMemoryStaleCommand(ctx.directory, ctx.args),
       description: "List stale and low-utility Swarm memories",
       subcommandOf: "memory",
       args: "--limit <n>",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent"
     },
     "memory export": {
       handler: (ctx) => handleMemoryExportCommand(ctx.directory, ctx.args),
       description: "Export current Swarm memory to JSONL files",
       subcommandOf: "memory",
       args: "",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "agent",
+      toolNoArgs: true
     },
     "memory evaluate": {
       handler: (ctx) => handleMemoryEvaluateCommand(ctx.directory, ctx.args),
       description: "Run golden Swarm memory recall evaluation fixtures",
       subcommandOf: "memory",
       args: "--json, --fixtures <directory>",
-      category: "diagnostics"
+      category: "diagnostics",
+      toolPolicy: "agent"
     },
     "memory import": {
       handler: (ctx) => handleMemoryImportCommand(ctx.directory, ctx.args),
       description: "Import legacy JSONL memory into SQLite",
       subcommandOf: "memory",
       args: "",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "human-only"
     },
     "memory migrate": {
       handler: (ctx) => handleMemoryMigrateCommand(ctx.directory, ctx.args),
       description: "Run the one-time legacy JSONL to SQLite migration",
       subcommandOf: "memory",
       args: "",
-      category: "utility"
+      category: "utility",
+      toolPolicy: "human-only"
     },
     checkpoint: {
       handler: (ctx) => handleCheckpointCommand(ctx.directory, ctx.args),
@@ -67908,19 +67971,21 @@ Subcommands:
       details: "save: creates named snapshot of current .swarm/ state. restore: soft-resets to checkpoint by overwriting current .swarm/ files. delete: removes named checkpoint. list: shows all checkpoints with timestamps. All subcommands require a label except list.",
       args: "<save|restore|delete|list> <label>",
       category: "utility",
-      clashesWithNativeCcCommand: "/checkpoint"
+      clashesWithNativeCcCommand: "/checkpoint",
+      toolPolicy: "restricted"
     }
   };
   VALID_COMMANDS = Object.keys(COMMAND_REGISTRY);
-  _internals45 = {
+  _internals11 = {
     handleHelpCommand,
     validateAliases,
+    validateToolPolicy,
     resolveCommand,
     levenshteinDistance: levenshteinDistance2,
     findSimilarCommands,
     buildDetailedHelp
   };
-  validation = _internals45.validateAliases();
+  validation = _internals11.validateAliases();
   if (!validation.valid) {
     throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
@@ -67931,6 +67996,16 @@ ${validation.errors.join(`
 ${validation.warnings.join(`
 `)}`);
   }
+  try {
+    const toolPolicyValidation = _internals11.validateToolPolicy();
+    if (toolPolicyValidation.warnings.length > 0) {
+      console.warn(`COMMAND_REGISTRY toolPolicy warnings:
+${toolPolicyValidation.warnings.join(`
+`)}`);
+    }
+  } catch (e) {
+    console.warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
+  }
 });
 
 // src/cli/index.ts