opencode-swarm 7.114.7 → 7.114.9

package/dist/cli/{index-6ctejje2.js → index-typ408f4.js}

@@ -68,7 +68,7 @@ import {
   savePlan,
   transientBackoff,
   validateProjectRoot
-} from "./index-f6y341yk.js";
+} from "./index-yrrqs4b0.js";
 import {
   buildOpenSpecProjectionSync,
   detectSpeckit,
@@ -111,7 +111,7 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-vjvdvjd3.js";
+} from "./index-x12hvfpf.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -121,10 +121,10 @@ import {
   validateActionability,
   validateActionableFields,
   validateLesson
-} from "./index-qrnhvhmg.js";
+} from "./index-n18yy0z1.js";
 import {
   readRecentEscalations
-} from "./index-7stsmndb.js";
+} from "./index-6f6y2rbp.js";
 import {
   effectiveRetrievalOutcomes,
   readKnowledgeCounterRollups,
@@ -132,7 +132,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-kjbfry6m.js";
+} from "./index-8f2270hc.js";
 import {
   appendKnowledge,
   appendRejectedLesson,
@@ -156,7 +156,7 @@ import {
   rewriteKnowledge,
   transactFile,
   transactKnowledge
-} from "./index-91qesget.js";
+} from "./index-rk6qhyng.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -3064,50 +3064,60 @@ class SQLiteMemoryProvider {
     mkdirSync4(path5.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
-    this.db.run("PRAGMA journal_mode = WAL;");
-    this.db.run("PRAGMA synchronous = NORMAL;");
-    const busyTimeoutMs = Math.min(60000, Math.max(0, Math.trunc(this.config.sqlite.busyTimeoutMs)));
-    this.db.run(`PRAGMA busy_timeout = ${busyTimeoutMs};`);
-    this.db.run("PRAGMA foreign_keys = ON;");
-    this.runMigrations();
-    this.backfillScopeKeys();
-    this.backfillRecallRunIds();
-    this.ftsAvailable = this.initializeFtsIndex();
-    this.initializeVecExtension();
-    if (this.config.embeddings.enabled && !this.embeddingProvider) {
-      try {
-        this.embeddingProvider = new LocalEmbeddingProvider({
-          model: this.config.embeddings.model,
-          dimension: this.config.embeddings.dimension,
-          version: this.config.embeddings.version
-        });
-      } catch (err) {
-        this.embeddingProvider = null;
-        warn("Failed to construct embedding provider \u2014 dense retrieval disabled", {
-          reason: err instanceof Error ? err.message : String(err)
-        });
+    try {
+      this.db.run("PRAGMA journal_mode = WAL;");
+      this.db.run("PRAGMA synchronous = NORMAL;");
+      const busyTimeoutMs = Math.min(60000, Math.max(0, Math.trunc(this.config.sqlite.busyTimeoutMs)));
+      this.db.run(`PRAGMA busy_timeout = ${busyTimeoutMs};`);
+      this.db.run("PRAGMA foreign_keys = ON;");
+      this.runMigrations();
+      this.backfillScopeKeys();
+      this.backfillRecallRunIds();
+      this.ftsAvailable = this.initializeFtsIndex();
+      this.initializeVecExtension();
+      if (this.config.embeddings.enabled && !this.embeddingProvider) {
+        try {
+          this.embeddingProvider = new LocalEmbeddingProvider({
+            model: this.config.embeddings.model,
+            dimension: this.config.embeddings.dimension,
+            version: this.config.embeddings.version
+          });
+        } catch (err) {
+          this.embeddingProvider = null;
+          warn("Failed to construct embedding provider \u2014 dense retrieval disabled", {
+            reason: err instanceof Error ? err.message : String(err)
+          });
+        }
+        try {
+          this.embeddingCache = new EmbeddingCache(this.config.embeddings.cacheSize);
+        } catch (err) {
+          this.embeddingCache = null;
+          warn("Failed to construct embedding cache \u2014 recall works without cache", {
+            reason: err instanceof Error ? err.message : String(err)
+          });
+        }
       }
-      try {
-        this.embeddingCache = new EmbeddingCache(this.config.embeddings.cacheSize);
-      } catch (err) {
-        this.embeddingCache = null;
-        warn("Failed to construct embedding cache \u2014 recall works without cache", {
-          reason: err instanceof Error ? err.message : String(err)
-        });
+      this.lastAutomaticJsonlMigration = null;
+      await this.migrateLegacyJsonlIfNeeded();
+      const memoryLoad = this.loadMemories();
+      const proposalLoad = this.loadProposals();
+      this.memories = new Map(memoryLoad.records.map((record) => [record.id, record]));
+      this.proposals = new Map(proposalLoad.records.map((proposal) => [proposal.id, proposal]));
+      this.initialized = true;
+      if (memoryLoad.invalidCount > 0) {
+        await this.event("invalid_load", "memory_items", `${memoryLoad.invalidCount} invalid SQLite memory row(s) skipped`);
       }
-    }
-    this.lastAutomaticJsonlMigration = null;
-    await this.migrateLegacyJsonlIfNeeded();
-    const memoryLoad = this.loadMemories();
-    const proposalLoad = this.loadProposals();
-    this.memories = new Map(memoryLoad.records.map((record) => [record.id, record]));
-    this.proposals = new Map(proposalLoad.records.map((proposal) => [proposal.id, proposal]));
-    this.initialized = true;
-    if (memoryLoad.invalidCount > 0) {
-      await this.event("invalid_load", "memory_items", `${memoryLoad.invalidCount} invalid SQLite memory row(s) skipped`);
-    }
-    if (proposalLoad.invalidCount > 0) {
-      await this.event("invalid_load", "memory_proposals", `${proposalLoad.invalidCount} invalid SQLite proposal row(s) skipped`);
+      if (proposalLoad.invalidCount > 0) {
+        await this.event("invalid_load", "memory_proposals", `${proposalLoad.invalidCount} invalid SQLite proposal row(s) skipped`);
+      }
+    } catch (err) {
+      try {
+        this.db?.close();
+      } catch {}
+      this.db = null;
+      this.ftsAvailable = false;
+      this.initialized = false;
+      throw err;
     }
   }
   async upsert(record) {
@@ -3132,7 +3142,20 @@ class SQLiteMemoryProvider {
   }
   async withTransaction(fn) {
     const db = this.requireDb();
-    return db.transaction(() => fn({}))();
+    if (db.inTransaction) {
+      return await fn({});
+    }
+    db.run("BEGIN IMMEDIATE");
+    try {
+      const result = await fn({});
+      db.run("COMMIT");
+      return result;
+    } catch (err) {
+      try {
+        db.run("ROLLBACK");
+      } catch {}
+      throw err;
+    }
   }
   async delete(id, reason) {
     await this.initialize();
@@ -6403,6 +6426,294 @@ async function handleList2(directory) {
   }
 }
 
+// src/commands/_shared/url-security.ts
+import * as child_process2 from "child_process";
+var MAX_URL_LEN = 2048;
+var IPV4_PRIVATE = /^10\./;
+var IPV4_LOOPBACK = /^127\./;
+var IPV4_LINK_LOCAL = /^169\.254\./;
+var IPV4_PRIVATE_172 = /^172\.(1[6-9]|2\d|3[0-1])\./;
+var IPV4_PRIVATE_192 = /^192\.168\./;
+var IPV4_ZERO_NETWORK = /^0\./;
+var IPV6_LINK_LOCAL = /^fe80:/i;
+var IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
+var _internals7 = {
+  spawnSync: (cmd, args, options) => {
+    const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
+    return child_process2.spawnSync(cmd, args, {
+      ...options,
+      env: mergedEnv
+    });
+  }
+};
+function sanitizeUrl(raw) {
+  let urlStr = raw.trim();
+  urlStr = urlStr.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
+  const fragmentIdx = urlStr.indexOf("#");
+  if (fragmentIdx !== -1) {
+    urlStr = urlStr.slice(0, fragmentIdx);
+  }
+  const queryIdx = urlStr.indexOf("?");
+  if (queryIdx !== -1) {
+    urlStr = urlStr.slice(0, queryIdx);
+  }
+  urlStr = urlStr.replace(/^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^@/]+@/, "https://");
+  if (urlStr.length > MAX_URL_LEN) {
+    urlStr = urlStr.slice(0, MAX_URL_LEN);
+  }
+  return urlStr.trim();
+}
+function sanitizeErrorEcho(raw, maxLength = 80) {
+  let stripped = "";
+  for (const ch of raw) {
+    const cp = ch.codePointAt(0);
+    if (cp !== undefined && (cp <= 31 || cp === 127)) {
+      stripped += " ";
+      continue;
+    }
+    stripped += ch;
+  }
+  const collapsed = stripped.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= maxLength)
+    return collapsed;
+  return `${collapsed.slice(0, maxLength)}\u2026`;
+}
+function containsControlCharacters(value) {
+  for (const ch of value) {
+    const cp = ch.codePointAt(0);
+    if (cp !== undefined && (cp <= 31 || cp === 127)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasNonAsciiHostname(hostname) {
+  for (const ch of hostname) {
+    const cp = ch.codePointAt(0);
+    if (cp !== undefined && cp > 127)
+      return true;
+  }
+  return false;
+}
+function isIpv4MappedPrivateHost(inner) {
+  if (IPV4_PRIVATE.test(inner) || IPV4_LOOPBACK.test(inner) || IPV4_LINK_LOCAL.test(inner) || IPV4_PRIVATE_172.test(inner) || IPV4_PRIVATE_192.test(inner) || IPV4_ZERO_NETWORK.test(inner)) {
+    return true;
+  }
+  const firstSegment = inner.split(":", 1)[0];
+  if (!firstSegment)
+    return false;
+  const firstWord = Number.parseInt(firstSegment, 16);
+  if (!Number.isFinite(firstWord))
+    return false;
+  return firstWord >= 0 && firstWord <= 255 || firstWord >= 2560 && firstWord <= 2815 || firstWord >= 32512 && firstWord <= 32767 || firstWord === 43518 || firstWord >= 44048 && firstWord <= 44063 || firstWord === 49320;
+}
+function isPrivateHost(url) {
+  const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (host === "localhost" || host === "::1" || host === "0.0.0.0" || IPV4_LOOPBACK.test(host) || IPV4_ZERO_NETWORK.test(host)) {
+    return true;
+  }
+  if (host.startsWith("localhost") || host === "localhost.com") {
+    return true;
+  }
+  if (IPV4_PRIVATE.test(host) || IPV4_LINK_LOCAL.test(host) || IPV4_PRIVATE_172.test(host) || IPV4_PRIVATE_192.test(host) || IPV6_LINK_LOCAL.test(host) || IPV6_UNIQUE_LOCAL.test(host)) {
+    return true;
+  }
+  if (host.startsWith("::ffff:")) {
+    const inner = host.slice(7);
+    if (isIpv4MappedPrivateHost(inner)) {
+      return true;
+    }
+  }
+  return false;
+}
+function validateAndSanitizeGithubUrl(rawUrl, resource) {
+  const sanitized = sanitizeUrl(rawUrl);
+  if (!sanitized) {
+    return { error: "Empty URL" };
+  }
+  if (!sanitized.startsWith("https://")) {
+    return { error: "URL must use HTTPS scheme" };
+  }
+  try {
+    const url = new URL(sanitized);
+    if (hasNonAsciiHostname(url.hostname)) {
+      return { error: "Non-ASCII hostnames are not allowed" };
+    }
+    if (isPrivateHost(url)) {
+      return { error: "Private or localhost URLs are not allowed" };
+    }
+    const githubPattern = new RegExp(`^https:\\/\\/github\\.com\\/([^/]+)\\/([^/]+)\\/${resource}\\/([0-9]+)\\/?$`);
+    if (!githubPattern.test(sanitized)) {
+      return {
+        error: resource === "issues" ? "URL must be a GitHub issue URL (https://github.com/owner/repo/issues/N)" : "URL must be a GitHub pull request URL (https://github.com/owner/repo/pull/N)"
+      };
+    }
+    return { sanitized };
+  } catch {
+    return { error: "Invalid URL format" };
+  }
+}
+function detectGitRemote(cwd, laneEnv) {
+  try {
+    const result = _internals7.spawnSync("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 5000,
+      ...cwd ? { cwd } : {},
+      envOverrides: laneEnv
+    });
+    if (result.status !== 0 || result.error) {
+      return null;
+    }
+    const remoteUrl = (result.stdout ?? "").trim();
+    return remoteUrl || null;
+  } catch {
+    return null;
+  }
+}
+function parseGitRemoteUrl(remoteUrl) {
+  const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i);
+  if (httpsMatch) {
+    const owner = httpsMatch[1];
+    const repo = httpsMatch[2].replace(/\.git$/, "");
+    if (containsControlCharacters(owner) || containsControlCharacters(repo)) {
+      return null;
+    }
+    return { owner, repo };
+  }
+  const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
+  if (sshMatch) {
+    const owner = sshMatch[1];
+    const repo = sshMatch[2].replace(/\.git$/, "");
+    if (containsControlCharacters(owner) || containsControlCharacters(repo)) {
+      return null;
+    }
+    return { owner, repo };
+  }
+  const pathMatch = remoteUrl.match(/\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  if (pathMatch) {
+    const owner = pathMatch[1];
+    const repo = pathMatch[2].replace(/\.git$/, "");
+    if (containsControlCharacters(owner) || containsControlCharacters(repo)) {
+      return null;
+    }
+    return { owner, repo };
+  }
+  return null;
+}
+
+// src/commands/pr-ref.ts
+var MAX_INSTRUCTIONS_LEN = 1000;
+function sanitizeInstructions(raw) {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  const stripped = collapsed.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
+  const normalized = stripped.replace(/\s+/g, " ").trim();
+  if (normalized.length <= MAX_INSTRUCTIONS_LEN)
+    return normalized;
+  return `${normalized.slice(0, MAX_INSTRUCTIONS_LEN)}\u2026`;
+}
+function validateAndSanitizeUrl(rawUrl) {
+  return validateAndSanitizeGithubUrl(rawUrl, "pull");
+}
+function parsePrRef(input, cwd) {
+  const urlMatch = input.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/i);
+  if (urlMatch) {
+    if (containsControlCharacters(urlMatch[1]) || containsControlCharacters(urlMatch[2])) {
+      return null;
+    }
+    return {
+      owner: urlMatch[1],
+      repo: urlMatch[2],
+      number: parseInt(urlMatch[3], 10)
+    };
+  }
+  const shorthandMatch = input.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+  if (shorthandMatch) {
+    if (containsControlCharacters(shorthandMatch[1]) || containsControlCharacters(shorthandMatch[2])) {
+      return null;
+    }
+    return {
+      owner: shorthandMatch[1],
+      repo: shorthandMatch[2],
+      number: parseInt(shorthandMatch[3], 10)
+    };
+  }
+  const bareMatch = input.match(/^(\d+)$/);
+  if (bareMatch) {
+    const prNumber = parseInt(bareMatch[1], 10);
+    const remoteUrl = detectGitRemote(cwd, undefined);
+    if (!remoteUrl) {
+      return null;
+    }
+    const parsed = parseGitRemoteUrl(remoteUrl);
+    if (!parsed) {
+      return null;
+    }
+    return {
+      owner: parsed.owner,
+      repo: parsed.repo,
+      number: prNumber
+    };
+  }
+  return null;
+}
+function looksLikePrRef(token) {
+  return /^https?:\/\//i.test(token) || /^[^/]+\/[^#]+#\d+$/.test(token) || /^\d+$/.test(token);
+}
+function resolvePrCommandInput(rest, cwd) {
+  if (rest.length === 0) {
+    return null;
+  }
+  const refToken = rest[0];
+  const instructions = sanitizeInstructions(rest.slice(1).join(" "));
+  const isFullUrl = /^https?:\/\//i.test(refToken);
+  const prInfo = parsePrRef(isFullUrl ? sanitizeUrl(refToken) : refToken, cwd);
+  if (!prInfo) {
+    return {
+      error: `Could not parse PR reference from "${sanitizeErrorEcho(refToken)}"`
+    };
+  }
+  const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
+  const result = validateAndSanitizeUrl(prUrl);
+  if ("error" in result) {
+    return { error: result.error };
+  }
+  return { prUrl: result.sanitized, instructions };
+}
+
+// src/commands/ci-monitor.ts
+var USAGE = [
+  "Usage: /swarm ci-monitor <pr-url|owner/repo#N|N>",
+  "",
+  "Drive an already human-reviewed, approved pull request to green and",
+  "merged: monitors CI, exhaustively researches and fixes each failure,",
+  "iterates until all required checks are green (max 5 fix cycles), then",
+  "merges. Only invoke after human review is complete.",
+  "",
+  "  /swarm ci-monitor https://github.com/owner/repo/pull/42",
+  "  /swarm ci-monitor owner/repo#42",
+  "  /swarm ci-monitor 42"
+].join(`
+`);
+function handleCiMonitorCommand(directory, args) {
+  const rest = args.filter((token) => token.trim().length > 0);
+  const resolved = resolvePrCommandInput(rest, directory);
+  if (resolved === null) {
+    return USAGE;
+  }
+  if ("error" in resolved) {
+    return `Error: ${resolved.error}
+
+${USAGE}`;
+  }
+  if (resolved.instructions) {
+    return `Error: /swarm ci-monitor takes only a PR reference \u2014 no trailing instructions. Got: "${resolved.instructions}"
+
+${USAGE}`;
+  }
+  return `[MODE: CI_MONITOR pr="${resolved.prUrl}"]`;
+}
+
 // src/commands/ci-simulate.ts
 import * as fs4 from "fs";
 import * as fsPromises2 from "fs/promises";
@@ -6475,7 +6786,7 @@ function timeoutKillSignal(platform) {
 }
 function killProcess(proc) {
   try {
-    proc?.kill(timeoutKillSignal(_internals7.platform()));
+    proc?.kill(timeoutKillSignal(_internals8.platform()));
   } catch {}
 }
 async function runExternalTool(options) {
@@ -6495,7 +6806,7 @@ async function runExternalTool(options) {
   let exitSettled = false;
   let settledExitCode = null;
   try {
-    proc = _internals7.bunSpawn([options.executable, ...options.args], {
+    proc = _internals8.bunSpawn([options.executable, ...options.args], {
       cwd: options.cwd,
       env: options.env,
       stdin: "ignore",
@@ -6563,7 +6874,7 @@ async function runExternalTool(options) {
     }
   }
 }
-var _internals7 = {
+var _internals8 = {
   bunSpawn,
   platform: () => process.platform
 };
@@ -6572,7 +6883,7 @@ var _internals7 = {
 var GIT_TIMEOUT_MS2 = 30000;
 var VALIDATION_TIMEOUT_MS = 5 * 60 * 1000;
 var OUTPUT_LIMIT_BYTES = 12000;
-var _internals8 = {
+var _internals9 = {
   runExternalTool,
   getDefaultBaseBranch,
   platform: process.platform,
@@ -6583,7 +6894,7 @@ var _internals8 = {
   }
 };
 async function runGit2(args, cwd, timeoutMs = GIT_TIMEOUT_MS2) {
-  const result = await _internals8.runExternalTool({
+  const result = await _internals9.runExternalTool({
     executable: "git",
     args,
     cwd,
@@ -6601,7 +6912,7 @@ async function runGit2(args, cwd, timeoutMs = GIT_TIMEOUT_MS2) {
 }
 async function runValidationCommand(cmd, cwd, timeoutMs = VALIDATION_TIMEOUT_MS) {
   const [executable, ...args] = cmd;
-  const result = await _internals8.runExternalTool({
+  const result = await _internals9.runExternalTool({
     executable,
     args,
     cwd,
@@ -6629,7 +6940,7 @@ async function getCurrentBranchOrRef(directory) {
   return hashResult.stdout.trim();
 }
 async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated) {
-  const worktreeBase = path12.join(_internals8.osTmpdir(), "swarm-ci-simulate");
+  const worktreeBase = path12.join(_internals9.osTmpdir(), "swarm-ci-simulate");
   const worktreeName = `pr-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
   const worktreePath = path12.join(worktreeBase, worktreeName);
   await fsPromises2.mkdir(worktreeBase, { recursive: true });
@@ -6647,8 +6958,8 @@ async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated)
 async function cleanupWorktree(worktreePath, projectRoot) {
   const removeResult = await runGit2(["worktree", "remove", "--force", worktreePath], projectRoot);
   try {
-    if (_internals8.fs.existsSync(worktreePath)) {
-      _internals8.fs.rmSync(worktreePath, { recursive: true, force: true });
+    if (_internals9.fs.existsSync(worktreePath)) {
+      _internals9.fs.rmSync(worktreePath, { recursive: true, force: true });
     }
   } catch {}
   if (removeResult.exitCode !== 0) {
@@ -6730,7 +7041,7 @@ async function handleCiSimulateCommand(directory, args) {
     steps: []
   };
   try {
-    const baseBranch = _internals8.getDefaultBaseBranch(directory);
+    const baseBranch = _internals9.getDefaultBaseBranch(directory);
     if (!isSafeGitRef(baseBranch)) {
       throw new Error("Detected default branch is not a safe git reference.");
     }
@@ -6829,7 +7140,7 @@ async function handleClarifyCommand(_directory, args) {
 }
 
 // src/commands/close.ts
-import * as child_process2 from "child_process";
+import * as child_process3 from "child_process";
 import * as fsSync from "fs";
 import { promises as fs10 } from "fs";
 import path29 from "path";
@@ -7518,7 +7829,7 @@ async function reviseSkill(params) {
   }
   if (!params.delegate) {
     try {
-      const revised = _internals9.buildDeterministicRevision(params.currentContent, params.currentVersion, params.violationContexts);
+      const revised = _internals10.buildDeterministicRevision(params.currentContent, params.currentVersion, params.violationContexts);
       const validation = await validateRevisionCandidate(params, revised, "skill_reviser:deterministic");
       if (!validation.passed) {
         return {
@@ -7645,7 +7956,7 @@ async function reviseSkill(params) {
     };
   }
 }
-var _internals9 = {
+var _internals10 = {
   reviseSkill,
   getSkillVersion,
   buildDeterministicRevision,
@@ -7729,7 +8040,7 @@ function resolveLogPath(directory) {
 function normalizeComplianceVerdict(verdict) {
   return verdict === "violation" ? "violated" : verdict;
 }
-var _internals10 = {
+var _internals11 = {
   generateId: () => crypto2.randomUUID(),
   appendFileSync: fs5.appendFileSync.bind(fs5),
   readFileSync: fs5.readFileSync.bind(fs5),
@@ -7799,9 +8110,9 @@ function parseFeedbackMarker(raw) {
 function readFeedbackAppliedEntryIds(directory) {
   const resolved = resolveLogPath(directory);
   const processed = new Set;
-  if (!_internals10.existsSync(resolved))
+  if (!_internals11.existsSync(resolved))
     return processed;
-  const raw = _internals10.readFileSync(resolved, "utf-8");
+  const raw = _internals11.readFileSync(resolved, "utf-8");
   for (const line of raw.split(`
 `)) {
     const trimmed = line.trim();
@@ -7822,15 +8133,15 @@ function appendFeedbackAppliedMarker(directory, processedEntryIds) {
     return;
   const resolved = resolveLogPath(directory);
   const dir = path15.dirname(resolved);
-  if (!_internals10.existsSync(dir)) {
-    _internals10.mkdirSync(dir, { recursive: true });
+  if (!_internals11.existsSync(dir)) {
+    _internals11.mkdirSync(dir, { recursive: true });
   }
   const marker = {
     type: "feedback_applied",
     timestamp: new Date().toISOString(),
     processedEntryIds: [...new Set(processedEntryIds)]
   };
-  _internals10.appendFileSync(resolved, `${JSON.stringify(marker)}
+  _internals11.appendFileSync(resolved, `${JSON.stringify(marker)}
 `, "utf-8");
 }
 function appendSkillUsageEntry(directory, entry) {
@@ -7867,11 +8178,11 @@ function appendSkillUsageEntry(directory, entry) {
   }
   const resolved = validateSwarmPath(directory, "skill-usage.jsonl");
   const dir = path15.dirname(resolved);
-  if (!_internals10.existsSync(dir)) {
-    _internals10.mkdirSync(dir, { recursive: true });
+  if (!_internals11.existsSync(dir)) {
+    _internals11.mkdirSync(dir, { recursive: true });
   }
   const fullEntry = {
-    id: _internals10.generateId(),
+    id: _internals11.generateId(),
     skillPath,
     agentName,
     taskID,
@@ -7881,21 +8192,21 @@ function appendSkillUsageEntry(directory, entry) {
     ...reviewerNotes !== undefined && { reviewerNotes },
     ...skillVersion !== undefined && { skillVersion }
   };
-  _internals10.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
+  _internals11.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
 `, "utf-8");
   try {
-    const stat2 = _internals10.statSync(resolved);
+    const stat2 = _internals11.statSync(resolved);
     if (stat2.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
-      _internals10.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
+      _internals11.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
     }
   } catch {}
 }
 function readSkillUsageEntries(directory, options) {
   const resolved = resolveLogPath(directory);
-  if (!_internals10.existsSync(resolved)) {
+  if (!_internals11.existsSync(resolved)) {
     return [];
   }
-  const raw = _internals10.readFileSync(resolved, "utf-8");
+  const raw = _internals11.readFileSync(resolved, "utf-8");
   const entries = [];
   for (const line of raw.split(`
 `)) {
@@ -7938,20 +8249,20 @@ var SKILL_USAGE_LOG_ROTATE_BYTES = 1024 * 1024;
 var SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL = 500;
 function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEFAULT) {
   const logPath = resolveLogPath(directory);
-  if (!_internals10.existsSync(logPath))
+  if (!_internals11.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 stat2 = _internals10.statSync(logPath);
+    const stat2 = _internals11.statSync(logPath);
     const start = Math.max(0, stat2.size - boundedMaxBytes);
-    const fd = _internals10.openSync(logPath, "r");
+    const fd = _internals11.openSync(logPath, "r");
     try {
       const readLen = stat2.size - start;
       if (readLen === 0)
         return [];
       const buf = Buffer.alloc(readLen);
-      _internals10.readSync(fd, buf, 0, buf.length, start);
+      _internals11.readSync(fd, buf, 0, buf.length, start);
       const content = buf.toString("utf-8");
       let usable;
       if (start > 0) {
@@ -7978,7 +8289,7 @@ function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEF
       }
       return entries;
     } finally {
-      _internals10.closeSync(fd);
+      _internals11.closeSync(fd);
     }
   } catch {
     return [];
@@ -8015,10 +8326,10 @@ function computeComplianceByVersion(entries, skillPath) {
 }
 function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   const resolved = resolveLogPath(directory);
-  if (!_internals10.existsSync(resolved)) {
+  if (!_internals11.existsSync(resolved)) {
     return { pruned: 0, remaining: 0 };
   }
-  const raw = _internals10.readFileSync(resolved, "utf-8");
+  const raw = _internals11.readFileSync(resolved, "utf-8");
   const lines = raw.split(`
 `);
   const entries = [];
@@ -8048,13 +8359,13 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
 `).concat(preservedMarkers.length > 0 ? `
 ` : "");
       try {
-        _internals10.writeFileSync(tmpPath2, content2, "utf-8");
-        _internals10.renameSync(tmpPath2, resolved);
+        _internals11.writeFileSync(tmpPath2, content2, "utf-8");
+        _internals11.renameSync(tmpPath2, resolved);
       } catch (writeErr) {
         const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
         try {
-          if (_internals10.existsSync(tmpPath2)) {
-            _internals10.writeFileSync(tmpPath2, "", "utf-8");
+          if (_internals11.existsSync(tmpPath2)) {
+            _internals11.writeFileSync(tmpPath2, "", "utf-8");
           }
         } catch {}
         return { pruned: 0, remaining: 0, error: msg };
@@ -8093,13 +8404,13 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
 `).concat(`
 `);
   try {
-    _internals10.writeFileSync(tmpPath, content, "utf-8");
-    _internals10.renameSync(tmpPath, resolved);
+    _internals11.writeFileSync(tmpPath, content, "utf-8");
+    _internals11.renameSync(tmpPath, resolved);
   } catch (writeErr) {
     const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
     try {
-      if (_internals10.existsSync(tmpPath)) {
-        _internals10.writeFileSync(tmpPath, "", "utf-8");
+      if (_internals11.existsSync(tmpPath)) {
+        _internals11.writeFileSync(tmpPath, "", "utf-8");
       }
     } catch {}
     return { pruned: 0, remaining: entries.length, error: msg };
@@ -8121,10 +8432,10 @@ async function resolveSourceKnowledgeIds(directory, skillPath) {
     if (!isContained) {
       return [];
     }
-    if (!_internals10.existsSync(absolute)) {
+    if (!_internals11.existsSync(absolute)) {
       return [];
     }
-    const content = _internals10.readFileSync(absolute, "utf-8");
+    const content = _internals11.readFileSync(absolute, "utf-8");
     return parseGeneratedFromKnowledge(content);
   } catch (err) {
     log("[skill-usage-log] resolveSourceKnowledgeIds failed (fail-open):", err instanceof Error ? err.message : String(err));
@@ -8232,7 +8543,7 @@ var DEFAULT_CURATOR_LLM_TIMEOUT_MS = 300000;
 var MAX_CURATOR_PHASE_DIGESTS = 50;
 var MAX_CURATOR_COMPLIANCE_OBSERVATIONS = 200;
 var MAX_CURATOR_RECOMMENDATIONS = 200;
-var _internals11 = {
+var _internals12 = {
   parseKnowledgeRecommendations,
   parseKnowledgeRecommendationsWithDiagnostics,
   readCuratorSummary,
@@ -8338,9 +8649,9 @@ ${digest.summary}`).join(`
 async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs) {
   const observations = [];
   try {
-    const skillListResult = await _internals11.listSkills(directory);
-    const usageEntries = _internals11.readSkillUsageEntries(directory);
-    const allArchivedIds = await _internals11.getArchivedKnowledgeIds(directory);
+    const skillListResult = await _internals12.listSkills(directory);
+    const usageEntries = _internals12.readSkillUsageEntries(directory);
+    const allArchivedIds = await _internals12.getArchivedKnowledgeIds(directory);
     for (const active of skillListResult.active) {
       if (excludeSlugs?.has(active.slug))
         continue;
@@ -8362,7 +8673,7 @@ async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs)
       const violationRate = skillUsage.length > 0 ? violations / skillUsage.length : 0;
       if (violationRate > 0.3) {
         const reason = `auto-retire: violation rate ${(violationRate * 100).toFixed(0)}% exceeds 30% threshold`;
-        await _internals11.retireSkill(directory, active.slug, reason);
+        await _internals12.retireSkill(directory, active.slug, reason);
         observations.push(`Skill '${active.slug}' auto-retired: ${reason}`);
         warn(`[curator] ${observations[observations.length - 1]}`);
         continue;
@@ -8370,15 +8681,15 @@ async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs)
       let archivedSourceMatched = false;
       if (allArchivedIds.size > 0) {
         try {
-          const content = await _internals11.readFileAsync(active.path, "utf-8");
-          const sourceIds = _internals11.parseDraftFrontmatter(content)?.sourceKnowledgeIds ?? [];
+          const content = await _internals12.readFileAsync(active.path, "utf-8");
+          const sourceIds = _internals12.parseDraftFrontmatter(content)?.sourceKnowledgeIds ?? [];
           archivedSourceMatched = sourceIds.some((id) => allArchivedIds.has(id));
         } catch {
           archivedSourceMatched = false;
         }
       }
       if (archivedSourceMatched) {
-        const result = await _internals11.retireOrMarkStale(directory, path16.dirname(active.path), allArchivedIds);
+        const result = await _internals12.retireOrMarkStale(directory, path16.dirname(active.path), allArchivedIds);
         if (result.action === "retire") {
           observations.push(`Skill '${active.slug}' auto-retired: all source knowledge entries archived`);
           warn(`[curator] ${observations[observations.length - 1]}`);
@@ -8646,7 +8957,7 @@ async function transactCuratorSummary(directory, mutate) {
   const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
   let invoked = false;
   let mutationResult;
-  await _internals11.transactFile(resolvedPath, _internals11.readCuratorSummaryState, _internals11.writeCuratorSummaryState, (state) => {
+  await _internals12.transactFile(resolvedPath, _internals12.readCuratorSummaryState, _internals12.writeCuratorSummaryState, (state) => {
     invoked = true;
     const mutation = mutate(state.summary);
     mutationResult = mutation.result;
@@ -8795,8 +9106,8 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
   const observations = [];
   const timestamp = new Date().toISOString();
   for (const agent of requiredAgents) {
-    const normalizedAgent = _internals11.normalizeAgentName(agent);
-    const isDispatched = agentsDispatched.some((a) => _internals11.normalizeAgentName(a) === normalizedAgent);
+    const normalizedAgent = _internals12.normalizeAgentName(agent);
+    const isDispatched = agentsDispatched.some((a) => _internals12.normalizeAgentName(a) === normalizedAgent);
     if (!isDispatched) {
       observations.push({
         phase,
@@ -8815,7 +9126,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
       if (e.type === "agent.delegation") {
         const agent = e.agent;
         if (agent && typeof agent === "string") {
-          const normalized = _internals11.normalizeAgentName(agent);
+          const normalized = _internals12.normalizeAgentName(agent);
           if (normalized === "coder") {
             coderDelegations.push({ event: e, index: i });
           } else if (normalized === "reviewer") {
@@ -8872,7 +9183,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
       if (e.type === "agent.delegation" && e.agent) {
         const agent = e.agent;
         if (agent && typeof agent === "string") {
-          const normalized = _internals11.normalizeAgentName(agent);
+          const normalized = _internals12.normalizeAgentName(agent);
           if (normalized === "sme") {
             smeDelegations.push({ event: e, index: i });
           }
@@ -8896,7 +9207,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
 }
 async function runCuratorInit(directory, config, llmDelegate) {
   try {
-    const priorSummary = await _internals11.readCuratorSummary(directory);
+    const priorSummary = await _internals12.readCuratorSummary(directory);
     const knowledgePath = resolveSwarmKnowledgePath(directory);
     const allEntries = await readKnowledge(knowledgePath);
     const highConfidenceEntries = allEntries.filter((e) => typeof e.confidence === "number" && e.confidence >= config.min_knowledge_confidence);
@@ -8937,7 +9248,7 @@ async function runCuratorInit(directory, config, llmDelegate) {
       const maxContextChars = config.max_summary_tokens * 2;
       briefingParts.push(contextMd.slice(0, maxContextChars));
     }
-    const latestPostMortemDigest = _internals11.readLatestPostMortemDigest(directory);
+    const latestPostMortemDigest = _internals12.readLatestPostMortemDigest(directory);
     if (latestPostMortemDigest) {
       briefingParts.push(`
 ## Latest Post-Mortem`);
@@ -9024,7 +9335,7 @@ Could not load prior session context.`,
 }
 async function runCuratorPhase(directory, phase, agentsDispatched, config, knowledgeConfig, llmDelegate) {
   try {
-    const priorSummary = await _internals11.readCuratorSummary(directory);
+    const priorSummary = await _internals12.readCuratorSummary(directory);
     if (priorSummary?.phase_digests.some((d) => d.phase === phase)) {
       const existingDigest = priorSummary.phase_digests.find((d) => d.phase === phase);
       return {
@@ -9037,10 +9348,10 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
       };
     }
     const eventsJsonlContent = await readSwarmFileAsync(directory, "events.jsonl");
-    const phaseEvents = eventsJsonlContent ? _internals11.filterPhaseEvents(eventsJsonlContent, phase) : [];
+    const phaseEvents = eventsJsonlContent ? _internals12.filterPhaseEvents(eventsJsonlContent, phase) : [];
     const contextMd = await readSwarmFileAsync(directory, "context.md");
     const requiredAgents = ["reviewer", "test_engineer"];
-    const complianceObservations = _internals11.checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, phase);
+    const complianceObservations = _internals12.checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, phase);
     const plan = await loadPlanJsonOnly(directory);
     const phaseData = plan?.phases.find((p) => p.id === phase);
     const tasksCompleted = phaseData ? phaseData.tasks.filter((t) => t.status === "completed").length : 0;
@@ -9064,7 +9375,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
       timestamp: new Date().toISOString(),
       summary: `Phase ${phase} completed. ${tasksCompleted}/${tasksTotal} tasks completed. ${complianceObservations.length} compliance observations.`,
       agents_used: [
-        ...new Set(agentsDispatched.map((a) => _internals11.normalizeAgentName(a)))
+        ...new Set(agentsDispatched.map((a) => _internals12.normalizeAgentName(a)))
       ],
       tasks_completed: tasksCompleted,
       tasks_total: tasksTotal,
@@ -9116,7 +9427,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
           clearTimeout(timer);
         }
         if (llmOutput?.trim()) {
-          const parsed = _internals11.parseKnowledgeRecommendationsWithDiagnostics(llmOutput);
+          const parsed = _internals12.parseKnowledgeRecommendationsWithDiagnostics(llmOutput);
           for (const diagnostic of parsed.diagnostics) {
             warn("[curator] skipped malformed recommendation line", {
               phase,
@@ -9161,7 +9472,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     const sessionId = `session-${Date.now()}`;
     const now = new Date().toISOString();
-    const summaryUpdated = await _internals11.mergeCuratorPhaseSummary(directory, {
+    const summaryUpdated = await _internals12.mergeCuratorPhaseSummary(directory, {
       phase,
       phaseDigest,
       complianceObservations,
@@ -9192,7 +9503,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     if (config.skill_generation_enabled === true && skillCandidates.length > 0) {
       try {
-        const skillModule = await import("./skill-generator-w6qd9mde.js");
+        const skillModule = await import("./skill-generator-tav44xpm.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -9210,8 +9521,8 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     const revisedSlugs = new Set;
     try {
-      const skillListResult = await _internals11.listSkills(directory);
-      const usageEntries = _internals11.readSkillUsageEntries(directory);
+      const skillListResult = await _internals12.listSkills(directory);
+      const usageEntries = _internals12.readSkillUsageEntries(directory);
       let revisionCallsThisPhase = 0;
       for (const active of skillListResult.active) {
         if (revisionCallsThisPhase >= MAX_REVISION_CALLS_PER_PHASE)
@@ -9235,8 +9546,8 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
         const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
         const violationRate = violations / skillUsage.length;
         if (violationRate > REVISION_VIOLATION_THRESHOLD && violationRate <= 0.3) {
-          const content = await _internals11.readFileAsync(active.path, "utf-8");
-          const fm = _internals11.parseDraftFrontmatter(content);
+          const content = await _internals12.readFileAsync(active.path, "utf-8");
+          const fm = _internals12.parseDraftFrontmatter(content);
           if (fm && fm.skillOrigin === "promoted_external")
             continue;
           const currentVersion = fm?.version ?? 1;
@@ -9247,7 +9558,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
             reviewerNotes: e.reviewerNotes,
             timestamp: e.timestamp
           }));
-          const result2 = await _internals11.reviseSkill({
+          const result2 = await _internals12.reviseSkill({
             directory,
             slug: active.slug,
             skillPath: active.path,
@@ -9266,7 +9577,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     } catch (revisionErr) {
       warn(`[curator] skill revision check failed: ${revisionErr instanceof Error ? revisionErr.message : String(revisionErr)}`);
     }
-    const autoRetireObservations = await _internals11.autoRetireSkills(directory, curatorKnowledgePath, revisedSlugs);
+    const autoRetireObservations = await _internals12.autoRetireSkills(directory, curatorKnowledgePath, revisedSlugs);
     if (autoRetireObservations.length > 0) {
       const retireNote = ` [${autoRetireObservations.length} skill(s) auto-retired]`;
       phaseDigest.summary += retireNote;
@@ -9473,7 +9784,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-qn7ew687.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-5gwp1ar8.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -9829,18 +10140,18 @@ async function executePostMortemActions(directory, parsed, options) {
     proposals_rejected: 0,
     proposals_skipped: 0
   };
-  const knowledgeConfig = options.knowledgeConfig ?? await _internals12.loadDefaultKnowledgeConfig();
+  const knowledgeConfig = options.knowledgeConfig ?? await _internals13.loadDefaultKnowledgeConfig();
   if (parsed.recommendations.length > 0) {
     try {
-      const knowledgeResult = await _internals12.applyCuratorKnowledgeUpdates(directory, parsed.recommendations, knowledgeConfig);
+      const knowledgeResult = await _internals13.applyCuratorKnowledgeUpdates(directory, parsed.recommendations, knowledgeConfig);
       result.knowledge_applied = knowledgeResult.applied;
       result.knowledge_skipped = knowledgeResult.skipped;
     } catch (err) {
       warnings.push(`Post-mortem knowledge actions failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
-      const entries = await _internals12.readSwarmKnowledge(directory);
-      const hiveResult = await _internals12.checkHivePromotions(entries, knowledgeConfig);
+      const entries = await _internals13.readSwarmKnowledge(directory);
+      const hiveResult = await _internals13.checkHivePromotions(entries, knowledgeConfig);
       result.hive_promotions = hiveResult.new_promotions;
       result.hive_encounters_incremented = hiveResult.encounters_incremented;
       result.hive_advancements = hiveResult.advancements;
@@ -9850,7 +10161,7 @@ async function executePostMortemActions(directory, parsed, options) {
   }
   if (parsed.queueTriage.length > 0) {
     try {
-      const proposalResult = await _internals12.applyProposalTriage(directory, parsed.queueTriage);
+      const proposalResult = await _internals13.applyProposalTriage(directory, parsed.queueTriage);
       result.proposals_approved = proposalResult.approved.length;
       result.proposals_rejected = proposalResult.rejected.length;
       result.proposals_skipped = proposalResult.skipped.length;
@@ -9863,7 +10174,7 @@ async function executePostMortemActions(directory, parsed, options) {
 async function verifyPostMortemKnowledgeActions(directory, recommendations) {
   if (recommendations.length === 0)
     return [];
-  const entries = await _internals12.readSwarmKnowledge(directory);
+  const entries = await _internals13.readSwarmKnowledge(directory);
   const activeEntries = entries.filter((entry) => isActiveStatus(entry.status));
   const exactIds = new Set(activeEntries.map((entry) => entry.id));
   const prefixMatches = new Map;
@@ -9964,7 +10275,7 @@ async function repairPostMortemActions(llmOutput, diagnostics, options) {
     ].join(`
 `);
     const repaired = await options.llmDelegate("", repairPrompt, ac.signal);
-    const parsed = _internals12.parsePostMortemActions(repaired);
+    const parsed = _internals13.parsePostMortemActions(repaired);
     if (parsed.diagnostics.length === 0) {
       return parsed;
     }
@@ -10017,7 +10328,7 @@ function collectRetrospectives(directory) {
 }
 async function collectDriftReports(directory) {
   try {
-    const reports = await _internals12.readPriorDriftReports(directory);
+    const reports = await _internals13.readPriorDriftReports(directory);
     return reports.slice(-MAX_DRIFT_REPORTS).map((report) => JSON.stringify(report, null, 2));
   } catch {
     return [];
@@ -10240,7 +10551,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings
     };
   }
-  const lock = await _internals12.acquirePostMortemLock(directory, effectivePlanId);
+  const lock = await _internals13.acquirePostMortemLock(directory, effectivePlanId);
   if (!lock.acquired) {
     return {
       success: false,
@@ -10317,20 +10628,20 @@ async function runCuratorPostMortem(directory, options = {}) {
         } finally {
           clearTimeout(timer);
         }
-        let parsedActions = _internals12.parsePostMortemActions(llmOutput);
+        let parsedActions = _internals13.parsePostMortemActions(llmOutput);
         if (parsedActions.diagnostics.length > 0) {
           warnings.push(`Post-mortem structured action parse diagnostics: ${parsedActions.diagnostics.join("; ")}`);
-          const repaired = await _internals12.repairPostMortemActions(llmOutput, parsedActions.diagnostics, options);
+          const repaired = await _internals13.repairPostMortemActions(llmOutput, parsedActions.diagnostics, options);
           if (repaired) {
             parsedActions = repaired;
             warnings.push("Post-mortem structured actions repaired by LLM.");
           }
         }
         llmSummary = parsedActions.summary;
-        const executed = await _internals12.executePostMortemActions(directory, parsedActions, options);
+        const executed = await _internals13.executePostMortemActions(directory, parsedActions, options);
         actionResult = executed.result;
         warnings.push(...executed.warnings);
-        const knowledgeVerification = await _internals12.verifyPostMortemKnowledgeActions(directory, parsedActions.recommendations);
+        const knowledgeVerification = await _internals13.verifyPostMortemKnowledgeActions(directory, parsedActions.recommendations);
         for (const item of knowledgeVerification) {
           if (item.status === "not_found" || item.status === "ambiguous_prefix" || item.status === "missing_entry_id") {
             warnings.push(`Post-mortem knowledge action ${item.action} for '${item.input_entry_id ?? "new"}' ${item.status}: ${item.reason}`);
@@ -10369,10 +10680,10 @@ ${actionSummary}`;
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         warnings.push(`LLM delegate failed, falling back to data-only report: ${msg}`);
-        reportContent = _internals12.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
+        reportContent = _internals13.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
       }
     } else {
-      reportContent = _internals12.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
+      reportContent = _internals13.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
     }
     try {
       const { mkdirSync: mkdirSync8 } = await import("fs");
@@ -10413,7 +10724,7 @@ ${actionSummary}`;
     }
   }
 }
-var _internals12 = {
+var _internals13 = {
   acquirePostMortemLock,
   collectKnowledgeSummary,
   collectRetrospectives,
@@ -10434,11 +10745,11 @@ var _internals12 = {
     return KnowledgeConfigSchema2.parse({});
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-qshyr2tc.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-5xt89z05.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig);
   },
   checkHivePromotions: async (entries, knowledgeConfig) => {
-    const { checkHivePromotions } = await import("./hive-promoter-5ngbmnrw.js");
+    const { checkHivePromotions } = await import("./hive-promoter-q899q2m6.js");
     return checkHivePromotions(entries, knowledgeConfig);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -10447,7 +10758,7 @@ var _internals12 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-w6qd9mde.js");
+    } = await import("./skill-generator-tav44xpm.js");
     const result = {
       approved: [],
       rejected: [],
@@ -10666,7 +10977,7 @@ async function checkHivePromotions(swarmEntries, config) {
     total_hive_entries: hiveEntries.length
   };
 }
-var _internals13 = {
+var _internals14 = {
   readSwarmEntries: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory)),
   checkHivePromotions,
   readCuratorSummary,
@@ -10674,15 +10985,15 @@ var _internals13 = {
 };
 function createHivePromoterHook(directory, config) {
   const hook = async (_input, _output) => {
-    const swarmEntries = await _internals13.readSwarmEntries(directory);
-    const promotionSummary = await _internals13.checkHivePromotions(swarmEntries, config);
-    const curatorSummary = await _internals13.readCuratorSummary(directory);
+    const swarmEntries = await _internals14.readSwarmEntries(directory);
+    const promotionSummary = await _internals14.checkHivePromotions(swarmEntries, config);
+    const curatorSummary = await _internals14.readCuratorSummary(directory);
     if (!curatorSummary)
       return;
     const hasActivity = promotionSummary.new_promotions > 0 || promotionSummary.encounters_incremented > 0 || promotionSummary.advancements > 0;
     if (!hasActivity)
       return;
-    await _internals13.appendCuratorRecommendation(directory, {
+    await _internals14.appendCuratorRecommendation(directory, {
       action: "promote",
       lesson: `Hive promotion: ${promotionSummary.new_promotions} new, ${promotionSummary.encounters_incremented} encounters, ${promotionSummary.advancements} advancements, ${promotionSummary.total_hive_entries} total entries`,
       reason: JSON.stringify({
@@ -11023,7 +11334,7 @@ var SKILL_AUDIENCE_RUNNER_PATTERN = /^runner:(opencode|claude|codex)$/;
 var WORKFLOW_BOOST_MIN_CONTEXT = 0.05;
 var RECENCY_DECAY_MS = 30 * 24 * 60 * 60 * 1000;
 var SKILL_FRONTMATTER_READ_BYTES = 16 * 1024;
-var _internals14 = {
+var _internals15 = {
   computeSkillRelevanceScore: null,
   rankSkillsForContext: null,
   getSkillStats: null,
@@ -11390,7 +11701,7 @@ function rankSkillsForContext(skills, taskContext, directory) {
   const results = [];
   for (const skillPath of skills) {
     const skillEntries = allEntries.filter((e) => e.skillPath === skillPath);
-    const metadata = _internals14.readSkillMetadata(skillPath, directory);
+    const metadata = _internals15.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;
@@ -11449,7 +11760,7 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
-      const meta = metadataBySkillPath?.get(sp) ?? _internals14.readSkillMetadata(sp, directory);
+      const meta = metadataBySkillPath?.get(sp) ?? _internals15.readSkillMetadata(sp, directory);
       return `  - file:${meta.path} - ${meta.name}: ${meta.description}`;
     }).join(`
 `);
@@ -11457,7 +11768,7 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   const lines = [];
   for (const skillPath of skills) {
     const stats = getSkillStats(skillPath, directory);
-    const meta = metadataBySkillPath?.get(skillPath) ?? _internals14.readSkillMetadata(skillPath, directory);
+    const meta = metadataBySkillPath?.get(skillPath) ?? _internals15.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:${meta.path} - ${meta.name}: ${meta.description} (used: ${stats.totalUsage}, compliance: ${compliancePct}%)` + (stats.topAgents.length > 0 ? ` \u2192 ${topAgentNames}` : ""));
@@ -11465,16 +11776,16 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   return lines.join(`
 `);
 }
-_internals14.computeSkillRelevanceScore = computeSkillRelevanceScore;
-_internals14.rankSkillsForContext = rankSkillsForContext;
-_internals14.getSkillStats = getSkillStats;
-_internals14.formatSkillIndexWithContext = formatSkillIndexWithContext;
-_internals14.parseSkillFrontmatter = parseSkillFrontmatter;
-_internals14.readSkillMetadata = readSkillMetadata;
-_internals14.extractSkillName = extractSkillName;
-_internals14.computeRecencyScore = computeRecencyScore;
-_internals14.computeContextMatchScore = computeContextMatchScore;
-_internals14.computeTriggerMatchBoost = computeTriggerMatchBoost;
+_internals15.computeSkillRelevanceScore = computeSkillRelevanceScore;
+_internals15.rankSkillsForContext = rankSkillsForContext;
+_internals15.getSkillStats = getSkillStats;
+_internals15.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals15.parseSkillFrontmatter = parseSkillFrontmatter;
+_internals15.readSkillMetadata = readSkillMetadata;
+_internals15.extractSkillName = extractSkillName;
+_internals15.computeRecencyScore = computeRecencyScore;
+_internals15.computeContextMatchScore = computeContextMatchScore;
+_internals15.computeTriggerMatchBoost = computeTriggerMatchBoost;
 
 // src/hooks/skill-propagation-gate.ts
 function parseSimpleYaml(content) {
@@ -11576,10 +11887,10 @@ function parseYamlValue(value) {
 }
 function loadRoutingSkills(directory, targetAgent) {
   const routingPath = path21.join(directory, ".opencode", "skill-routing.yaml");
-  if (!_internals15.existsSync(routingPath))
+  if (!_internals16.existsSync(routingPath))
     return [];
   try {
-    const content = _internals15.readFileSync(routingPath, "utf-8");
+    const content = _internals16.readFileSync(routingPath, "utf-8");
     const config = parseSimpleYaml(content);
     if (!config?.routing)
       return [];
@@ -11606,7 +11917,7 @@ var SKILL_SEARCH_ROOTS = [
   ".claude/skills"
 ];
 var MAX_SCORING_SESSION_ENTRIES = 500;
-var _internals15 = {
+var _internals16 = {
   readdirSync: fs8.readdirSync.bind(fs8),
   existsSync: fs8.existsSync.bind(fs8),
   statSync: fs8.statSync.bind(fs8),
@@ -11639,11 +11950,11 @@ function discoverAvailableSkills(directory) {
   const results = [];
   for (const root of SKILL_SEARCH_ROOTS) {
     const rootPath = path21.join(directory, root);
-    if (!_internals15.existsSync(rootPath))
+    if (!_internals16.existsSync(rootPath))
       continue;
     let entries;
     try {
-      entries = _internals15.readdirSync(rootPath);
+      entries = _internals16.readdirSync(rootPath);
     } catch {
       continue;
     }
@@ -11651,11 +11962,11 @@ function discoverAvailableSkills(directory) {
       if (entry.startsWith("."))
         continue;
       const skillDir = path21.join(rootPath, entry);
-      if (_internals15.existsSync(path21.join(skillDir, "retired.marker")) || _internals15.existsSync(path21.join(skillDir, "stale.marker")))
+      if (_internals16.existsSync(path21.join(skillDir, "retired.marker")) || _internals16.existsSync(path21.join(skillDir, "stale.marker")))
         continue;
       const skillFile = path21.join(skillDir, "SKILL.md");
       try {
-        if (_internals15.statSync(skillDir).isDirectory() && _internals15.existsSync(skillFile)) {
+        if (_internals16.statSync(skillDir).isDirectory() && _internals16.existsSync(skillFile)) {
           results.push(path21.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
         }
       } catch (err) {
@@ -11687,7 +11998,7 @@ function parseDelegationArgs(args) {
   }
   if (!targetAgent)
     return null;
-  const skillsField = prompt ? _internals15.extractSkillsFieldFromPrompt(prompt) : "";
+  const skillsField = prompt ? _internals16.extractSkillsFieldFromPrompt(prompt) : "";
   return { targetAgent, skillsField };
 }
 function extractSkillsFieldFromPrompt(prompt) {
@@ -11728,10 +12039,10 @@ function writeWarnEvent(directory, record) {
   const filePath = path21.join(directory, ".swarm", "events.jsonl");
   try {
     const dir = path21.dirname(filePath);
-    if (!_internals15.existsSync(dir)) {
-      _internals15.mkdirSync(dir, { recursive: true });
+    if (!_internals16.existsSync(dir)) {
+      _internals16.mkdirSync(dir, { recursive: true });
     }
-    _internals15.appendFileSync(filePath, `${JSON.stringify(record)}
+    _internals16.appendFileSync(filePath, `${JSON.stringify(record)}
 `, "utf-8");
   } catch (err) {
     warn(`[skill-propagation-gate] failed to write warning event: ${err instanceof Error ? err.message : String(err)}`);
@@ -11786,7 +12097,7 @@ function validateSkillReference(directory, reference, context, options) {
     };
   }
   try {
-    const root = _internals15.realpathSync(directory);
+    const root = _internals16.realpathSync(directory);
     const lexicalPath = path21.resolve(root, withoutPrefix);
     if (!isWithinRoot(root, lexicalPath)) {
       return {
@@ -11794,10 +12105,10 @@ function validateSkillReference(directory, reference, context, options) {
         reason: "skill path resolves outside the project"
       };
     }
-    if (!_internals15.existsSync(lexicalPath) || !_internals15.statSync(lexicalPath).isFile()) {
+    if (!_internals16.existsSync(lexicalPath) || !_internals16.statSync(lexicalPath).isFile()) {
       return { valid: false, reason: "skill file does not exist" };
     }
-    const realPath = _internals15.realpathSync(lexicalPath);
+    const realPath = _internals16.realpathSync(lexicalPath);
     if (!isWithinRoot(root, realPath)) {
       return {
         valid: false,
@@ -11806,7 +12117,7 @@ function validateSkillReference(directory, reference, context, options) {
     }
     const normalizedPath = withoutPrefix.replace(/^\.\//, "");
     const validatedMetadataPath = path21.relative(root, realPath).replace(/\\/g, "/");
-    const metadata = _internals15.readSkillMetadata(validatedMetadataPath, root);
+    const metadata = _internals16.readSkillMetadata(validatedMetadataPath, root);
     if (metadata.frontmatterStatus !== "valid" && metadata.frontmatterStatus !== "absent") {
       return {
         valid: false,
@@ -11838,18 +12149,18 @@ async function validateExplicitSkillReferencesBefore(directory, input, config) {
   if (!agentRaw || stripKnownSwarmPrefix(agentRaw) !== "architect") {
     return { blocked: false, reason: null };
   }
-  const parsed = _internals15.parseDelegationArgs(input.args);
+  const parsed = _internals16.parseDelegationArgs(input.args);
   if (!parsed)
     return { blocked: false, reason: null };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
-  if (!_internals15.SKILL_CAPABLE_AGENTS.has(targetBase)) {
+  if (!_internals16.SKILL_CAPABLE_AGENTS.has(targetBase)) {
     return { blocked: false, reason: null };
   }
   const skillsValue = parsed.skillsField.trim();
   if (!skillsValue || skillsValue.toLowerCase() === "none") {
     return { blocked: false, reason: null };
   }
-  const fileReferences = _internals15.extractFileSkillReferences(skillsValue);
+  const fileReferences = _internals16.extractFileSkillReferences(skillsValue);
   if (fileReferences.length === 0) {
     return { blocked: false, reason: null, validatedSkillPaths: [] };
   }
@@ -11862,7 +12173,7 @@ async function validateExplicitSkillReferencesBefore(directory, input, config) {
   const context = resolveSkillAudienceContext(config);
   const validatedSkillPaths = [];
   for (const reference of fileReferences) {
-    const result = _internals15.validateSkillReference(directory, reference, context, {
+    const result = _internals16.validateSkillReference(directory, reference, context, {
       enforceAudience: true
     });
     if (!result.valid) {
@@ -11907,18 +12218,18 @@ async function skillPropagationGateBefore(directory, input, config) {
   const baseAgent = stripKnownSwarmPrefix(agentRaw);
   if (baseAgent !== "architect")
     return { blocked: false, reason: null, recommendedSkills: undefined };
-  const parsed = _internals15.parseDelegationArgs(input.args);
+  const parsed = _internals16.parseDelegationArgs(input.args);
   if (!parsed)
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
-  if (!_internals15.SKILL_CAPABLE_AGENTS.has(targetBase))
+  if (!_internals16.SKILL_CAPABLE_AGENTS.has(targetBase))
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const sessionID = typeof input.sessionID === "string" ? input.sessionID : "unknown";
   const audienceContext = resolveSkillAudienceContext(config);
   const availableSkills = [];
   const metadataBySkillPath = new Map;
-  for (const skillPath of _internals15.discoverAvailableSkills(directory)) {
-    const validation = _internals15.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
+  for (const skillPath of _internals16.discoverAvailableSkills(directory)) {
+    const validation = _internals16.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
     if (!validation.valid || !validation.skillPath)
       continue;
     availableSkills.push(validation.skillPath);
@@ -11929,7 +12240,7 @@ async function skillPropagationGateBefore(directory, input, config) {
   const skillsValue = parsed.skillsField.trim();
   if (skillsValue && skillsValue.toLowerCase() !== "none") {
     const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
-    const taskId = _internals15.extractTaskIdFromPrompt(prompt);
+    const taskId = _internals16.extractTaskIdFromPrompt(prompt);
     const skillPaths = explicitIntegrity.validatedSkillPaths ?? [];
     let coderSkillPaths = [];
     if (prompt) {
@@ -11938,19 +12249,19 @@ async function skillPropagationGateBefore(directory, input, config) {
         const trimmed = line.trim();
         if (trimmed.startsWith("SKILLS_USED_BY_CODER:")) {
           const fieldVal = trimmed.slice("SKILLS_USED_BY_CODER:".length).trim();
-          coderSkillPaths = _internals15.parseSkillPaths(fieldVal);
+          coderSkillPaths = _internals16.parseSkillPaths(fieldVal);
           break;
         }
       }
     }
     const safeCoderSkillPaths = coderSkillPaths.flatMap((skillPath) => {
-      const validation = _internals15.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: false });
+      const validation = _internals16.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: false });
       return validation.valid && validation.skillPath ? [validation.skillPath] : [];
     });
     const allPaths = [...new Set([...skillPaths, ...safeCoderSkillPaths])];
     for (const skillPath of allPaths) {
       try {
-        _internals15.appendSkillUsageEntry(directory, {
+        _internals16.appendSkillUsageEntry(directory, {
           skillPath,
           agentName: targetBase,
           taskID: taskId,
@@ -11967,18 +12278,18 @@ async function skillPropagationGateBefore(directory, input, config) {
   let scored = [];
   if (skillsValue.toLowerCase() !== "none" && availableSkills.length > 0) {
     try {
-      const sessionEntries = _internals15.readSkillUsageEntriesTail(directory, {
+      const sessionEntries = _internals16.readSkillUsageEntriesTail(directory, {
         sessionID
       });
-      if (sessionEntries.length > _internals15.MAX_SCORING_SESSION_ENTRIES) {
+      if (sessionEntries.length > _internals16.MAX_SCORING_SESSION_ENTRIES) {
         scoringSkipped = true;
-        warn(`[skill-propagation-gate] skipping scoring \u2014 tail window has ${sessionEntries.length} session entries (limit: ${_internals15.MAX_SCORING_SESSION_ENTRIES})`);
+        warn(`[skill-propagation-gate] skipping scoring \u2014 tail window has ${sessionEntries.length} session entries (limit: ${_internals16.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 = metadataBySkillPath.get(skillPath) ?? _internals15.readSkillMetadata(skillPath, directory);
-          const score = _internals15.computeSkillRelevanceScore(skillPath, prompt, skillEntries, metadata);
+          const metadata = metadataBySkillPath.get(skillPath) ?? _internals16.readSkillMetadata(skillPath, directory);
+          const score = _internals16.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) {
@@ -11992,11 +12303,11 @@ async function skillPropagationGateBefore(directory, input, config) {
     }
   }
   try {
-    const routingPaths = _internals15.loadRoutingSkills(directory, targetBase);
+    const routingPaths = _internals16.loadRoutingSkills(directory, targetBase);
     if (routingPaths.length > 0) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
-        const validation = _internals15.validateSkillReference(directory, routingPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
+        const validation = _internals16.validateSkillReference(directory, routingPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
         if (!validation.valid || !validation.skillPath)
           continue;
         const eligibleRoutingPath = validation.skillPath;
@@ -12004,7 +12315,7 @@ async function skillPropagationGateBefore(directory, input, config) {
           metadataBySkillPath.set(eligibleRoutingPath, validation.metadata);
         }
         const routedSkillDir = path21.dirname(path21.join(directory, eligibleRoutingPath));
-        if (_internals15.existsSync(path21.join(routedSkillDir, "retired.marker")) || _internals15.existsSync(path21.join(routedSkillDir, "stale.marker")))
+        if (_internals16.existsSync(path21.join(routedSkillDir, "retired.marker")) || _internals16.existsSync(path21.join(routedSkillDir, "stale.marker")))
           continue;
         if (!existingPaths.has(eligibleRoutingPath)) {
           scored.push({
@@ -12030,12 +12341,12 @@ async function skillPropagationGateBefore(directory, input, config) {
       } else if (typeof scored !== "undefined" && scored.length > 0) {
         skillsForIndex = scored.map((r) => r.skillPath);
       }
-      const formattedIndex = _internals15.formatSkillIndexWithContext(skillsForIndex, directory, metadataBySkillPath);
+      const formattedIndex = _internals16.formatSkillIndexWithContext(skillsForIndex, directory, metadataBySkillPath);
       if (formattedIndex.length > 0) {
         const contextPath = path21.join(directory, ".swarm", "context.md");
         let existingContent = "";
-        if (_internals15.existsSync(contextPath)) {
-          existingContent = _internals15.readFileSync(contextPath, "utf-8");
+        if (_internals16.existsSync(contextPath)) {
+          existingContent = _internals16.readFileSync(contextPath, "utf-8");
         }
         const sectionHeader = "## Available Skills";
         const newSection = `${sectionHeader}
@@ -12055,10 +12366,10 @@ ${newSection}`;
           }
         }
         const swarmDir = path21.dirname(contextPath);
-        if (!_internals15.existsSync(swarmDir)) {
-          _internals15.mkdirSync(swarmDir, { recursive: true });
+        if (!_internals16.existsSync(swarmDir)) {
+          _internals16.mkdirSync(swarmDir, { recursive: true });
         }
-        _internals15.writeFileSync(contextPath, updatedContent, "utf-8");
+        _internals16.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)}`);
@@ -12084,7 +12395,7 @@ ${newSection}`;
   });
   const warningMsg = `Skill propagation warning: Delegating to ${targetBase} without SKILLS field. ` + `Available skills: ${skillNames.join(", ")}`;
   try {
-    _internals15.writeWarnEvent(directory, {
+    _internals16.writeWarnEvent(directory, {
       type: "skill_propagation_warn",
       timestamp: new Date().toISOString(),
       tool: toolName,
@@ -12116,17 +12427,17 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
   const validatedProvenancePaths = (fieldValue) => {
     if (remainingProvenanceValidationBudget <= 0)
       return [];
-    const references = _internals15.parseSkillPaths(fieldValue).slice(0, remainingProvenanceValidationBudget);
+    const references = _internals16.parseSkillPaths(fieldValue).slice(0, remainingProvenanceValidationBudget);
     remainingProvenanceValidationBudget -= references.length;
     return references.flatMap((reference) => {
-      const validation = _internals15.validateSkillReference(directory, reference, audienceContext, { enforceAudience: true });
+      const validation = _internals16.validateSkillReference(directory, reference, audienceContext, { enforceAudience: true });
       return validation.valid && validation.skillPath ? [validation.skillPath] : [];
     });
   };
   let dedupKeys = new Set;
   let existingEntries = [];
   try {
-    existingEntries = _internals15.readSkillUsageEntriesTail(directory, {
+    existingEntries = _internals16.readSkillUsageEntriesTail(directory, {
       sessionID
     });
     dedupKeys = new Set(existingEntries.map((e, i) => {
@@ -12197,7 +12508,7 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
         if (isDuplicate(skillPath, "reviewer", resolvedTaskID))
           continue;
         try {
-          _internals15.appendSkillUsageEntry(directory, {
+          _internals16.appendSkillUsageEntry(directory, {
             skillPath,
             agentName: "reviewer",
             taskID: resolvedTaskID,
@@ -12242,14 +12553,14 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
       }
       if (currentTargetAgent && skillsField && skillsField.toLowerCase() !== "none") {
         const skillPaths = validatedProvenancePaths(skillsField);
-        const taskId = _internals15.extractTaskIdFromPrompt(text);
+        const taskId = _internals16.extractTaskIdFromPrompt(text);
         for (const skillPath of skillPaths) {
           if (hadRecordingError)
             break;
           if (isDuplicate(skillPath, currentTargetAgent, taskId))
             continue;
           try {
-            _internals15.appendSkillUsageEntry(directory, {
+            _internals16.appendSkillUsageEntry(directory, {
               skillPath,
               agentName: currentTargetAgent,
               taskID: taskId,
@@ -12269,18 +12580,18 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
     break;
   }
 }
-_internals15.skillPropagationGateBefore = skillPropagationGateBefore;
-_internals15.skillPropagationTransformScan = skillPropagationTransformScan;
-_internals15.writeWarnEvent = writeWarnEvent;
-_internals15.discoverAvailableSkills = discoverAvailableSkills;
-_internals15.parseDelegationArgs = parseDelegationArgs;
-_internals15.parseSkillPaths = parseSkillPaths;
-_internals15.extractFileSkillReferences = extractFileSkillReferences;
-_internals15.validateSkillReference = validateSkillReference;
-_internals15.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
-_internals15.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
-_internals15.formatSkillIndexWithContext = formatSkillIndexWithContext;
-_internals15.loadRoutingSkills = loadRoutingSkills;
+_internals16.skillPropagationGateBefore = skillPropagationGateBefore;
+_internals16.skillPropagationTransformScan = skillPropagationTransformScan;
+_internals16.writeWarnEvent = writeWarnEvent;
+_internals16.discoverAvailableSkills = discoverAvailableSkills;
+_internals16.parseDelegationArgs = parseDelegationArgs;
+_internals16.parseSkillPaths = parseSkillPaths;
+_internals16.extractFileSkillReferences = extractFileSkillReferences;
+_internals16.validateSkillReference = validateSkillReference;
+_internals16.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
+_internals16.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
+_internals16.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals16.loadRoutingSkills = loadRoutingSkills;
 
 // src/hooks/micro-reflector.ts
 var REFLECT_OUTCOMES = new Set([
@@ -12347,7 +12658,7 @@ function hashContent(content) {
 async function canonicalExistingPath(candidate) {
   let resolved = path23.resolve(candidate);
   try {
-    resolved = await _internals16.realpath(resolved);
+    resolved = await _internals17.realpath(resolved);
   } catch {}
   return resolved;
 }
@@ -13128,9 +13439,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     } catch {}
   }
   if (!options?.skipAutoPromotion) {
-    await _internals16.runAutoPromotion(directory, config);
+    await _internals17.runAutoPromotion(directory, config);
     if (phaseInfo.phase_number > 0) {
-      await _internals16.runAutoDemotion(directory, config, phaseInfo.phase_number);
+      await _internals17.runAutoDemotion(directory, config, phaseInfo.phase_number);
     }
   }
   return { stored, reinforced, skipped, rejected, quarantined };
@@ -13245,7 +13556,7 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
         }
         inFlightEvidenceEntries.add(evidenceKey);
         try {
-          await _internals16.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
+          await _internals17.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
             llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
             enrichmentQuota: options.enrichmentQuota
           });
@@ -13277,14 +13588,14 @@ function createKnowledgeCuratorHook(directory, config, 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 _internals16.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
+    await _internals17.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
       llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
       enrichmentQuota: options.enrichmentQuota
     });
   };
   return safeHook(handler);
 }
-var _internals16 = {
+var _internals17 = {
   isWriteToEvidenceFile,
   curateAndStoreSwarm,
   runAutoPromotion,
@@ -13323,7 +13634,7 @@ async function runFinalizeRewardSweep(args) {
       return result;
     }
     const timestamp = args.timestamp ?? new Date().toISOString();
-    const provider = _internals17.createConfiguredMemoryProvider(directory, memoryConfig);
+    const provider = _internals18.createConfiguredMemoryProvider(directory, memoryConfig);
     try {
       result.swept = true;
       for (const taskId of taskIds) {
@@ -13343,7 +13654,7 @@ async function runFinalizeRewardSweep(args) {
         }
         let taskRewarded = 0;
         for (const runId of runIds) {
-          const { memoriesRewarded } = await _internals17.applyCouncilReward(provider, {
+          const { memoriesRewarded } = await _internals18.applyCouncilReward(provider, {
             runId,
             unitId: taskId,
             reward: FINALIZE_NEGATIVE_TERMINAL_REWARD,
@@ -13369,7 +13680,7 @@ async function runFinalizeRewardSweep(args) {
   }
   return result;
 }
-var _internals17 = {
+var _internals18 = {
   createConfiguredMemoryProvider,
   applyCouncilReward
 };
@@ -14396,7 +14707,7 @@ async function reconcileStaleActiveSkills(directory, options = {}) {
       continue;
     }
     try {
-      const regen = await _internals18.regenerateSkill(directory, skill.slug, {
+      const regen = await _internals19.regenerateSkill(directory, skill.slug, {
         evaluate: false
       });
       if (regen.regenerated) {
@@ -14646,7 +14957,7 @@ async function runSkillImprover(req) {
     autoApply
   };
 }
-var _internals18 = {
+var _internals19 = {
   runSkillImprover,
   buildDeterministicProposal,
   buildLLMProposalFrame,
@@ -15049,13 +15360,13 @@ var write_retro = createSwarmTool({
         task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
         metadata: args.metadata
       };
-      return await _internals19.executeWriteRetro(writeRetroArgs, directory);
+      return await _internals20.executeWriteRetro(writeRetroArgs, directory);
     } catch {
       return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
     }
   }
 });
-var _internals19 = {
+var _internals20 = {
   executeWriteRetro,
   write_retro
 };
@@ -15364,8 +15675,8 @@ async function runFinalizeStage(ctx) {
   ];
   ctx.curationSucceeded = false;
   try {
-    ctx.curationResult = await _internals20.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
-      llmDelegate: _internals20.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
+    ctx.curationResult = await _internals21.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
+      llmDelegate: _internals21.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
       enrichmentQuota: {
         maxCalls: ctx.config.enrichment.max_calls_per_day,
         window: ctx.config.enrichment.quota_window
@@ -15384,7 +15695,7 @@ async function runFinalizeStage(ctx) {
     if (ctx.config.hive_enabled === false) {} else {
       try {
         const entries = await readKnowledge(resolveSwarmKnowledgePath(ctx.directory));
-        const result = await _internals20.checkHivePromotions(entries, ctx.config);
+        const result = await _internals21.checkHivePromotions(entries, ctx.config);
         ctx.hivePromoted = result.new_promotions;
       } catch (hiveErr) {
         const msg = hiveErr instanceof Error ? hiveErr.message : String(hiveErr);
@@ -15405,7 +15716,7 @@ async function runFinalizeStage(ctx) {
   ctx.knowledgeSkillHint = ctx.sessionKnowledgeCreated > 0 ? `${ctx.sessionKnowledgeCreated} knowledge entries created this session. Consider running skill_improve or skill_generate to compile mature entries into skills.` : "";
   if (ctx.runSkillReview) {
     try {
-      const { config: loadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
+      const { config: loadedConfig } = _internals21.loadPluginConfigWithMeta(ctx.directory);
       const skillImproverConfig = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
       const skillReviewResult = await runAbortableSkillReview({
         directory: ctx.directory,
@@ -15468,7 +15779,7 @@ async function runFinalizeStage(ctx) {
     }
     if (!ctx.planAlreadyDone || ctx.guaranteeResult.closedPhaseIds.length > 0 || ctx.guaranteeResult.closedTaskIds.length > 0) {
       try {
-        await _internals20.closePlanTerminalState(ctx.directory, ctx.planData, {
+        await _internals21.closePlanTerminalState(ctx.directory, ctx.planData, {
           closedPhaseIds: ctx.guaranteeResult.closedPhaseIds,
           closedTaskIds: ctx.guaranteeResult.closedTaskIds,
           originalStatuses: ctx.originalStatuses
@@ -15485,11 +15796,11 @@ async function runFinalizeStage(ctx) {
   }
   try {
     const { CuratorConfigSchema: CCS } = await import("./schema-aymfdrsb.js");
-    const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
+    const { config: pmLoadedConfig } = _internals21.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
-      const pmResult = await _internals20.runCuratorPostMortem(ctx.directory, {
-        llmDelegate: _internals20.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
+      const pmResult = await _internals21.runCuratorPostMortem(ctx.directory, {
+        llmDelegate: _internals21.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
         scope: "project",
         sessionID: ctx.options.sessionID
       });
@@ -15515,7 +15826,7 @@ async function copySqliteSafe(srcPath, destPath, laneEnv) {
   }
   let checkpointVerified = false;
   try {
-    const result = _internals20.spawnSync("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
+    const result = _internals21.spawnSync("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
       cwd: path29.dirname(srcPath),
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -15686,7 +15997,7 @@ async function runArchiveEvidenceRetention(ctx) {
   let maxAgeDays = 30;
   let maxBundles = 10;
   try {
-    const { config: evidenceLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
+    const { config: evidenceLoadedConfig } = _internals21.loadPluginConfigWithMeta(ctx.directory);
     const evidenceCfg = evidenceLoadedConfig.evidence ?? {};
     if (typeof evidenceCfg.max_age_days === "number") {
       maxAgeDays = evidenceCfg.max_age_days;
@@ -15696,7 +16007,7 @@ async function runArchiveEvidenceRetention(ctx) {
     }
   } catch {}
   try {
-    await _internals20.archiveEvidence(ctx.directory, maxAgeDays, maxBundles);
+    await _internals21.archiveEvidence(ctx.directory, maxAgeDays, maxBundles);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     ctx.warnings.push(`Evidence retention archive failed: ${msg}`);
@@ -15899,9 +16210,9 @@ async function runAlignStage(ctx) {
   const pruneBranches = ctx.args.includes("--prune-branches");
   let gitAlignResult = "";
   const prunedBranches = [];
-  const gitStatus = _internals20.getGitRepositoryStatus(ctx.directory);
+  const gitStatus = _internals21.getGitRepositoryStatus(ctx.directory);
   if (gitStatus.isRepo) {
-    const aggressiveResult = await _internals20.resetToMainAfterMerge(ctx.directory, {
+    const aggressiveResult = await _internals21.resetToMainAfterMerge(ctx.directory, {
       pruneBranches
     });
     if (aggressiveResult.success) {
@@ -15913,7 +16224,7 @@ async function runAlignStage(ctx) {
         ctx.warnings.push("Uncommitted changes were discarded during git alignment");
       }
     } else {
-      const alignResult = await _internals20.resetToRemoteBranch(ctx.directory, {
+      const alignResult = await _internals21.resetToRemoteBranch(ctx.directory, {
         pruneBranches
       });
       gitAlignResult = alignResult.message;
@@ -15973,7 +16284,7 @@ async function handleCloseCommand(directory, args, options = {}) {
   let finalizeLock = {
     acquired: false
   };
-  finalizeLock = await _internals20.acquireFinalizeLock(directory);
+  finalizeLock = await _internals21.acquireFinalizeLock(directory);
   if (!finalizeLock.acquired) {
     return `\u274C Another /swarm finalize is already running for this project. If you are certain no other run is active, wait for the lock to expire or remove the stale lock and retry.`;
   }
@@ -16004,7 +16315,7 @@ This project was already finalized in a previous /swarm close run. The plan has
     if (planExists) {
       planAlreadyDone = phases.length > 0 && phases.every((p) => p.status === "complete" || p.status === "completed" || p.status === "blocked" || p.status === "closed");
     }
-    const { config: loadedConfig } = _internals20.loadPluginConfigWithMeta(directory);
+    const { config: loadedConfig } = _internals21.loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
       directory,
@@ -16048,7 +16359,7 @@ This project was already finalized in a previous /swarm close run. The plan has
       args
     };
     await runFinalizeStage(ctx);
-    await _internals20.runFinalizeRewardSweep({
+    await _internals21.runFinalizeRewardSweep({
       directory,
       closedTaskIds: ctx.guaranteeResult.closedTaskIds,
       memoryConfig: loadedConfig.memory
@@ -16129,9 +16440,9 @@ This project was already finalized in a previous /swarm close run. The plan has
     }
     const sessionIdsToEnd = [...swarmState.agentSessions.keys()];
     for (const sessionId of sessionIdsToEnd) {
-      _internals20.endAgentSession(sessionId);
+      _internals21.endAgentSession(sessionId);
     }
-    _internals20.resetSwarmStatePreservingSingletons();
+    _internals21.resetSwarmStatePreservingSingletons();
     const retroWarnings = ctx.warnings.filter((w) => w.includes("Retrospective write") || w.includes("retrospective write") || w.includes("Session retrospective"));
     const otherWarnings = ctx.warnings.filter((w) => !w.includes("Retrospective write") && !w.includes("retrospective write") && !w.includes("Session retrospective"));
     let warningMsg = "";
@@ -16200,7 +16511,7 @@ async function acquireFinalizeLock(directory) {
   }
   return { acquired: false };
 }
-var _internals20 = {
+var _internals21 = {
   ACTIVE_STATE_DIRS_TO_CLEAN,
   countSessionKnowledgeEntries,
   CLOSE_SKILL_REVIEW_TIMEOUT_MS,
@@ -16228,7 +16539,7 @@ var _internals20 = {
   endAgentSession,
   spawnSync: (cmd, args, options) => {
     const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
-    return child_process2.spawnSync(cmd, args, {
+    return child_process3.spawnSync(cmd, args, {
       ...options,
       env: mergedEnv
     });
@@ -16256,7 +16567,7 @@ var MODES = new Set(CODEBASE_REVIEW_MODES);
 var DEFAULT_MODE = "phase0";
 var DEFAULT_SCOPE = "repository root";
 var FLAG_VALUE_MISSING = (token) => `Flag "${token}" requires a value`;
-var USAGE = `Usage: /swarm codebase-review [scope] [--mode phase0|complete|defect|security|correctness|testing|ui|performance|ai-slop|enhancements|custom] [--tracks <list>] [--continue <run-id>] [--json] [--skip-update] [--allow-dirty]
+var USAGE2 = `Usage: /swarm codebase-review [scope] [--mode phase0|complete|defect|security|correctness|testing|ui|performance|ai-slop|enhancements|custom] [--tracks <list>] [--continue <run-id>] [--json] [--skip-update] [--allow-dirty]
 
 Run the codebase-review-swarm workflow in the current repository.
 
@@ -16349,12 +16660,12 @@ function parseArgs(args) {
 async function handleCodebaseReviewCommand(_directory, args) {
   const parsed = parseArgs(args);
   if (parsed.help) {
-    return USAGE;
+    return USAGE2;
   }
   if (parsed.error) {
     return `Error: ${parsed.error}
 
-${USAGE}`;
+${USAGE2}`;
   }
   const scope = sanitizeText(parsed.rest.join(" "), MAX_SCOPE_LEN) || DEFAULT_SCOPE;
   return [
@@ -16787,7 +17098,7 @@ function parseArgs2(args) {
   }
   return out;
 }
-var USAGE2 = [
+var USAGE3 = [
   "Usage: /swarm council <question> [--spec-review]",
   "",
   "  question         The question to put to the council",
@@ -16800,7 +17111,7 @@ async function handleCouncilCommand(_directory, args) {
   const parsed = parseArgs2(args);
   const question = sanitizeQuestion(parsed.rest.join(" "));
   if (!question) {
-    return USAGE2;
+    return USAGE3;
   }
   const tokens = ["MODE: COUNCIL"];
   if (parsed.preset) {
@@ -16818,17 +17129,17 @@ import * as fs11 from "fs";
 import * as path33 from "path";
 
 // src/turbo/epic/cochange-source.ts
-import * as child_process4 from "child_process";
+import * as child_process5 from "child_process";
 import { promisify as promisify2 } from "util";
 
 // src/tools/co-change-analyzer.ts
-import * as child_process3 from "child_process";
+import * as child_process4 from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
 import { readdir, readFile as readFile10, stat as stat3 } from "fs/promises";
 import * as path32 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
-  return promisify(child_process3.execFile);
+  return promisify(child_process4.execFile);
 }
 async function parseGitLog(directory, maxCommits) {
   const commitMap = new Map;
@@ -17046,9 +17357,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals21.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals21.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
-  const staticEdges = await _internals21.getStaticEdges(directory);
+  const commitMap = await _internals22.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals22.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
+  const staticEdges = await _internals22.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -17164,11 +17475,11 @@ var co_change_analyzer = createSwarmTool({
       npmiThreshold,
       maxCommitsToAnalyze
     };
-    const pairs = await _internals21.detectDarkMatter(directory, options);
-    return _internals21.formatDarkMatterOutput(pairs);
+    const pairs = await _internals22.detectDarkMatter(directory, options);
+    return _internals22.formatDarkMatterOutput(pairs);
   }
 });
-var _internals21 = {
+var _internals22 = {
   parseGitLog,
   buildCoChangeMatrix,
   getStaticEdges,
@@ -17178,14 +17489,14 @@ var _internals21 = {
 };
 
 // src/turbo/epic/cochange-source.ts
-var execFileAsync = promisify2(child_process4.execFile);
+var execFileAsync = promisify2(child_process5.execFile);
 var MAX_TRACKED_DIRS = 10;
 var GIT_HEAD_TIMEOUT_MS = 5000;
 var DEFAULT_MAX_COMMITS = 500;
 var cache = new Map;
 async function readGitHead(directory) {
   try {
-    const { stdout } = await _internals22.execFile("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await _internals23.execFile("git", ["rev-parse", "HEAD"], {
       cwd: directory,
       timeout: GIT_HEAD_TIMEOUT_MS
     });
@@ -17211,9 +17522,9 @@ async function getCoChangeData(directory, options) {
   let entries;
   let commitsObserved;
   try {
-    const commitMap = await _internals22.parseGitLog(directory, maxCommits);
+    const commitMap = await _internals23.parseGitLog(directory, maxCommits);
     commitsObserved = commitMap.size;
-    const matrix = _internals22.buildCoChangeMatrix(commitMap);
+    const matrix = _internals23.buildCoChangeMatrix(commitMap);
     entries = Array.from(matrix.values());
   } catch {
     return { pairs: [], commitsObserved: 0 };
@@ -17237,10 +17548,10 @@ async function getCoChangePairs(directory, options) {
   const data = await getCoChangeData(directory, options);
   return data.pairs;
 }
-var _internals22 = {
+var _internals23 = {
   execFile: execFileAsync,
-  parseGitLog: _internals21.parseGitLog,
-  buildCoChangeMatrix: _internals21.buildCoChangeMatrix
+  parseGitLog: _internals22.parseGitLog,
+  buildCoChangeMatrix: _internals22.buildCoChangeMatrix
 };
 
 // src/turbo/epic/cochange-conflict.ts
@@ -17522,7 +17833,7 @@ async function handleCouplingCommand(directory, args) {
 
 Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>] [--format markdown|json] [--persist]`;
   }
-  const plan = await _internals23.loadPlanJsonOnly(directory);
+  const plan = await _internals24.loadPlanJsonOnly(directory);
   if (plan === null) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` to create one before measuring coupling.";
   }
@@ -17546,7 +17857,7 @@ Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>
     const scope = scopeFiles ?? task.files_touched ?? [];
     return { id: task.id, scope };
   });
-  const cochangePairs = await _internals23.getCoChangePairs(directory);
+  const cochangePairs = await _internals24.getCoChangePairs(directory);
   const report = computeCouplingReport(tasks, cochangePairs, {
     npmi: parsed.threshold,
     minCoChanges: parsed.minCoChanges
@@ -17585,13 +17896,13 @@ _Warning: failed to persist report (${persistStatus.error})._`;
   }
   return `${formatCouplingReportMarkdown(report)}${persistTrailer}`;
 }
-var _internals23 = {
+var _internals24 = {
   loadPlanJsonOnly,
   getCoChangePairs
 };
 
 // src/commands/curate.ts
-var _internals24 = {
+var _internals25 = {
   checkHivePromotions,
   readKnowledge,
   resolveSwarmKnowledgePath,
@@ -17599,8 +17910,8 @@ var _internals24 = {
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
       import("./schema-aymfdrsb.js"),
-      import("./curator-qshyr2tc.js"),
-      import("./curator-llm-factory-2xgznxyw.js")
+      import("./curator-5xt89z05.js"),
+      import("./curator-llm-factory-pnhvf3s3.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -17608,15 +17919,15 @@ var _internals24 = {
 async function handleCurateCommand(directory, _args, options) {
   try {
     const config = KnowledgeConfigSchema.parse({});
-    const swarmPath = _internals24.resolveSwarmKnowledgePath(directory);
-    const swarmEntries = await _internals24.readKnowledge(swarmPath) ?? [];
-    const summary = await _internals24.checkHivePromotions(swarmEntries, config);
+    const swarmPath = _internals25.resolveSwarmKnowledgePath(directory);
+    const swarmEntries = await _internals25.readKnowledge(swarmPath) ?? [];
+    const summary = await _internals25.checkHivePromotions(swarmEntries, config);
     if (options?.sessionID) {
       let onDemandPhase = 1;
       try {
-        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals24.loadCuratorDeps();
+        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals25.loadCuratorDeps();
         const curatorConfig = CuratorConfigSchema.parse({});
-        const priorSummary = await _internals24.readSwarmFileAsync(directory, "curator-summary.json");
+        const priorSummary = await _internals25.readSwarmFileAsync(directory, "curator-summary.json");
         if (priorSummary) {
           try {
             const parsed = JSON.parse(priorSummary);
@@ -17627,7 +17938,7 @@ async function handleCurateCommand(directory, _args, options) {
         }
         let planPhaseCount = Infinity;
         try {
-          const planRaw = await _internals24.readSwarmFileAsync(directory, "plan.json");
+          const planRaw = await _internals25.readSwarmFileAsync(directory, "plan.json");
           if (planRaw) {
             const plan = JSON.parse(planRaw);
             if (Array.isArray(plan.phases))
@@ -17646,8 +17957,8 @@ async function handleCurateCommand(directory, _args, options) {
           summary.knowledge_skipped = applied.skipped;
           summary.curator_phase = onDemandPhase;
           try {
-            const updatedEntries = await _internals24.readKnowledge(swarmPath) ?? [];
-            const postUpdateHive = await _internals24.checkHivePromotions(updatedEntries, config);
+            const updatedEntries = await _internals25.readKnowledge(swarmPath) ?? [];
+            const postUpdateHive = await _internals25.checkHivePromotions(updatedEntries, config);
             summary.new_promotions += postUpdateHive.new_promotions;
             summary.encounters_incremented += postUpdateHive.encounters_incremented;
             summary.advancements += postUpdateHive.advancements;
@@ -17712,7 +18023,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals21.detectDarkMatter(directory, options);
+    pairs = await _internals22.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -17755,7 +18066,7 @@ var PROFILES = new Set([
 var DEFAULT_PROFILE = "standard";
 var DEFAULT_MAX_EXPLORERS = 6;
 var FULL_PROFILE_DEFAULT_MAX_EXPLORERS = 8;
-var USAGE3 = `Usage: /swarm deep-dive <scope> [--profile standard|security|ux|architecture|full] [--max-explorers N] [--json] [--skip-update] [--allow-dirty]
+var USAGE4 = `Usage: /swarm deep-dive <scope> [--profile standard|security|ux|architecture|full] [--max-explorers N] [--json] [--skip-update] [--allow-dirty]
 
 Run a bounded, evidence-backed deep dive on an application section.
 
@@ -17844,11 +18155,11 @@ async function handleDeepDiveCommand(_directory, args) {
   if (parsed.error) {
     return `Error: ${parsed.error}
 
-${USAGE3}`;
+${USAGE4}`;
   }
   const scope = sanitizeScope(parsed.rest.join(" "));
   if (!scope) {
-    return USAGE3;
+    return USAGE4;
   }
   if (parsed.profile === "full" && !parsed.maxExplorersExplicit) {
     parsed.maxExplorers = FULL_PROFILE_DEFAULT_MAX_EXPLORERS;
@@ -17865,7 +18176,7 @@ var DEFAULT_MAX_RESEARCHERS = 3;
 var EXHAUSTIVE_DEFAULT_MAX_RESEARCHERS = 5;
 var DEFAULT_ROUNDS = 2;
 var EXHAUSTIVE_DEFAULT_ROUNDS = 3;
-var USAGE4 = `Usage: /swarm deep-research <question> [--depth standard|exhaustive] [--max-researchers 1..6] [--rounds 1..4] [--brief]
+var USAGE5 = `Usage: /swarm deep-research <question> [--depth standard|exhaustive] [--max-researchers 1..6] [--rounds 1..4] [--brief]
 
 Run a multi-source, fact-checked deep research pass and synthesize a cited report.
 
@@ -17959,11 +18270,11 @@ async function handleDeepResearchCommand(_directory, args) {
   if (parsed.error) {
     return `Error: ${parsed.error}
 
-${USAGE4}`;
+${USAGE5}`;
   }
   const question = sanitizeQuestion2(parsed.rest.join(" "));
   if (!question) {
-    return USAGE4;
+    return USAGE5;
   }
   if (parsed.depth === "exhaustive") {
     if (!parsed.maxResearchersExplicit)
@@ -17976,7 +18287,7 @@ ${USAGE4}`;
 
 // src/commands/design-docs.ts
 var MAX_DESC_LEN = 2000;
-var USAGE5 = `Usage: /swarm design-docs <description> [--out <dir>] [--lang <name>] [--update]
+var USAGE6 = `Usage: /swarm design-docs <description> [--out <dir>] [--lang <name>] [--update]
 
 Generate or sync language-agnostic design docs for the project under build:
   <out>/domain.md, <out>/technical-spec.md, <out>/behavior-spec.md,
@@ -18068,35 +18379,35 @@ async function handleDesignDocsCommand(directory, args) {
   if (parsed.error) {
     return `Error: ${parsed.error}
 
-${USAGE5}`;
+${USAGE6}`;
   }
   try {
     const { config } = loadPluginConfigWithMeta(directory);
     if (config.design_docs?.enabled !== true) {
       return "Error: design docs are disabled. Set `design_docs.enabled: true` in " + `opencode-swarm.json to enable the docs_design agent and this command.
 
-` + USAGE5;
+` + USAGE6;
     }
   } catch (configErr) {
     console.warn(`[design-docs] Could not read opencode-swarm.json (${String(configErr)}). ` + "Falling through \u2014 the architect will abort if docs_design is not registered.");
   }
   const description = sanitizeDescription(parsed.rest.join(" "));
   if (!description && !parsed.update) {
-    return USAGE5;
+    return USAGE6;
   }
   const header = `[MODE: DESIGN_DOCS out=${parsed.out} lang=${parsed.lang} update=${parsed.update}] ${description}`;
   return header.trimEnd();
 }
 
 // src/services/diagnose-service.ts
-import * as child_process5 from "child_process";
+import * as child_process6 from "child_process";
 import { existsSync as existsSync23, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
 import * as path36 from "path";
 import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.114.7",
+  version: "7.114.9",
   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",
@@ -18548,7 +18859,7 @@ function resolveCachePackageRoot(cachePath) {
   const nestedPackageRoot = path36.join(cachePath, "node_modules", "opencode-swarm");
   return existsSync23(nestedPackageRoot) ? nestedPackageRoot : cachePath;
 }
-var _internals25 = {
+var _internals26 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
   getSandboxExecutor: getExecutor
 };
@@ -18804,7 +19115,7 @@ async function checkGitRepository(directory) {
         detail: "Invalid directory \u2014 cannot check git status"
       };
     }
-    child_process5.execSync("git rev-parse --git-dir", {
+    child_process6.execSync("git rev-parse --git-dir", {
       cwd: directory,
       stdio: "pipe"
     });
@@ -19132,9 +19443,9 @@ async function checkCurator(directory) {
 }
 async function getSandboxStatus() {
   try {
-    const capability = await _internals25.detectSandboxCapability();
+    const capability = await _internals26.detectSandboxCapability();
     const mechanism = capability.mechanism ?? "none";
-    const executor = await _internals25.getSandboxExecutor();
+    const executor = await _internals26.getSandboxExecutor();
     const hasExecutor = executor !== null;
     if (hasExecutor) {
       const executorStrength = executor?.strength;
@@ -19886,7 +20197,7 @@ function readPromotionEvidence(directory) {
 }
 
 // src/commands/epic.ts
-var _internals26 = {
+var _internals27 = {
   loadPluginConfigWithMeta,
   loadPlanJsonOnly,
   getCoChangeData,
@@ -19908,7 +20219,7 @@ async function handleEpicCommand(directory, args, sessionID) {
   if (!sessionID || sessionID.trim() === "") {
     return "Error: No active session context. Epic Mode requires an active session. Use /swarm epic from within an OpenCode session.";
   }
-  const session = _internals26.ensureAgentSession(sessionID, undefined, directory);
+  const session = _internals27.ensureAgentSession(sessionID, undefined, directory);
   const arg0 = args[0]?.toLowerCase();
   switch (arg0) {
     case "status":
@@ -19935,7 +20246,7 @@ Usage:
 }
 function enableAndAck(directory, sessionID, session) {
   try {
-    _internals26.enableEpicMode(directory, sessionID);
+    _internals27.enableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error enabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -19951,7 +20262,7 @@ function enableAndAck(directory, sessionID, session) {
 }
 function disableAndAck(directory, sessionID, session) {
   try {
-    _internals26.disableEpicMode(directory, sessionID);
+    _internals27.disableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error disabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -19960,12 +20271,12 @@ function disableAndAck(directory, sessionID, session) {
 }
 function renderStatus(directory, sessionID) {
   const lines = ["## Epic Mode \u2014 Status", ""];
-  if (_internals26.isStateUnreadable(directory)) {
+  if (_internals27.isStateUnreadable(directory)) {
     lines.push("**Epic Mode state is unreadable** (`.swarm/epic-state.json` is corrupt or has an unexpected shape). Status cannot be reported until the file is repaired or removed. The fail-closed marker means `epic_decide_phase` will refuse to compute a verdict in this state.");
     return lines.join(`
 `);
   }
-  const state = _internals26.loadEpicSessionState(directory, sessionID);
+  const state = _internals27.loadEpicSessionState(directory, sessionID);
   if (!state) {
     lines.push("Epic Mode has not been toggled for this session.");
     return lines.join(`
@@ -20017,7 +20328,7 @@ function formatGreenfieldDetail(input) {
 function renderLast(directory) {
   let records;
   try {
-    records = _internals26.readPromotionEvidence(directory);
+    records = _internals27.readPromotionEvidence(directory);
   } catch (err) {
     return `Error reading epic-promotions.jsonl: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -20072,7 +20383,7 @@ function renderLast(directory) {
 `);
 }
 function renderCalibration(directory) {
-  if (_internals26.isCalibrationStateUnreadable(directory)) {
+  if (_internals27.isCalibrationStateUnreadable(directory)) {
     return [
       "## Epic Mode \u2014 Calibration",
       "",
@@ -20084,11 +20395,11 @@ function renderCalibration(directory) {
   }
   let state;
   try {
-    state = _internals26.loadCalibrationState(directory);
+    state = _internals27.loadCalibrationState(directory);
   } catch (err) {
     return `Error reading calibration state: ${err instanceof Error ? err.message : String(err)}`;
   }
-  const { config } = _internals26.loadPluginConfigWithMeta(directory);
+  const { config } = _internals27.loadPluginConfigWithMeta(directory);
   const staticThreshold = config.turbo?.epic?.mode?.activation_threshold ?? 0.3;
   const calibrationCfg = config.turbo?.epic?.calibration;
   const loosenWindow = calibrationCfg?.loosen_window ?? 10;
@@ -20136,7 +20447,7 @@ function renderCalibration(directory) {
   lines.push("");
   let recentDivergent = [];
   try {
-    const all = _internals26.readDivergenceHistory(directory, { limit: 50 });
+    const all = _internals27.readDivergenceHistory(directory, { limit: 50 });
     recentDivergent = all.filter((r) => !r.isClean).slice(-5);
   } catch {}
   lines.push("### Recent divergent tasks (tightened the threshold)");
@@ -20153,11 +20464,11 @@ function renderCalibration(directory) {
 `);
 }
 async function renderDecide(directory) {
-  const plan = await _internals26.loadPlanJsonOnly(directory);
+  const plan = await _internals27.loadPlanJsonOnly(directory);
   if (!plan) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` first.";
   }
-  const { config } = _internals26.loadPluginConfigWithMeta(directory);
+  const { config } = _internals27.loadPluginConfigWithMeta(directory);
   const modeCfg = config.turbo?.epic?.mode;
   const cochangeCfg = config.turbo?.epic?.cochange;
   const activationThreshold = modeCfg?.activation_threshold ?? 0.3;
@@ -20167,20 +20478,20 @@ async function renderDecide(directory) {
   const tasks = [];
   for (const phase of plan.phases) {
     for (const task of phase.tasks) {
-      const scopeFiles = _internals26.readTaskScopes(directory, task.id);
+      const scopeFiles = _internals27.readTaskScopes(directory, task.id);
       const scope = scopeFiles ?? task.files_touched ?? [];
       tasks.push({ id: task.id, scope });
     }
   }
-  const { pairs, commitsObserved } = await _internals26.getCoChangeData(directory);
+  const { pairs, commitsObserved } = await _internals27.getCoChangeData(directory);
   const isGitProject = (() => {
     try {
-      return _internals26.isGitRepo(directory);
+      return _internals27.isGitRepo(directory);
     } catch {
       return false;
     }
   })();
-  const verdict = _internals26.decideEpicActivation(tasks, pairs, commitsObserved, {
+  const verdict = _internals27.decideEpicActivation(tasks, pairs, commitsObserved, {
     activationThreshold,
     minCommitsForSignal,
     cochangeNpmiThreshold,
@@ -20224,7 +20535,7 @@ function formatVerdict(verdict) {
 }
 
 // src/services/evidence-service.ts
-var _internals27 = {
+var _internals28 = {
   loadEvidence,
   listEvidenceTaskIds
 };
@@ -20269,7 +20580,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals27.loadEvidence(directory, taskId);
+  const result = await _internals28.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -20292,13 +20603,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals27.listEvidenceTaskIds(directory);
+  const taskIds = await _internals28.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals27.loadEvidence(directory, taskId);
+    const result = await _internals28.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -20378,7 +20689,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-8g594znj.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-fehwj116.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -20926,7 +21237,7 @@ function extractCurrentPhaseFromPlan(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals28.validatePlanPhases(plan)) {
+  if (!_internals29.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -21068,9 +21379,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals28.parseSessionState(sessionContent);
+  const sessionState = _internals29.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals28.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals29.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -21089,8 +21400,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals28.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals28.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals29.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals29.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -21254,7 +21565,7 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var _internals28 = {
+var _internals29 = {
   getHandoffData,
   formatHandoffMarkdown,
   formatContinuationPrompt,
@@ -21403,15 +21714,15 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals29.writeSnapshot(directory, swarmState), () => _internals29.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals30.writeSnapshot(directory, swarmState), () => _internals30.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals29.writeSnapshot(directory, swarmState), () => _internals29.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals30.writeSnapshot(directory, swarmState), () => _internals30.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _internals29 = {
+var _internals30 = {
   writeSnapshot,
   createSnapshotWriterHook,
   flushPendingSnapshot
@@ -21608,184 +21919,8 @@ async function handleHistoryCommand(directory, _args) {
   const historyData = await getHistoryData(directory);
   return formatHistoryMarkdown(historyData);
 }
-// src/commands/_shared/url-security.ts
-import * as child_process6 from "child_process";
-var MAX_URL_LEN = 2048;
-var IPV4_PRIVATE = /^10\./;
-var IPV4_LOOPBACK = /^127\./;
-var IPV4_LINK_LOCAL = /^169\.254\./;
-var IPV4_PRIVATE_172 = /^172\.(1[6-9]|2\d|3[0-1])\./;
-var IPV4_PRIVATE_192 = /^192\.168\./;
-var IPV4_ZERO_NETWORK = /^0\./;
-var IPV6_LINK_LOCAL = /^fe80:/i;
-var IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-var _internals30 = {
-  spawnSync: (cmd, args, options) => {
-    const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
-    return child_process6.spawnSync(cmd, args, {
-      ...options,
-      env: mergedEnv
-    });
-  }
-};
-function sanitizeUrl(raw) {
-  let urlStr = raw.trim();
-  urlStr = urlStr.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
-  const fragmentIdx = urlStr.indexOf("#");
-  if (fragmentIdx !== -1) {
-    urlStr = urlStr.slice(0, fragmentIdx);
-  }
-  const queryIdx = urlStr.indexOf("?");
-  if (queryIdx !== -1) {
-    urlStr = urlStr.slice(0, queryIdx);
-  }
-  urlStr = urlStr.replace(/^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^@/]+@/, "https://");
-  if (urlStr.length > MAX_URL_LEN) {
-    urlStr = urlStr.slice(0, MAX_URL_LEN);
-  }
-  return urlStr.trim();
-}
-function sanitizeErrorEcho(raw, maxLength = 80) {
-  let stripped = "";
-  for (const ch of raw) {
-    const cp = ch.codePointAt(0);
-    if (cp !== undefined && (cp <= 31 || cp === 127)) {
-      stripped += " ";
-      continue;
-    }
-    stripped += ch;
-  }
-  const collapsed = stripped.replace(/\s+/g, " ").trim();
-  if (collapsed.length <= maxLength)
-    return collapsed;
-  return `${collapsed.slice(0, maxLength)}\u2026`;
-}
-function containsControlCharacters(value) {
-  for (const ch of value) {
-    const cp = ch.codePointAt(0);
-    if (cp !== undefined && (cp <= 31 || cp === 127)) {
-      return true;
-    }
-  }
-  return false;
-}
-function hasNonAsciiHostname(hostname) {
-  for (const ch of hostname) {
-    const cp = ch.codePointAt(0);
-    if (cp !== undefined && cp > 127)
-      return true;
-  }
-  return false;
-}
-function isIpv4MappedPrivateHost(inner) {
-  if (IPV4_PRIVATE.test(inner) || IPV4_LOOPBACK.test(inner) || IPV4_LINK_LOCAL.test(inner) || IPV4_PRIVATE_172.test(inner) || IPV4_PRIVATE_192.test(inner) || IPV4_ZERO_NETWORK.test(inner)) {
-    return true;
-  }
-  const firstSegment = inner.split(":", 1)[0];
-  if (!firstSegment)
-    return false;
-  const firstWord = Number.parseInt(firstSegment, 16);
-  if (!Number.isFinite(firstWord))
-    return false;
-  return firstWord >= 0 && firstWord <= 255 || firstWord >= 2560 && firstWord <= 2815 || firstWord >= 32512 && firstWord <= 32767 || firstWord === 43518 || firstWord >= 44048 && firstWord <= 44063 || firstWord === 49320;
-}
-function isPrivateHost(url) {
-  const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
-  if (host === "localhost" || host === "::1" || host === "0.0.0.0" || IPV4_LOOPBACK.test(host) || IPV4_ZERO_NETWORK.test(host)) {
-    return true;
-  }
-  if (host.startsWith("localhost") || host === "localhost.com") {
-    return true;
-  }
-  if (IPV4_PRIVATE.test(host) || IPV4_LINK_LOCAL.test(host) || IPV4_PRIVATE_172.test(host) || IPV4_PRIVATE_192.test(host) || IPV6_LINK_LOCAL.test(host) || IPV6_UNIQUE_LOCAL.test(host)) {
-    return true;
-  }
-  if (host.startsWith("::ffff:")) {
-    const inner = host.slice(7);
-    if (isIpv4MappedPrivateHost(inner)) {
-      return true;
-    }
-  }
-  return false;
-}
-function validateAndSanitizeGithubUrl(rawUrl, resource) {
-  const sanitized = sanitizeUrl(rawUrl);
-  if (!sanitized) {
-    return { error: "Empty URL" };
-  }
-  if (!sanitized.startsWith("https://")) {
-    return { error: "URL must use HTTPS scheme" };
-  }
-  try {
-    const url = new URL(sanitized);
-    if (hasNonAsciiHostname(url.hostname)) {
-      return { error: "Non-ASCII hostnames are not allowed" };
-    }
-    if (isPrivateHost(url)) {
-      return { error: "Private or localhost URLs are not allowed" };
-    }
-    const githubPattern = new RegExp(`^https:\\/\\/github\\.com\\/([^/]+)\\/([^/]+)\\/${resource}\\/([0-9]+)\\/?$`);
-    if (!githubPattern.test(sanitized)) {
-      return {
-        error: resource === "issues" ? "URL must be a GitHub issue URL (https://github.com/owner/repo/issues/N)" : "URL must be a GitHub pull request URL (https://github.com/owner/repo/pull/N)"
-      };
-    }
-    return { sanitized };
-  } catch {
-    return { error: "Invalid URL format" };
-  }
-}
-function detectGitRemote(cwd, laneEnv) {
-  try {
-    const result = _internals30.spawnSync("git", ["remote", "get-url", "origin"], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 5000,
-      ...cwd ? { cwd } : {},
-      envOverrides: laneEnv
-    });
-    if (result.status !== 0 || result.error) {
-      return null;
-    }
-    const remoteUrl = (result.stdout ?? "").trim();
-    return remoteUrl || null;
-  } catch {
-    return null;
-  }
-}
-function parseGitRemoteUrl(remoteUrl) {
-  const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i);
-  if (httpsMatch) {
-    const owner = httpsMatch[1];
-    const repo = httpsMatch[2].replace(/\.git$/, "");
-    if (containsControlCharacters(owner) || containsControlCharacters(repo)) {
-      return null;
-    }
-    return { owner, repo };
-  }
-  const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
-  if (sshMatch) {
-    const owner = sshMatch[1];
-    const repo = sshMatch[2].replace(/\.git$/, "");
-    if (containsControlCharacters(owner) || containsControlCharacters(repo)) {
-      return null;
-    }
-    return { owner, repo };
-  }
-  const pathMatch = remoteUrl.match(/\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
-  if (pathMatch) {
-    const owner = pathMatch[1];
-    const repo = pathMatch[2].replace(/\.git$/, "");
-    if (containsControlCharacters(owner) || containsControlCharacters(repo)) {
-      return null;
-    }
-    return { owner, repo };
-  }
-  return null;
-}
-
 // src/commands/issue.ts
-var USAGE6 = [
+var USAGE7 = [
   "Usage: /swarm issue <url|owner/repo#N|N> [--plan] [--trace] [--no-repro]",
   "",
   "Ingest a GitHub issue into the swarm workflow.",
@@ -21800,7 +21935,7 @@ var USAGE6 = [
   "  --no-repro    Skip reproduction step"
 ].join(`
 `);
-function validateAndSanitizeUrl(rawUrl) {
+function validateAndSanitizeUrl2(rawUrl) {
   return validateAndSanitizeGithubUrl(rawUrl, "issues");
 }
 function parseArgs7(args) {
@@ -21874,21 +22009,21 @@ function handleIssueCommand(directory, args) {
   const parsed = parseArgs7(args);
   const rawInput = parsed.rest.join(" ").trim();
   if (!rawInput) {
-    return USAGE6;
+    return USAGE7;
   }
   const isFullUrl = /^https?:\/\//i.test(rawInput);
   const issueInfo = parseIssueRef(isFullUrl ? sanitizeUrl(rawInput) : rawInput, directory);
   if (!issueInfo) {
     return `Error: Could not parse issue reference from "${sanitizeErrorEcho(rawInput)}"
 
-${USAGE6}`;
+${USAGE7}`;
   }
   const issueUrl = `https://github.com/${issueInfo.owner}/${issueInfo.repo}/issues/${issueInfo.number}`;
-  const result = validateAndSanitizeUrl(issueUrl);
+  const result = validateAndSanitizeUrl2(issueUrl);
   if ("error" in result) {
     return `Error: ${result.error}
 
-${USAGE6}`;
+${USAGE7}`;
   }
   const flags = [];
   if (parsed.plan)
@@ -22957,7 +23092,7 @@ async function readLatestLoopState(directory) {
 var _internals33 = {
   readLatestLoopState
 };
-var USAGE7 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
+var USAGE8 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
 
 Run a compound-engineering loop: brainstorm \u2192 plan \u2192 build \u2192 review \u2192 improve,
 iterating until the objective is met or a budget stop condition fires.
@@ -23059,11 +23194,11 @@ async function handleLoopCommand(_directory, args) {
   if (parsed.error) {
     return `Error: ${parsed.error}
 
-${USAGE7}`;
+${USAGE8}`;
   }
   const objective = sanitizeObjective(parsed.rest.join(" "));
   if (!objective && !parsed.resume) {
-    return USAGE7;
+    return USAGE8;
   }
   let autonomy = parsed.autonomy;
   if (parsed.resume && !parsed.autonomyExplicit) {
@@ -24234,85 +24369,6 @@ async function handlePostMortemCommand(directory, args, options) {
   }
 }
 
-// src/commands/pr-ref.ts
-var MAX_INSTRUCTIONS_LEN = 1000;
-function sanitizeInstructions(raw) {
-  const collapsed = raw.replace(/\s+/g, " ").trim();
-  const stripped = collapsed.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
-  const normalized = stripped.replace(/\s+/g, " ").trim();
-  if (normalized.length <= MAX_INSTRUCTIONS_LEN)
-    return normalized;
-  return `${normalized.slice(0, MAX_INSTRUCTIONS_LEN)}\u2026`;
-}
-function validateAndSanitizeUrl2(rawUrl) {
-  return validateAndSanitizeGithubUrl(rawUrl, "pull");
-}
-function parsePrRef(input, cwd) {
-  const urlMatch = input.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/i);
-  if (urlMatch) {
-    if (containsControlCharacters(urlMatch[1]) || containsControlCharacters(urlMatch[2])) {
-      return null;
-    }
-    return {
-      owner: urlMatch[1],
-      repo: urlMatch[2],
-      number: parseInt(urlMatch[3], 10)
-    };
-  }
-  const shorthandMatch = input.match(/^([^/]+)\/([^#]+)#(\d+)$/);
-  if (shorthandMatch) {
-    if (containsControlCharacters(shorthandMatch[1]) || containsControlCharacters(shorthandMatch[2])) {
-      return null;
-    }
-    return {
-      owner: shorthandMatch[1],
-      repo: shorthandMatch[2],
-      number: parseInt(shorthandMatch[3], 10)
-    };
-  }
-  const bareMatch = input.match(/^(\d+)$/);
-  if (bareMatch) {
-    const prNumber = parseInt(bareMatch[1], 10);
-    const remoteUrl = detectGitRemote(cwd, undefined);
-    if (!remoteUrl) {
-      return null;
-    }
-    const parsed = parseGitRemoteUrl(remoteUrl);
-    if (!parsed) {
-      return null;
-    }
-    return {
-      owner: parsed.owner,
-      repo: parsed.repo,
-      number: prNumber
-    };
-  }
-  return null;
-}
-function looksLikePrRef(token) {
-  return /^https?:\/\//i.test(token) || /^[^/]+\/[^#]+#\d+$/.test(token) || /^\d+$/.test(token);
-}
-function resolvePrCommandInput(rest, cwd) {
-  if (rest.length === 0) {
-    return null;
-  }
-  const refToken = rest[0];
-  const instructions = sanitizeInstructions(rest.slice(1).join(" "));
-  const isFullUrl = /^https?:\/\//i.test(refToken);
-  const prInfo = parsePrRef(isFullUrl ? sanitizeUrl(refToken) : refToken, cwd);
-  if (!prInfo) {
-    return {
-      error: `Could not parse PR reference from "${sanitizeErrorEcho(refToken)}"`
-    };
-  }
-  const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
-  const result = validateAndSanitizeUrl2(prUrl);
-  if ("error" in result) {
-    return { error: result.error };
-  }
-  return { prUrl: result.sanitized, instructions };
-}
-
 // src/commands/pr-feedback.ts
 function handlePrFeedbackCommand(directory, args) {
   const rest = args.filter((t) => t.trim().length > 0);
@@ -24499,7 +24555,7 @@ async function handlePrMonitorStatusCommand(directory, _args, sessionID, source)
 }
 
 // src/commands/pr-review.ts
-var USAGE8 = [
+var USAGE9 = [
   "Usage: /swarm pr-review <url|owner/repo#N|N> [--council] [instructions...]",
   "",
   "Run a full swarm PR review on a GitHub pull request.",
@@ -24537,16 +24593,16 @@ function handlePrReviewCommand(directory, args) {
   if (parsed.unknownFlag) {
     return `Error: Unknown flag "${parsed.unknownFlag}"
 
-${USAGE8}`;
+${USAGE9}`;
   }
   const resolved = resolvePrCommandInput(parsed.rest, directory);
   if (resolved === null) {
-    return USAGE8;
+    return USAGE9;
   }
   if ("error" in resolved) {
     return `Error: ${resolved.error}
 
-${USAGE8}`;
+${USAGE9}`;
   }
   const councilFlag = parsed.council ? "council=true" : "council=false";
   const signal = `[MODE: PR_REVIEW pr="${resolved.prUrl}" ${councilFlag}]`;
@@ -31392,7 +31448,7 @@ var _internals46 = {
   writeProjectedSpecSync
 };
 var SWARM_SPEC_REL = path61.join(".swarm", "spec.md");
-var USAGE9 = `Usage:
+var USAGE10 = `Usage:
   /swarm sdd status [--json] [--source <provider>]
   /swarm sdd validate [--json] [--change <id>] [--source <provider>] [--feature <id>]
   /swarm sdd project [--dry-run] [--overwrite] [--json] [--change <id>] [--source <provider>] [--feature <id>]
@@ -31505,11 +31561,11 @@ async function handleSddStatusCommand(directory, args) {
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE9}`;
+${USAGE10}`;
   if (parsed.feature && parsed.source && parsed.source !== "speckit") {
     return `Error: --feature is only valid with --source speckit
 
-${USAGE9}`;
+${USAGE10}`;
   }
   const speckitDetection = detectSpeckit(directory);
   const speckitPresent = speckitDetection.features.length > 0;
@@ -31576,11 +31632,11 @@ async function handleSddValidateCommand(directory, args) {
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE9}`;
+${USAGE10}`;
   if (parsed.feature && parsed.source && parsed.source !== "speckit") {
     return `Error: --feature is only valid with --source speckit
 
-${USAGE9}`;
+${USAGE10}`;
   }
   let useSpeckit = false;
   const nativeSpecExists = fs29.existsSync(path61.join(directory, SWARM_SPEC_REL));
@@ -31609,7 +31665,7 @@ ${USAGE9}`;
         const resolution = resolveSpeckitProjection(directory);
         return parsed.json ? JSON.stringify({ valid: false, error: formatSpeckitError(resolution) }, null, 2) : `Error: ${formatSpeckitError(resolution)}
 
-${USAGE9}`;
+${USAGE10}`;
       }
     }
   }
@@ -31620,7 +31676,7 @@ ${USAGE9}`;
     if (resolution.kind !== "ok" && resolution.kind !== "zero_requirements") {
       return parsed.json ? JSON.stringify({ valid: false, error: formatSpeckitError(resolution) }, null, 2) : `Error: ${formatSpeckitError(resolution)}
 
-${USAGE9}`;
+${USAGE10}`;
     }
     const spec = resolution.kind === "ok" ? resolution.spec : null;
     const result2 = {
@@ -31725,16 +31781,16 @@ async function handleSddProjectCommand(directory, args) {
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE9}`;
+${USAGE10}`;
   if (parsed.feature && parsed.source && parsed.source !== "speckit") {
     return `Error: --feature is only valid with --source speckit
 
-${USAGE9}`;
+${USAGE10}`;
   }
   if (parsed.source === "swarm") {
     return `Error: --source swarm selects the native .swarm/spec.md and does not generate a projection. Use --source openspec or --source speckit.
 
-${USAGE9}`;
+${USAGE10}`;
   }
   if (!parsed.dryRun) {
     const nativeSpecPath = path61.join(directory, SWARM_SPEC_REL);
@@ -31744,7 +31800,7 @@ ${USAGE9}`;
           "Error: .swarm/spec.md already exists.",
           "Pass --overwrite to replace it.",
           "",
-          USAGE9
+          USAGE10
         ].join(`
 `);
       }
@@ -31771,7 +31827,7 @@ ${USAGE9}`;
         const resolution = resolveSpeckitProjection(directory);
         return `Error: ${formatSpeckitError(resolution)}
 
-${USAGE9}`;
+${USAGE10}`;
       }
     }
   }
@@ -31782,7 +31838,7 @@ ${USAGE9}`;
     if (resolution.kind !== "ok") {
       return `Error: ${formatSpeckitError(resolution)}
 
-${USAGE9}`;
+${USAGE10}`;
     }
     const result2 = _internals46.writeProjectedSpecSync(directory, {
       source: "speckit",
@@ -31801,7 +31857,7 @@ ${USAGE9}`;
       }
       return `Error: ${result2.error}
 
-${USAGE9}`;
+${USAGE10}`;
     }
     if (!result2.projection) {
       if (parsed.json) {
@@ -31815,7 +31871,7 @@ ${USAGE9}`;
       return [
         "SDD projection failed: no valid Spec-Kit projection could be built.",
         "",
-        USAGE9
+        USAGE10
       ].join(`
 `);
     }
@@ -31858,7 +31914,7 @@ ${formatList(result2.projection.warnings)}` : ""
     }
     return `Error: ${result.error}
 
-${USAGE9}`;
+${USAGE10}`;
   }
   if (!result.projection) {
     if (parsed.json) {
@@ -31872,7 +31928,7 @@ ${USAGE9}`;
     return [
       "SDD projection failed: no valid OpenSpec-compatible projection could be built.",
       "",
-      USAGE9
+      USAGE10
     ].join(`
 `);
   }
@@ -31900,7 +31956,7 @@ ${formatList(result.projection.warnings)}` : ""
 `);
 }
 async function handleSddCommand(_directory, _args) {
-  return USAGE9;
+  return USAGE10;
 }
 
 // src/commands/simulate.ts
@@ -31923,7 +31979,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals21.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals22.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -32992,7 +33048,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-z01r5483.js");
+    const { buildHelpText } = await import("./index-54sevh81.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -33001,7 +33057,7 @@ async function handleHelpCommand(ctx) {
     return _internals49.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals49.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-z01r5483.js");
+  const { buildHelpText: fullHelp } = await import("./index-54sevh81.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -33134,7 +33190,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-4t8fnysh.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-7aztgtyh.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -33144,7 +33200,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-4t8fnysh.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-7aztgtyh.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -33504,6 +33560,14 @@ Subcommands:
     category: "agent",
     toolPolicy: "none"
   },
+  "ci-monitor": {
+    handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleCiMonitorCommand),
+    description: "Drive an already-reviewed, approved PR to green and merged (monitor CI, fix, merge) [pr]",
+    args: "<pr-url|owner/repo#N|N>",
+    details: "Triggers MODE: CI_MONITOR \u2014 takes an already human-reviewed, approved PR, exhaustively researches every CI failure, fixes it end-to-end, iterates until all required checks are green (max 5 fix cycles), then merges via `gh pr merge` with no merge-strategy flag. Invoke only after human review is complete; the skill re-verifies reviewDecision: APPROVED and mergeable state before doing anything destructive. Distinct from /swarm pr-subscribe, which passively watches a PR without a merge terminal. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolved against origin).",
+    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",
@@ -34544,6 +34608,7 @@ FILE: src/auth/login.ts
 INPUT: Validate email format, password >= 8 chars
 OUTPUT: Modified file
 CONSTRAINT: Do not modify other functions
+ACCEPTANCE: Populate from the plan task's acceptance criteria / FR / SC when the task has them (one item per line, or FR-/SC-style references), so the coder can gate its implementation on each. Omit the field entirely when the task has no structured acceptance criteria.
 SKILLS: file:.claude/skills/engineering-conventions/SKILL.md
 
 {{AGENT_PREFIX}}reviewer
@@ -34889,6 +34954,22 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Honor any free-text instructions that follow the closing bracket of the signal as additional scope, without dropping any ledger item.
 - Quality is the only metric \u2014 time, tokens, and agent dispatches are irrelevant to correctness
 
+### MODE: CI_MONITOR
+Activates when: architect receives \`[MODE: CI_MONITOR pr="https://github.com/..."]\` signal from the ci-monitor command handler.
+
+Purpose: Drive an already human-reviewed, approved PR to a merged state \u2014 monitor its CI, exhaustively research and fix every failure, iterate until all required checks are green (max 5 fix cycles), then merge. This is the terminal closeout hop for a PR that just needs to get green and merge; it is NOT a review or feedback-ingestion mode. It is the first mode in this workflow that performs a merge, so it carries extra safety gates.
+
+ACTION: Load skill ${bundledProjectSkillFileReference("swarm-ci-monitor")} immediately and follow its protocol.
+
+HARD CONSTRAINTS (apply regardless of skill load success):
+- Do NOT invoke this mode's merge path without the user having named the PR explicitly \u2014 no auto-discovery.
+- Verify \`reviewDecision: APPROVED\` before entering the fix loop; abort with "human review not complete" if not.
+- Verify \`mergeable: MERGEABLE\` and an acceptable \`mergeStateStatus\` before entering the fix loop; do not bypass these gates even under time pressure.
+- Never use \`--admin\`, a forced merge strategy, or \`--delete-branch\` \u2014 let branch protection determine the merge method.
+- Re-verify review approval and mergeable state immediately before every merge attempt (Step 3 of the loaded skill) \u2014 a check that was green earlier is not sufficient.
+- Confirm the merge via the local git object DB (Step 4b), not only the GitHub API response, before reporting success.
+- Hard-stop at 5 fix-push cycles; escalate to the user rather than exceeding the budget.
+
 ### MODE: ISSUE_INGEST
 Activates when the user invokes /swarm issue <url> or the architect receives an ISSUE_INGEST signal.
 
@@ -38293,7 +38374,6 @@ function resolveWriteTargets(command, writes, cwd) {
     };
   });
 }
-
 // src/hooks/guardrails/index.ts
 var SPEC_DRIFT_BLOCKED_TOOLS = new Set([
   "save_plan",
@@ -39297,4 +39377,4 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
   };
 }
 
-export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals11 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, checkHivePromotions, _internals13 as _internals1, createHivePromoterHook, promoteToHive, promoteFromSwarm, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals49 as _internals2, resolveCommand };
+export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals12 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, checkHivePromotions, _internals14 as _internals1, createHivePromoterHook, promoteToHive, promoteFromSwarm, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals49 as _internals2, resolveCommand };