opencode-swarm 6.38.0 → 6.40.1

package/dist/index.js

@@ -80,7 +80,13 @@ var init_tool_names = __esm(() => {
     "update_task_status",
     "write_retro",
     "declare_scope",
-    "knowledge_query"
+    "knowledge_query",
+    "doc_scan",
+    "doc_extract",
+    "curator_analyze",
+    "knowledgeAdd",
+    "knowledgeRecall",
+    "knowledgeRemove"
   ];
   TOOL_NAME_SET = new Set(TOOL_NAMES);
 });
@@ -146,6 +152,7 @@ var init_constants = __esm(() => {
     architect: [
       "checkpoint",
       "check_gate_status",
+      "completion_verify",
       "complexity_hotspots",
       "detect_domains",
       "evidence_check",
@@ -157,6 +164,7 @@ var init_constants = __esm(() => {
       "diff",
       "pkg_audit",
       "pre_check_batch",
+      "quality_budget",
       "retrieve_summary",
       "save_plan",
       "schema_drift",
@@ -166,7 +174,19 @@ var init_constants = __esm(() => {
       "todo_extract",
       "update_task_status",
       "write_retro",
-      "declare_scope"
+      "declare_scope",
+      "sast_scan",
+      "sbom_generate",
+      "build_check",
+      "syntax_check",
+      "placeholder_scan",
+      "phase_complete",
+      "doc_scan",
+      "doc_extract",
+      "curator_analyze",
+      "knowledgeAdd",
+      "knowledgeRecall",
+      "knowledgeRemove"
     ],
     explorer: [
       "complexity_hotspots",
@@ -177,7 +197,9 @@ var init_constants = __esm(() => {
       "retrieve_summary",
       "schema_drift",
       "symbols",
-      "todo_extract"
+      "todo_extract",
+      "doc_scan",
+      "knowledgeRecall"
     ],
     coder: [
       "diff",
@@ -185,7 +207,11 @@ var init_constants = __esm(() => {
       "lint",
       "symbols",
       "extract_code_blocks",
-      "retrieve_summary"
+      "retrieve_summary",
+      "build_check",
+      "syntax_check",
+      "knowledgeAdd",
+      "knowledgeRecall"
     ],
     test_engineer: [
       "test_runner",
@@ -195,7 +221,9 @@ var init_constants = __esm(() => {
       "retrieve_summary",
       "imports",
       "complexity_hotspots",
-      "pkg_audit"
+      "pkg_audit",
+      "build_check",
+      "syntax_check"
     ],
     sme: [
       "complexity_hotspots",
@@ -204,7 +232,8 @@ var init_constants = __esm(() => {
       "imports",
       "retrieve_summary",
       "schema_drift",
-      "symbols"
+      "symbols",
+      "knowledgeRecall"
     ],
     reviewer: [
       "diff",
@@ -217,28 +246,34 @@ var init_constants = __esm(() => {
       "complexity_hotspots",
       "retrieve_summary",
       "extract_code_blocks",
-      "test_runner"
+      "test_runner",
+      "sast_scan",
+      "placeholder_scan",
+      "knowledgeRecall"
     ],
     critic: [
       "complexity_hotspots",
       "detect_domains",
       "imports",
       "retrieve_summary",
-      "symbols"
+      "symbols",
+      "knowledgeRecall"
     ],
     critic_sounding_board: [
       "complexity_hotspots",
       "detect_domains",
       "imports",
       "retrieve_summary",
-      "symbols"
+      "symbols",
+      "knowledgeRecall"
     ],
     critic_drift_verifier: [
       "complexity_hotspots",
       "detect_domains",
       "imports",
       "retrieve_summary",
-      "symbols"
+      "symbols",
+      "knowledgeRecall"
     ],
     docs: [
       "detect_domains",
@@ -248,9 +283,15 @@ var init_constants = __esm(() => {
       "retrieve_summary",
       "schema_drift",
       "symbols",
-      "todo_extract"
+      "todo_extract",
+      "knowledgeRecall"
     ],
-    designer: ["extract_code_blocks", "retrieve_summary", "symbols"]
+    designer: [
+      "extract_code_blocks",
+      "retrieve_summary",
+      "symbols",
+      "knowledgeRecall"
+    ]
   };
   for (const [agentName, tools] of Object.entries(AGENT_TOOL_MAP)) {
     const invalidTools = tools.filter((tool) => !TOOL_NAME_SET.has(tool));
@@ -14869,8 +14910,8 @@ var init_schema = __esm(() => {
   });
   CheckpointConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
-    auto_checkpoint_threshold: exports_external.number().min(1).max(20).default(3)
-  });
+    auto_checkpoint_threshold: exports_external.number().int().min(1).max(20).default(3)
+  }).strict();
   AutomationModeSchema = exports_external.enum(["manual", "hybrid", "auto"]);
   AutomationCapabilitiesSchema = exports_external.object({
     plan_sync: exports_external.boolean().default(true),
@@ -14990,7 +15031,8 @@ var init_schema = __esm(() => {
       block_on_threshold: exports_external.boolean().default(false).describe("If true, block phase completion when threshold exceeded. Default: advisory only.")
     }).optional(),
     incremental_verify: IncrementalVerifyConfigSchema.optional(),
-    compaction_service: CompactionConfigSchema.optional()
+    compaction_service: CompactionConfigSchema.optional(),
+    turbo_mode: exports_external.boolean().default(false).optional()
   });
 });
 
@@ -15169,7 +15211,8 @@ var init_plan_schema = __esm(() => {
     id: exports_external.number().int().min(1),
     name: exports_external.string().min(1),
     status: PhaseStatusSchema.default("pending"),
-    tasks: exports_external.array(TaskSchema).default([])
+    tasks: exports_external.array(TaskSchema).default([]),
+    required_agents: exports_external.array(exports_external.string()).optional()
   });
   PlanSchema = exports_external.object({
     schema_version: exports_external.literal("1.0.0"),
@@ -16077,7 +16120,7 @@ async function updateTaskStatus(directory, taskId, status) {
     throw new Error(`Task not found: ${taskId}`);
   }
   const updatedPlan = { ...plan, phases: updatedPhases };
-  await savePlan(directory, updatedPlan, { preserveCompletedStatuses: false });
+  await savePlan(directory, updatedPlan, { preserveCompletedStatuses: true });
   return updatedPlan;
 }
 function derivePlanMarkdown(plan) {
@@ -16433,8 +16476,8 @@ function getTaskBlockers(task, summary, status) {
   }
   return blockers;
 }
-async function buildTaskSummary(task, taskId) {
-  const result = await loadEvidence(".", taskId);
+async function buildTaskSummary(directory, task, taskId) {
+  const result = await loadEvidence(directory, taskId);
   const bundle = result.status === "found" ? result.bundle : null;
   const phase = task?.phase ?? 0;
   const status = getTaskStatus(task, bundle);
@@ -16463,18 +16506,18 @@ async function buildTaskSummary(task, taskId) {
     lastEvidenceTimestamp: lastTimestamp
   };
 }
-async function buildPhaseSummary(phase) {
-  const taskIds = await listEvidenceTaskIds(".");
+async function buildPhaseSummary(directory, phase) {
+  const taskIds = await listEvidenceTaskIds(directory);
   const phaseTaskIds = new Set(phase.tasks.map((t) => t.id));
   const taskSummaries = [];
   const _taskMap = new Map(phase.tasks.map((t) => [t.id, t]));
   for (const task of phase.tasks) {
-    const summary = await buildTaskSummary(task, task.id);
+    const summary = await buildTaskSummary(directory, task, task.id);
     taskSummaries.push(summary);
   }
   const extraTaskIds = taskIds.filter((id) => !phaseTaskIds.has(id));
   for (const taskId of extraTaskIds) {
-    const summary = await buildTaskSummary(undefined, taskId);
+    const summary = await buildTaskSummary(directory, undefined, taskId);
     if (summary.phase === phase.id) {
       taskSummaries.push(summary);
     }
@@ -16575,7 +16618,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
   let totalTasks = 0;
   let completedTasks = 0;
   for (const phase of phasesToProcess) {
-    const summary = await buildPhaseSummary(phase);
+    const summary = await buildPhaseSummary(directory, phase);
     phaseSummaries.push(summary);
     totalTasks += summary.totalTasks;
     completedTasks += summary.completedTasks;
@@ -30153,6 +30196,11 @@ function isGitRepo() {
 }
 function handleSave(label, directory) {
   try {
+    let maxCheckpoints = 20;
+    try {
+      const { config: config3 } = loadPluginConfigWithMeta(directory);
+      maxCheckpoints = config3.checkpoint?.auto_checkpoint_threshold ?? maxCheckpoints;
+    } catch {}
     const log2 = readCheckpointLog(directory);
     const existingCheckpoint = log2.checkpoints.find((c) => c.label === label);
     if (existingCheckpoint) {
@@ -30257,6 +30305,7 @@ function handleDelete(label, directory) {
 var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json", MAX_LABEL_LENGTH = 100, GIT_TIMEOUT_MS = 30000, SHELL_METACHARACTERS, SAFE_LABEL_PATTERN, CONTROL_CHAR_PATTERN, NON_ASCII_PATTERN, checkpoint;
 var init_checkpoint = __esm(() => {
   init_tool();
+  init_config();
   init_create_tool();
   SHELL_METACHARACTERS = /[;|&$`(){}<>!'"]/;
   SAFE_LABEL_PATTERN = /^[a-zA-Z0-9_ -]+$/;
@@ -30280,7 +30329,7 @@ var init_checkpoint = __esm(() => {
       let label;
       try {
         action = String(args2.action);
-        label = args2.label !== undefined ? String(args2.label) : undefined;
+        label = args2.label !== undefined && args2.label !== null ? String(args2.label) : undefined;
       } catch {
         return JSON.stringify({
           action: "unknown",
@@ -31853,6 +31902,163 @@ var require_proper_lockfile = __commonJS((exports, module2) => {
   module2.exports.checkSync = checkSync;
 });
 
+// src/hooks/knowledge-store.ts
+import { existsSync as existsSync7 } from "fs";
+import { appendFile, mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import * as os4 from "os";
+import * as path12 from "path";
+function resolveSwarmKnowledgePath(directory) {
+  return path12.join(directory, ".swarm", "knowledge.jsonl");
+}
+function resolveSwarmRejectedPath(directory) {
+  return path12.join(directory, ".swarm", "knowledge-rejected.jsonl");
+}
+function resolveHiveKnowledgePath() {
+  const platform = process.platform;
+  const home = os4.homedir();
+  let dataDir;
+  if (platform === "win32") {
+    dataDir = path12.join(process.env.LOCALAPPDATA || path12.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+  } else if (platform === "darwin") {
+    dataDir = path12.join(home, "Library", "Application Support", "opencode-swarm");
+  } else {
+    dataDir = path12.join(process.env.XDG_DATA_HOME || path12.join(home, ".local", "share"), "opencode-swarm");
+  }
+  return path12.join(dataDir, "shared-learnings.jsonl");
+}
+function resolveHiveRejectedPath() {
+  const hivePath = resolveHiveKnowledgePath();
+  return path12.join(path12.dirname(hivePath), "shared-learnings-rejected.jsonl");
+}
+async function readKnowledge(filePath) {
+  if (!existsSync7(filePath))
+    return [];
+  const content = await readFile2(filePath, "utf-8");
+  const results = [];
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      results.push(JSON.parse(trimmed));
+    } catch {
+      console.warn(`[knowledge-store] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return results;
+}
+async function readRejectedLessons(directory) {
+  return readKnowledge(resolveSwarmRejectedPath(directory));
+}
+async function appendKnowledge(filePath, entry) {
+  await mkdir(path12.dirname(filePath), { recursive: true });
+  await appendFile(filePath, `${JSON.stringify(entry)}
+`, "utf-8");
+}
+async function rewriteKnowledge(filePath, entries) {
+  const dir = path12.dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  let release = null;
+  try {
+    release = await import_proper_lockfile.default.lock(dir, {
+      retries: { retries: 3, minTimeout: 100 }
+    });
+    const content = entries.map((e) => JSON.stringify(e)).join(`
+`) + (entries.length > 0 ? `
+` : "");
+    await writeFile(filePath, content, "utf-8");
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+async function appendRejectedLesson(directory, lesson) {
+  const filePath = resolveSwarmRejectedPath(directory);
+  const existing = await readRejectedLessons(directory);
+  const MAX = 20;
+  const updated = [...existing, lesson];
+  if (updated.length > MAX) {
+    const trimmed = updated.slice(updated.length - MAX);
+    await rewriteKnowledge(filePath, trimmed);
+  } else {
+    await appendKnowledge(filePath, lesson);
+  }
+}
+function normalize2(text) {
+  return text.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function wordBigrams(text) {
+  const words = normalize2(text).split(" ").filter(Boolean);
+  const bigrams = new Set;
+  for (let i2 = 0;i2 < words.length - 1; i2++) {
+    bigrams.add(`${words[i2]} ${words[i2 + 1]}`);
+  }
+  return bigrams;
+}
+function jaccardBigram(a, b) {
+  if (a.size === 0 && b.size === 0)
+    return 1;
+  const aArr = Array.from(a);
+  const intersection3 = new Set(aArr.filter((x) => b.has(x)));
+  const union3 = new Set([...aArr, ...Array.from(b)]);
+  return intersection3.size / union3.size;
+}
+function findNearDuplicate(candidate, entries, threshold = 0.6) {
+  const candidateBigrams = wordBigrams(candidate);
+  return entries.find((entry) => {
+    const entryBigrams = wordBigrams(entry.lesson);
+    return jaccardBigram(candidateBigrams, entryBigrams) >= threshold;
+  });
+}
+function computeConfidence(confirmedByCount, autoGenerated) {
+  let score = 0.5;
+  score += Math.min(confirmedByCount, 3) * 0.1;
+  if (!autoGenerated)
+    score += 0.1;
+  return Math.min(score, 1);
+}
+function inferTags(lesson) {
+  const lower = lesson.toLowerCase();
+  const tags = [];
+  if (/\b(?:typescript|ts)\b/.test(lower))
+    tags.push("typescript");
+  if (/\b(?:javascript|js)\b/.test(lower))
+    tags.push("javascript");
+  if (/\b(?:python)\b/.test(lower))
+    tags.push("python");
+  if (/\b(?:bun|node|deno)\b/.test(lower))
+    tags.push("runtime");
+  if (/\b(?:react|vue|svelte|angular)\b/.test(lower))
+    tags.push("frontend");
+  if (/\b(?:git|github|gitlab)\b/.test(lower))
+    tags.push("git");
+  if (/\b(?:docker|kubernetes|k8s)\b/.test(lower))
+    tags.push("container");
+  if (/\b(?:sql|postgres|mysql|sqlite)\b/.test(lower))
+    tags.push("database");
+  if (/\b(?:test|spec|vitest|jest|mocha)\b/.test(lower))
+    tags.push("testing");
+  if (/\b(?:ci|cd|pipeline|workflow|action)\b/.test(lower))
+    tags.push("ci-cd");
+  if (/\b(?:security|auth|token|password|encrypt)\b/.test(lower))
+    tags.push("security");
+  if (/\b(?:performance|latency|throughput|cache)\b/.test(lower))
+    tags.push("performance");
+  if (/\b(?:api|rest|graphql|grpc|endpoint)\b/.test(lower))
+    tags.push("api");
+  if (/\b(?:swarm|architect|agent|hook|plan)\b/.test(lower))
+    tags.push("opencode-swarm");
+  return Array.from(new Set(tags));
+}
+var import_proper_lockfile;
+var init_knowledge_store = __esm(() => {
+  import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+});
+
 // src/services/config-doctor.ts
 var exports_config_doctor = {};
 __export(exports_config_doctor, {
@@ -33338,6 +33544,59 @@ var init_profiles = __esm(() => {
       ]
     }
   });
+  LANGUAGE_REGISTRY.register({
+    id: "php",
+    displayName: "PHP",
+    tier: 3,
+    extensions: [".php", ".phtml"],
+    treeSitter: { grammarId: "php", wasmFile: "tree-sitter-php.wasm" },
+    build: {
+      detectFiles: ["composer.json"],
+      commands: []
+    },
+    test: {
+      detectFiles: ["phpunit.xml", "phpunit.xml.dist"],
+      frameworks: [
+        {
+          name: "PHPUnit",
+          detect: "phpunit.xml",
+          cmd: "vendor/bin/phpunit",
+          priority: 1
+        }
+      ]
+    },
+    lint: {
+      detectFiles: [".php-cs-fixer.php", "phpcs.xml"],
+      linters: [
+        {
+          name: "PHP-CS-Fixer",
+          detect: ".php-cs-fixer.php",
+          cmd: "vendor/bin/php-cs-fixer fix --dry-run --diff",
+          priority: 1
+        }
+      ]
+    },
+    audit: {
+      detectFiles: ["composer.lock"],
+      command: "composer audit --format=json",
+      outputFormat: "json"
+    },
+    sast: { nativeRuleSet: "php", semgrepSupport: "ga" },
+    prompts: {
+      coderConstraints: [
+        "Follow PSR-12 coding standards",
+        "Use strict types declaration: declare(strict_types=1)",
+        "Prefer type hints and return type declarations on all functions",
+        "Use dependency injection over static methods and singletons"
+      ],
+      reviewerChecklist: [
+        "Verify no user input reaches SQL queries without parameterised binding",
+        "Check for XSS \u2014 all output must be escaped with htmlspecialchars()",
+        "Confirm no eval(), exec(), or shell_exec() with user-controlled input",
+        "Validate proper error handling \u2014 no bare catch blocks that swallow errors"
+      ]
+    }
+  });
 });
 
 // src/lang/detector.ts
@@ -33735,6 +33994,53 @@ var init_discovery = __esm(() => {
   });
 });
 
+// src/utils/path-security.ts
+function containsPathTraversal(str) {
+  if (/\.\.[/\\]/.test(str))
+    return true;
+  if (/(?:^|[/\\])\.\.(?:[/\\]|$)/.test(str))
+    return true;
+  if (/%2e%2e/i.test(str))
+    return true;
+  if (/%2e\./i.test(str))
+    return true;
+  if (/%2e/i.test(str) && /\.\./.test(str))
+    return true;
+  if (/%252e%252e/i.test(str))
+    return true;
+  if (/\uff0e/.test(str))
+    return true;
+  if (/\u3002/.test(str))
+    return true;
+  if (/\uff65/.test(str))
+    return true;
+  if (/%2f/i.test(str))
+    return true;
+  if (/%5c/i.test(str))
+    return true;
+  return false;
+}
+function containsControlChars(str) {
+  return /[\0\t\r\n]/.test(str);
+}
+function validateDirectory(directory) {
+  if (!directory || directory.trim() === "") {
+    throw new Error("Invalid directory: empty");
+  }
+  if (containsPathTraversal(directory)) {
+    throw new Error("Invalid directory: path traversal detected");
+  }
+  if (containsControlChars(directory)) {
+    throw new Error("Invalid directory: control characters detected");
+  }
+  if (directory.startsWith("/") || directory.startsWith("\\")) {
+    throw new Error("Invalid directory: absolute path");
+  }
+  if (/^[A-Za-z]:[/\\]/.test(directory)) {
+    throw new Error("Invalid directory: Windows absolute path");
+  }
+}
+
 // src/tools/lint.ts
 import * as fs12 from "fs";
 import * as path23 from "path";
@@ -33908,7 +34214,7 @@ async function detectAvailableLinter(directory) {
 async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
   const DETECT_TIMEOUT = 2000;
   try {
-    const biomeProc = Bun.spawn(["npx", "biome", "--version"], {
+    const biomeProc = Bun.spawn([biomeBin, "--version"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -33922,7 +34228,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     }
   } catch {}
   try {
-    const eslintProc = Bun.spawn(["npx", "eslint", "--version"], {
+    const eslintProc = Bun.spawn([eslintBin, "--version"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -34133,19 +34439,6 @@ function isHighEntropyString(str) {
   const entropy = calculateShannonEntropy(str);
   return entropy > 4;
 }
-function containsPathTraversal(str) {
-  if (/\.\.[/\\]/.test(str))
-    return true;
-  if (/[/\\]\.\.$/.test(str) || str === "..")
-    return true;
-  if (/\.\.[/\\]/.test(path24.normalize(str.replace(/\*/g, "x"))))
-    return true;
-  if (str.includes("%2e%2e") || str.includes("%2E%2E"))
-    return true;
-  if (str.includes("..") && /%2e/i.test(str))
-    return true;
-  return false;
-}
 function validateExcludePattern(exc) {
   if (exc.length === 0)
     return null;
@@ -34198,9 +34491,6 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   }
   return false;
 }
-function containsControlChars(str) {
-  return /[\0\t\r\n]/.test(str);
-}
 function validateDirectoryInput(dir) {
   if (!dir || dir.length === 0) {
     return "directory is required";
@@ -34812,31 +35102,6 @@ var init_secretscan = __esm(() => {
 // src/tools/test-runner.ts
 import * as fs14 from "fs";
 import * as path25 from "path";
-function containsPathTraversal2(str) {
-  if (/\.\.[/\\]/.test(str))
-    return true;
-  if (/(?:^|[/\\])\.\.(?:[/\\]|$)/.test(str))
-    return true;
-  if (/%2e%2e/i.test(str))
-    return true;
-  if (/%2e\./i.test(str))
-    return true;
-  if (/%2e/i.test(str) && /\.\./.test(str))
-    return true;
-  if (/%252e%252e/i.test(str))
-    return true;
-  if (/\uff0e/.test(str))
-    return true;
-  if (/\u3002/.test(str))
-    return true;
-  if (/\uff65/.test(str))
-    return true;
-  if (/%2f/i.test(str))
-    return true;
-  if (/%5c/i.test(str))
-    return true;
-  return false;
-}
 function isAbsolutePath(str) {
   if (str.startsWith("/"))
     return true;
@@ -34848,9 +35113,6 @@ function isAbsolutePath(str) {
     return true;
   return false;
 }
-function containsControlChars2(str) {
-  return /[\x00-\x08\x0a\x0b\x0c\x0d\x0e-\x1f\x7f\x80-\x9f]/.test(str);
-}
 function containsPowerShellMetacharacters(str) {
   return POWERSHELL_METACHARACTERS.test(str);
 }
@@ -34871,9 +35133,9 @@ function validateArgs2(args2) {
         return false;
       if (isAbsolutePath(f))
         return false;
-      if (containsPathTraversal2(f))
+      if (containsPathTraversal(f))
         return false;
-      if (containsControlChars2(f))
+      if (containsControlChars(f))
         return false;
       if (containsPowerShellMetacharacters(f))
         return false;
@@ -35702,7 +35964,7 @@ var init_test_runner = __esm(() => {
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      if (containsControlChars2(workingDir)) {
+      if (containsControlChars(workingDir)) {
         const errorResult = {
           success: false,
           framework: "none",
@@ -35711,7 +35973,7 @@ var init_test_runner = __esm(() => {
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      if (containsPathTraversal2(workingDir)) {
+      if (containsPathTraversal(workingDir)) {
         const errorResult = {
           success: false,
           framework: "none",
@@ -35978,12 +36240,13 @@ async function runLintCheck(dir, linter, timeoutMs) {
   const startTime = Date.now();
   try {
     const lintPromise = runLint(linter, "check", dir);
+    let timeoutId;
     const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
+      timeoutId = setTimeout(() => {
         reject(new Error(`Lint check timed out after ${timeoutMs}ms`));
       }, timeoutMs);
     });
-    const result = await Promise.race([lintPromise, timeoutPromise]);
+    const result = await Promise.race([lintPromise, timeoutPromise]).finally(() => clearTimeout(timeoutId));
     if (!result.success) {
       return {
         type: "lint",
@@ -36475,7 +36738,7 @@ function deriveRequiredGates(agentType) {
 }
 function expandRequiredGates(existingGates, newAgentType) {
   const newGates = deriveRequiredGates(newAgentType);
-  const combined = [...new Set([...existingGates, ...newGates])];
+  const combined = [...new Set([...existingGates ?? [], ...newGates])];
   return combined.sort();
 }
 function getEvidenceDir(directory) {
@@ -36610,10 +36873,10 @@ function createPreflightIntegration(config3) {
     });
     const report = await runPreflight(directory, request.currentPhase, preflightConfig);
     if (statusArtifact) {
-      const state2 = report.overall === "pass" ? "success" : "failure";
-      statusArtifact.recordOutcome(state2, request.currentPhase, report.message);
+      const state = report.overall === "pass" ? "success" : "failure";
+      statusArtifact.recordOutcome(state, request.currentPhase, report.message);
       console.log("[PreflightIntegration] Status artifact updated", {
-        state: state2,
+        state,
         phase: request.currentPhase,
         message: report.message
       });
@@ -36643,6 +36906,395 @@ var init_preflight_integration = __esm(() => {
   init_preflight_service();
 });
 
+// src/tools/doc-scan.ts
+var exports_doc_scan = {};
+__export(exports_doc_scan, {
+  scanDocIndex: () => scanDocIndex,
+  extractDocConstraints: () => extractDocConstraints,
+  doc_scan: () => doc_scan,
+  doc_extract: () => doc_extract
+});
+import * as crypto4 from "crypto";
+import * as fs25 from "fs";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import * as path36 from "path";
+function normalizeSeparators(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function matchesDocPattern(filePath, patterns) {
+  const normalizedPath = normalizeSeparators(filePath);
+  const basename5 = path36.basename(filePath);
+  for (const pattern of patterns) {
+    if (!pattern.includes("/") && !pattern.includes("\\")) {
+      if (basename5 === pattern) {
+        return true;
+      }
+      continue;
+    }
+    if (pattern.startsWith("**/")) {
+      const filenamePattern = pattern.slice(3);
+      if (basename5 === filenamePattern) {
+        return true;
+      }
+      continue;
+    }
+    const patternNormalized = normalizeSeparators(pattern);
+    const dirPrefix = patternNormalized.replace(/\/\*\*.*$/, "").replace(/\/\*.*$/, "");
+    if (normalizedPath.startsWith(`${dirPrefix}/`) || normalizedPath === dirPrefix) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractTitleAndSummary(content, filename) {
+  const lines = content.split(`
+`);
+  let title = filename;
+  let summary = "";
+  let foundTitle = false;
+  const potentialSummaryLines = [];
+  for (let i2 = 0;i2 < lines.length && i2 < READ_LINES_LIMIT; i2++) {
+    const line = lines[i2].trim();
+    if (!foundTitle && line.startsWith("# ")) {
+      title = line.slice(2).trim();
+      foundTitle = true;
+      continue;
+    }
+    if (line && !line.startsWith("#")) {
+      potentialSummaryLines.push(line);
+    }
+  }
+  for (const line of potentialSummaryLines) {
+    summary += (summary ? " " : "") + line;
+    if (summary.length >= MAX_SUMMARY_LENGTH) {
+      break;
+    }
+  }
+  if (summary.length > MAX_SUMMARY_LENGTH) {
+    summary = `${summary.slice(0, MAX_SUMMARY_LENGTH - 3)}...`;
+  }
+  return { title, summary };
+}
+function stripMarkdown(text) {
+  return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s*[-*\u2022]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "").trim();
+}
+async function scanDocIndex(directory) {
+  const manifestPath = path36.join(directory, ".swarm", "doc-manifest.json");
+  const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
+  const extraPatterns = [
+    "ARCHITECTURE.md",
+    "CLAUDE.md",
+    "AGENTS.md",
+    ".github/*.md",
+    "doc/**/*.md"
+  ];
+  const allPatterns = [...defaultPatterns, ...extraPatterns];
+  try {
+    const manifestContent = await readFile5(manifestPath, "utf-8");
+    const existingManifest = JSON.parse(manifestContent);
+    if (existingManifest.schema_version === 1 && existingManifest.files) {
+      let cacheValid = true;
+      for (const file3 of existingManifest.files) {
+        try {
+          const fullPath = path36.join(directory, file3.path);
+          const stat2 = fs25.statSync(fullPath);
+          if (stat2.mtimeMs > new Date(existingManifest.scanned_at).getTime()) {
+            cacheValid = false;
+            break;
+          }
+        } catch {
+          cacheValid = false;
+          break;
+        }
+      }
+      if (cacheValid) {
+        return { manifest: existingManifest, cached: true };
+      }
+    }
+  } catch {}
+  const discoveredFiles = [];
+  let rawEntries;
+  try {
+    rawEntries = fs25.readdirSync(directory, { recursive: true });
+  } catch {
+    const manifest2 = {
+      schema_version: 1,
+      scanned_at: new Date().toISOString(),
+      files: []
+    };
+    return { manifest: manifest2, cached: false };
+  }
+  const entries = rawEntries.filter((e) => typeof e === "string");
+  for (const entry of entries) {
+    const fullPath = path36.join(directory, entry);
+    let stat2;
+    try {
+      stat2 = fs25.statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (!stat2.isFile())
+      continue;
+    const pathParts = normalizeSeparators(entry).split("/");
+    let skipThisFile = false;
+    for (const part of pathParts) {
+      if (SKIP_DIRECTORIES2.has(part)) {
+        skipThisFile = true;
+        break;
+      }
+    }
+    if (skipThisFile)
+      continue;
+    for (const pattern of SKIP_PATTERNS) {
+      if (pattern.test(entry)) {
+        skipThisFile = true;
+        break;
+      }
+    }
+    if (skipThisFile)
+      continue;
+    if (!matchesDocPattern(entry, allPatterns)) {
+      continue;
+    }
+    let content;
+    try {
+      content = fs25.readFileSync(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const { title, summary } = extractTitleAndSummary(content, path36.basename(entry));
+    const lineCount = content.split(`
+`).length;
+    discoveredFiles.push({
+      path: entry,
+      title,
+      summary,
+      lines: lineCount,
+      mtime: stat2.mtimeMs
+    });
+  }
+  discoveredFiles.sort((a, b) => a.path.toLowerCase().localeCompare(b.path.toLowerCase()));
+  let truncated = false;
+  if (discoveredFiles.length > MAX_INDEXED_FILES) {
+    discoveredFiles.splice(MAX_INDEXED_FILES);
+    truncated = true;
+  }
+  if (truncated && discoveredFiles.length > 0) {
+    discoveredFiles[0].summary = `[Warning: ${MAX_INDEXED_FILES}+ docs found, listing first ${MAX_INDEXED_FILES}] ` + discoveredFiles[0].summary;
+  }
+  const manifest = {
+    schema_version: 1,
+    scanned_at: new Date().toISOString(),
+    files: discoveredFiles
+  };
+  try {
+    await mkdir5(path36.dirname(manifestPath), { recursive: true });
+    await writeFile4(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  } catch {}
+  return { manifest, cached: false };
+}
+function isConstraintLine(line) {
+  const upperLine = line.toUpperCase();
+  for (const pattern of CONSTRAINT_PATTERNS) {
+    if (pattern.test(upperLine)) {
+      return true;
+    }
+  }
+  if (/^\s*[-*\u2022]/.test(line) && ACTION_WORDS.test(line)) {
+    return true;
+  }
+  return false;
+}
+function extractConstraintsFromContent(content) {
+  const lines = content.split(`
+`);
+  const constraints = [];
+  for (const line of lines) {
+    if (constraints.length >= MAX_CONSTRAINTS_PER_DOC) {
+      break;
+    }
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    if (isConstraintLine(trimmed)) {
+      const cleaned = stripMarkdown(trimmed);
+      const len = cleaned.length;
+      if (len >= MIN_LESSON_LENGTH && len <= MAX_CONSTRAINT_LENGTH) {
+        constraints.push(cleaned);
+      }
+    }
+  }
+  return constraints;
+}
+async function extractDocConstraints(directory, taskFiles, taskDescription) {
+  const manifestPath = path36.join(directory, ".swarm", "doc-manifest.json");
+  let manifest;
+  try {
+    const content = await readFile5(manifestPath, "utf-8");
+    manifest = JSON.parse(content);
+  } catch {
+    const result = await scanDocIndex(directory);
+    manifest = result.manifest;
+  }
+  const knowledgePath = resolveSwarmKnowledgePath(directory);
+  const existingEntries = await readKnowledge(knowledgePath);
+  const taskContext = [...taskFiles, taskDescription].join(" ");
+  const taskBigrams = wordBigrams(normalize2(taskContext));
+  let extractedCount = 0;
+  let skippedCount = 0;
+  const details = [];
+  for (const docFile of manifest.files) {
+    const docContext = `${docFile.path} ${docFile.title} ${docFile.summary}`;
+    const docBigrams = wordBigrams(normalize2(docContext));
+    const score = jaccardBigram(taskBigrams, docBigrams);
+    if (score <= RELEVANCE_THRESHOLD) {
+      skippedCount++;
+      continue;
+    }
+    let fullContent;
+    try {
+      fullContent = await readFile5(path36.join(directory, docFile.path), "utf-8");
+    } catch {
+      skippedCount++;
+      continue;
+    }
+    const constraints = extractConstraintsFromContent(fullContent);
+    if (constraints.length === 0) {
+      skippedCount++;
+      continue;
+    }
+    const docDetails = {
+      path: docFile.path,
+      score,
+      constraints: []
+    };
+    for (const constraint of constraints) {
+      const duplicate = findNearDuplicate(constraint, existingEntries, DEDUP_THRESHOLD);
+      if (!duplicate) {
+        const entry = {
+          id: crypto4.randomUUID(),
+          tier: "swarm",
+          lesson: constraint,
+          category: "architecture",
+          tags: ["doc-scan", path36.basename(docFile.path)],
+          scope: "global",
+          confidence: 0.5,
+          status: "candidate",
+          confirmed_by: [],
+          project_name: "",
+          retrieval_outcomes: {
+            applied_count: 0,
+            succeeded_after_count: 0,
+            failed_after_count: 0
+          },
+          schema_version: 1,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+          auto_generated: true,
+          hive_eligible: false
+        };
+        await appendKnowledge(knowledgePath, entry);
+        existingEntries.push(entry);
+        extractedCount++;
+        docDetails.constraints.push(constraint);
+      }
+    }
+    if (docDetails.constraints.length > 0) {
+      details.push(docDetails);
+    } else {
+      skippedCount++;
+    }
+  }
+  return { extracted: extractedCount, skipped: skippedCount, details };
+}
+var SKIP_DIRECTORIES2, SKIP_PATTERNS, MAX_SUMMARY_LENGTH = 200, MAX_INDEXED_FILES = 100, READ_LINES_LIMIT = 30, MIN_LESSON_LENGTH = 15, MAX_CONSTRAINTS_PER_DOC = 5, MAX_CONSTRAINT_LENGTH = 200, RELEVANCE_THRESHOLD = 0.1, DEDUP_THRESHOLD = 0.6, CONSTRAINT_PATTERNS, ACTION_WORDS, doc_scan, doc_extract;
+var init_doc_scan = __esm(() => {
+  init_dist();
+  init_schema();
+  init_knowledge_store();
+  init_create_tool();
+  SKIP_DIRECTORIES2 = new Set([
+    "node_modules",
+    ".git",
+    ".swarm",
+    "dist",
+    "build",
+    ".next",
+    "vendor"
+  ]);
+  SKIP_PATTERNS = [/\.test\./, /\.spec\./, /\.d\.ts$/];
+  CONSTRAINT_PATTERNS = [
+    /\bMUST\b/,
+    /\bMUST NOT\b/,
+    /\bSHOULD\b/,
+    /\bSHOULD NOT\b/,
+    /\bDO NOT\b/,
+    /\bALWAYS\b/,
+    /\bNEVER\b/,
+    /\bREQUIRED\b/
+  ];
+  ACTION_WORDS = /\b(must|should|don't|avoid|ensure|use|follow)\b/i;
+  doc_scan = createSwarmTool({
+    description: "Scan project documentation files and build an index manifest. Caches results in .swarm/doc-manifest.json for fast subsequent scans.",
+    args: {
+      force: tool.schema.boolean().optional().describe("Force re-scan even if cache is valid")
+    },
+    execute: async (args2, directory) => {
+      let force = false;
+      try {
+        if (args2 && typeof args2 === "object") {
+          const obj = args2;
+          if (obj.force === true)
+            force = true;
+        }
+      } catch {}
+      if (force) {
+        const manifestPath = path36.join(directory, ".swarm", "doc-manifest.json");
+        try {
+          fs25.unlinkSync(manifestPath);
+        } catch {}
+      }
+      const { manifest, cached: cached3 } = await scanDocIndex(directory);
+      return JSON.stringify({
+        success: true,
+        files_count: manifest.files.length,
+        cached: cached3,
+        manifest
+      }, null, 2);
+    }
+  });
+  doc_extract = createSwarmTool({
+    description: "Extract actionable constraints from project documentation relevant to the current task. Scans docs via doc-manifest, scores relevance via Jaccard bigram similarity, and stores non-duplicate constraints in .swarm/knowledge.jsonl.",
+    args: {
+      task_files: tool.schema.array(tool.schema.string()).describe("List of file paths involved in the current task"),
+      task_description: tool.schema.string().describe("Description of the current task")
+    },
+    execute: async (args2, directory) => {
+      let taskFiles = [];
+      let taskDescription = "";
+      try {
+        if (args2 && typeof args2 === "object") {
+          const obj = args2;
+          if (Array.isArray(obj.task_files)) {
+            taskFiles = obj.task_files.filter((f) => typeof f === "string");
+          }
+          if (typeof obj.task_description === "string") {
+            taskDescription = obj.task_description;
+          }
+        }
+      } catch {}
+      if (taskFiles.length === 0 && !taskDescription) {
+        return JSON.stringify({
+          success: false,
+          error: "task_files or task_description is required"
+        });
+      }
+      const result = await extractDocConstraints(directory, taskFiles, taskDescription);
+      return JSON.stringify({ success: true, ...result }, null, 2);
+    }
+  });
+});
+
 // src/hooks/curator-drift.ts
 var exports_curator_drift = {};
 __export(exports_curator_drift, {
@@ -36651,11 +37303,11 @@ __export(exports_curator_drift, {
   readPriorDriftReports: () => readPriorDriftReports,
   buildDriftInjectionText: () => buildDriftInjectionText
 });
-import * as fs27 from "fs";
-import * as path38 from "path";
+import * as fs28 from "fs";
+import * as path39 from "path";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path38.join(directory, ".swarm");
-  const entries = await fs27.promises.readdir(swarmDir).catch(() => null);
+  const swarmDir = path39.join(directory, ".swarm");
+  const entries = await fs28.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
   const reportFiles = entries.filter((name2) => name2.startsWith(DRIFT_REPORT_PREFIX) && name2.endsWith(".json")).sort();
@@ -36666,7 +37318,7 @@ async function readPriorDriftReports(directory) {
       continue;
     try {
       const report = JSON.parse(content);
-      if (typeof report.phase !== "number" || typeof report.alignment !== "string") {
+      if (typeof report.phase !== "number" || typeof report.alignment !== "string" || typeof report.timestamp !== "string" || typeof report.drift_score !== "number" || typeof report.schema_version !== "number" || !Array.isArray(report.compounding_effects)) {
         console.warn(`[curator-drift] Skipping corrupt drift report: ${filename}`);
         continue;
       }
@@ -36681,10 +37333,10 @@ async function readPriorDriftReports(directory) {
 async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
-  const swarmDir = path38.dirname(filePath);
-  await fs27.promises.mkdir(swarmDir, { recursive: true });
+  const swarmDir = path39.dirname(filePath);
+  await fs28.promises.mkdir(swarmDir, { recursive: true });
   try {
-    await fs27.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs28.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
   } catch (err2) {
     throw new Error(`[curator-drift] Failed to write drift report to ${filePath}: ${String(err2)}`);
   }
@@ -38274,11 +38926,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path45) {
+      function locateFile(path46) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path45, scriptDirectory);
+          return Module["locateFile"](path46, scriptDirectory);
         }
-        return scriptDirectory + path45;
+        return scriptDirectory + path46;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -40063,8 +40715,8 @@ async function loadGrammar(languageId) {
   const wasmFileName = getWasmFileName(normalizedId);
   const grammarsPath = getGrammarsPath();
   const wasmPath = fileURLToPath(new URL(`${grammarsPath}${wasmFileName}`, import.meta.url));
-  const { existsSync: existsSync27 } = await import("fs");
-  if (!existsSync27(wasmPath)) {
+  const { existsSync: existsSync28 } = await import("fs");
+  if (!existsSync28(wasmPath)) {
     throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
 Make sure to run 'bun run build' to copy grammar files to dist/lang/grammars/`);
   }
@@ -40094,8 +40746,6 @@ var init_runtime = __esm(() => {
     c: "tree-sitter-cpp.wasm",
     csharp: "tree-sitter-c-sharp.wasm",
     css: "tree-sitter-css.wasm",
-    html: "tree-sitter-html.wasm",
-    json: "tree-sitter-json.wasm",
     bash: "tree-sitter-bash.wasm",
     ruby: "tree-sitter-ruby.wasm",
     php: "tree-sitter-php.wasm",
@@ -40188,7 +40838,9 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
   applyRehydrationCache(sessionState);
   if (directory) {
     let rehydrationPromise;
-    rehydrationPromise = rehydrateSessionFromDisk(directory, sessionState).catch(() => {}).finally(() => {
+    rehydrationPromise = rehydrateSessionFromDisk(directory, sessionState).catch((err2) => {
+      console.warn("[state] Rehydration failed:", err2 instanceof Error ? err2.message : String(err2));
+    }).finally(() => {
       swarmState.pendingRehydrations.delete(rehydrationPromise);
     });
     swarmState.pendingRehydrations.add(rehydrationPromise);
@@ -40701,10 +41353,11 @@ Two small delegations with two QA gates > one large delegation with one QA gate.
    Never silently consume LOW-confidence result as verified.
 6f-1. **DOCUMENTATION AWARENESS**
 Before implementation begins:
-1. Check if .swarm/doc-manifest.json exists. If not, delegate to explorer to run DOCUMENTATION DISCOVERY MODE.
+1. Check if .swarm/doc-manifest.json exists. If not, delegate to explorer to run DOCUMENTATION DISCOVERY MODE (or call doc_scan directly).
 2. The explorer indexes project documentation (CONTRIBUTING.md, architecture.md, README.md, etc.) and writes constraints to the knowledge system.
-3. Before starting each phase, call knowledge_recall with query "doc-constraints" to check if any project documentation constrains the current task.
-4. Key constraints from project docs (commit conventions, release process, test framework, platform requirements) take priority over your own assumptions.
+3. When beginning a new task, if .swarm/doc-manifest.json exists, call doc_extract with the task's file list and description to load relevant documentation constraints.
+4. Before starting each phase, call knowledge_recall with query "doc-constraints" to check if any project documentation constrains the current task.
+5. Key constraints from project docs (commit conventions, release process, test framework, platform requirements) take priority over your own assumptions.
        7. **TIERED QA GATE** \u2014 Execute AFTER every coder task. Pipeline determined by change tier:
 NOTE: These gates are enforced by runtime hooks. If you skip the {{AGENT_PREFIX}}reviewer delegation,
 the next coder delegation will be BLOCKED by the plugin. This is not a suggestion \u2014
@@ -42423,9 +43076,10 @@ MIGRATION_NEEDED: [yes \u2014 description of required caller updates | no]
 
 ## DOCUMENTATION DISCOVERY MODE
 Activates automatically during codebase reality check at plan ingestion.
+Use the doc_scan tool to scan and index documentation files. If doc_scan is unavailable, fall back to manual globbing.
 
 STEPS:
-1. Glob for documentation files:
+1. Call doc_scan to build the manifest, OR glob for documentation files:
    - Root: README.md, CONTRIBUTING.md, CHANGELOG.md, ARCHITECTURE.md, CLAUDE.md, AGENTS.md, .github/*.md
    - docs/**/*.md, doc/**/*.md (one level deep only)
 
@@ -44580,7 +45234,24 @@ async function handleBenchmarkCommand(directory, args2) {
 }
 
 // src/commands/checkpoint.ts
+init_zod();
 init_checkpoint();
+var CheckpointResultSchema = exports_external.object({
+  action: exports_external.string().optional(),
+  success: exports_external.boolean(),
+  error: exports_external.string().optional(),
+  checkpoints: exports_external.array(exports_external.unknown()).optional()
+}).passthrough();
+function safeParseResult(result) {
+  const parsed = CheckpointResultSchema.safeParse(JSON.parse(result));
+  if (!parsed.success) {
+    return {
+      success: false,
+      error: `Invalid response: ${parsed.error.message}`
+    };
+  }
+  return parsed.data;
+}
 async function handleCheckpointCommand(directory, args2) {
   const subcommand = args2[0] || "list";
   const label = args2[1];
@@ -44603,7 +45274,7 @@ async function handleSave2(directory, label) {
     const result = await checkpoint.execute({ action: "save", label }, {
       directory
     });
-    const parsed = JSON.parse(result);
+    const parsed = safeParseResult(result);
     if (parsed.success) {
       return `\u2713 Checkpoint saved: "${label}"`;
     } else {
@@ -44622,7 +45293,7 @@ async function handleRestore2(directory, label) {
     const result = await checkpoint.execute({ action: "restore", label }, {
       directory
     });
-    const parsed = JSON.parse(result);
+    const parsed = safeParseResult(result);
     if (parsed.success) {
       return `\u2713 Restored to checkpoint: "${label}"`;
     } else {
@@ -44641,7 +45312,7 @@ async function handleDelete2(directory, label) {
     const result = await checkpoint.execute({ action: "delete", label }, {
       directory
     });
-    const parsed = JSON.parse(result);
+    const parsed = safeParseResult(result);
     if (parsed.success) {
       return `\u2713 Checkpoint deleted: "${label}"`;
     } else {
@@ -44657,7 +45328,7 @@ async function handleList2(directory) {
     const result = await checkpoint.execute({ action: "list" }, {
       directory
     });
-    const parsed = JSON.parse(result);
+    const parsed = safeParseResult(result);
     if (!parsed.success) {
       return `Error: ${parsed.error || "Failed to list checkpoints"}`;
     }
@@ -44729,162 +45400,7 @@ import path15 from "path";
 import * as fs9 from "fs";
 import * as path13 from "path";
 init_event_bus();
-
-// src/hooks/knowledge-store.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync7 } from "fs";
-import { appendFile, mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import * as os4 from "os";
-import * as path12 from "path";
-function resolveSwarmKnowledgePath(directory) {
-  return path12.join(directory, ".swarm", "knowledge.jsonl");
-}
-function resolveSwarmRejectedPath(directory) {
-  return path12.join(directory, ".swarm", "knowledge-rejected.jsonl");
-}
-function resolveHiveKnowledgePath() {
-  const platform = process.platform;
-  const home = os4.homedir();
-  let dataDir;
-  if (platform === "win32") {
-    dataDir = path12.join(process.env.LOCALAPPDATA || path12.join(home, "AppData", "Local"), "opencode-swarm", "Data");
-  } else if (platform === "darwin") {
-    dataDir = path12.join(home, "Library", "Application Support", "opencode-swarm");
-  } else {
-    dataDir = path12.join(process.env.XDG_DATA_HOME || path12.join(home, ".local", "share"), "opencode-swarm");
-  }
-  return path12.join(dataDir, "shared-learnings.jsonl");
-}
-function resolveHiveRejectedPath() {
-  const hivePath = resolveHiveKnowledgePath();
-  return path12.join(path12.dirname(hivePath), "shared-learnings-rejected.jsonl");
-}
-async function readKnowledge(filePath) {
-  if (!existsSync7(filePath))
-    return [];
-  const content = await readFile2(filePath, "utf-8");
-  const results = [];
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      results.push(JSON.parse(trimmed));
-    } catch {
-      console.warn(`[knowledge-store] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return results;
-}
-async function readRejectedLessons(directory) {
-  return readKnowledge(resolveSwarmRejectedPath(directory));
-}
-async function appendKnowledge(filePath, entry) {
-  await mkdir(path12.dirname(filePath), { recursive: true });
-  await appendFile(filePath, `${JSON.stringify(entry)}
-`, "utf-8");
-}
-async function rewriteKnowledge(filePath, entries) {
-  const dir = path12.dirname(filePath);
-  await mkdir(dir, { recursive: true });
-  let release = null;
-  try {
-    release = await import_proper_lockfile.default.lock(dir, {
-      retries: { retries: 3, minTimeout: 100 }
-    });
-    const content = entries.map((e) => JSON.stringify(e)).join(`
-`) + (entries.length > 0 ? `
-` : "");
-    await writeFile(filePath, content, "utf-8");
-  } finally {
-    if (release) {
-      try {
-        await release();
-      } catch {}
-    }
-  }
-}
-async function appendRejectedLesson(directory, lesson) {
-  const filePath = resolveSwarmRejectedPath(directory);
-  const existing = await readRejectedLessons(directory);
-  const MAX = 20;
-  const updated = [...existing, lesson];
-  if (updated.length > MAX) {
-    const trimmed = updated.slice(updated.length - MAX);
-    await rewriteKnowledge(filePath, trimmed);
-  } else {
-    await appendKnowledge(filePath, lesson);
-  }
-}
-function normalize2(text) {
-  return text.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
-}
-function wordBigrams(text) {
-  const words = normalize2(text).split(" ").filter(Boolean);
-  const bigrams = new Set;
-  for (let i2 = 0;i2 < words.length - 1; i2++) {
-    bigrams.add(`${words[i2]} ${words[i2 + 1]}`);
-  }
-  return bigrams;
-}
-function jaccardBigram(a, b) {
-  if (a.size === 0 && b.size === 0)
-    return 1;
-  const aArr = Array.from(a);
-  const intersection3 = new Set(aArr.filter((x) => b.has(x)));
-  const union3 = new Set([...aArr, ...Array.from(b)]);
-  return intersection3.size / union3.size;
-}
-function findNearDuplicate(candidate, entries, threshold = 0.6) {
-  const candidateBigrams = wordBigrams(candidate);
-  return entries.find((entry) => {
-    const entryBigrams = wordBigrams(entry.lesson);
-    return jaccardBigram(candidateBigrams, entryBigrams) >= threshold;
-  });
-}
-function computeConfidence(confirmedByCount, autoGenerated) {
-  let score = 0.5;
-  score += Math.min(confirmedByCount, 3) * 0.1;
-  if (!autoGenerated)
-    score += 0.1;
-  return Math.min(score, 1);
-}
-function inferTags(lesson) {
-  const lower = lesson.toLowerCase();
-  const tags = [];
-  if (/\b(?:typescript|ts)\b/.test(lower))
-    tags.push("typescript");
-  if (/\b(?:javascript|js)\b/.test(lower))
-    tags.push("javascript");
-  if (/\b(?:python)\b/.test(lower))
-    tags.push("python");
-  if (/\b(?:bun|node|deno)\b/.test(lower))
-    tags.push("runtime");
-  if (/\b(?:react|vue|svelte|angular)\b/.test(lower))
-    tags.push("frontend");
-  if (/\b(?:git|github|gitlab)\b/.test(lower))
-    tags.push("git");
-  if (/\b(?:docker|kubernetes|k8s)\b/.test(lower))
-    tags.push("container");
-  if (/\b(?:sql|postgres|mysql|sqlite)\b/.test(lower))
-    tags.push("database");
-  if (/\b(?:test|spec|vitest|jest|mocha)\b/.test(lower))
-    tags.push("testing");
-  if (/\b(?:ci|cd|pipeline|workflow|action)\b/.test(lower))
-    tags.push("ci-cd");
-  if (/\b(?:security|auth|token|password|encrypt)\b/.test(lower))
-    tags.push("security");
-  if (/\b(?:performance|latency|throughput|cache)\b/.test(lower))
-    tags.push("performance");
-  if (/\b(?:api|rest|graphql|grpc|endpoint)\b/.test(lower))
-    tags.push("api");
-  if (/\b(?:swarm|architect|agent|hook|plan)\b/.test(lower))
-    tags.push("opencode-swarm");
-  return Array.from(new Set(tags));
-}
-
-// src/hooks/curator.ts
+init_knowledge_store();
 init_utils2();
 var CURATOR_LLM_TIMEOUT_MS = 30000;
 function parseKnowledgeRecommendations(llmOutput) {
@@ -45387,7 +45903,11 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, _knowled
   return { applied, skipped };
 }
 
+// src/hooks/hive-promoter.ts
+init_knowledge_store();
+
 // src/hooks/knowledge-validator.ts
+init_knowledge_store();
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 import { appendFile as appendFile2, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import * as path14 from "path";
@@ -45993,6 +46513,7 @@ async function promoteFromSwarm(directory, lessonId) {
 }
 
 // src/commands/curate.ts
+init_knowledge_store();
 async function handleCurateCommand(directory, _args) {
   try {
     const config3 = KnowledgeConfigSchema.parse({});
@@ -46021,6 +46542,7 @@ function formatCurationSummary(summary) {
 }
 
 // src/commands/dark-matter.ts
+init_knowledge_store();
 import path17 from "path";
 
 // src/tools/co-change-analyzer.ts
@@ -47862,7 +48384,8 @@ async function extractFromLegacy(directory) {
       mappedStatus = "complete";
     else if (status === "IN PROGRESS")
       mappedStatus = "in_progress";
-    const headerLineIndex = lines.indexOf(match[0]);
+    const headerLineIndex = planContent.substring(0, match.index).split(`
+`).length - 1;
     let completed = 0;
     let total = 0;
     if (headerLineIndex !== -1) {
@@ -47927,6 +48450,7 @@ async function handleHistoryCommand(directory, _args) {
 init_schema();
 
 // src/hooks/knowledge-migrator.ts
+init_knowledge_store();
 import { randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
@@ -48155,6 +48679,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
 }
 
 // src/commands/knowledge.ts
+init_knowledge_store();
 async function handleKnowledgeQuarantineCommand(directory, args2) {
   const entryId = args2[0];
   if (!entryId) {
@@ -48260,9 +48785,9 @@ async function getPlanData(directory, phaseArg) {
       return {
         hasPlan: true,
         fullMarkdown,
-        requestedPhase: NaN,
+        requestedPhase: null,
         phaseMarkdown: null,
-        errorMessage: null,
+        errorMessage: `Invalid phase number: "${phaseArg}"`,
         isLegacy: false
       };
     }
@@ -48313,9 +48838,9 @@ async function getPlanData(directory, phaseArg) {
     return {
       hasPlan: true,
       fullMarkdown: planContent,
-      requestedPhase: NaN,
+      requestedPhase: null,
       phaseMarkdown: null,
-      errorMessage: null,
+      errorMessage: `Invalid phase number: "${phaseArg}"`,
       isLegacy: true
     };
   }
@@ -48555,9 +49080,16 @@ function sanitizeSummaryId(id) {
 }
 async function storeSummary(directory, id, fullOutput, summaryText, maxStoredBytes) {
   const sanitizedId = sanitizeSummaryId(id);
-  const outputBytes = Buffer.byteLength(fullOutput, "utf8");
-  if (outputBytes > maxStoredBytes) {
-    throw new Error(`Summary fullOutput size (${outputBytes} bytes) exceeds maximum (${maxStoredBytes} bytes)`);
+  const preCheckEntry = {
+    id: sanitizedId,
+    summaryText,
+    fullOutput,
+    timestamp: Date.now(),
+    originalBytes: Buffer.byteLength(fullOutput, "utf8")
+  };
+  const serializedSize = Buffer.byteLength(JSON.stringify(preCheckEntry), "utf8");
+  if (serializedSize > maxStoredBytes) {
+    throw new Error(`Summary entry size (${serializedSize} bytes) exceeds maximum (${maxStoredBytes} bytes)`);
   }
   const relativePath = path27.join("summaries", `${sanitizedId}.json`);
   const summaryPath = validateSwarmPath(directory, relativePath);
@@ -48567,7 +49099,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
     summaryText,
     fullOutput,
     timestamp: Date.now(),
-    originalBytes: outputBytes
+    originalBytes: Buffer.byteLength(fullOutput, "utf8")
   };
   const entryJson = JSON.stringify(entry);
   mkdirSync9(summaryDir, { recursive: true });
@@ -49133,7 +49665,15 @@ function makeInitialState() {
     lastSnapshotAt: null
   };
 }
-var state = makeInitialState();
+var sessionStates = new Map;
+function getSessionState(sessionId) {
+  let state = sessionStates.get(sessionId);
+  if (!state) {
+    state = makeInitialState();
+    sessionStates.set(sessionId, state);
+  }
+  return state;
+}
 function appendSnapshot(directory, tier, budgetPct, message) {
   try {
     const snapshotPath = path29.join(directory, ".swarm", "context-snapshot.md");
@@ -49172,6 +49712,7 @@ function createCompactionService(config3, directory, injectMessage) {
       if (budgetPct <= 0)
         return;
       const sessionId = _input.sessionID;
+      const state = getSessionState(sessionId);
       try {
         if (budgetPct >= config3.emergencyThreshold && budgetPct > state.lastEmergencyAt + 5) {
           state.lastEmergencyAt = budgetPct;
@@ -49203,29 +49744,27 @@ function createCompactionService(config3, directory, injectMessage) {
     }
   };
 }
-function getCompactionMetrics() {
-  return {
-    compactionCount: state.observationCount + state.reflectionCount + state.emergencyCount,
-    lastSnapshotAt: state.lastSnapshotAt
-  };
+function getCompactionMetrics(sessionId) {
+  if (sessionId) {
+    const state = getSessionState(sessionId);
+    return {
+      compactionCount: state.observationCount + state.reflectionCount + state.emergencyCount,
+      lastSnapshotAt: state.lastSnapshotAt
+    };
+  }
+  let total = 0;
+  let lastSnapshot = null;
+  for (const state of sessionStates.values()) {
+    total += state.observationCount + state.reflectionCount + state.emergencyCount;
+    if (state.lastSnapshotAt && (!lastSnapshot || state.lastSnapshotAt > lastSnapshot)) {
+      lastSnapshot = state.lastSnapshotAt;
+    }
+  }
+  return { compactionCount: total, lastSnapshotAt: lastSnapshot };
 }
 
 // src/services/context-budget-service.ts
 init_utils2();
-function validateDirectory(directory) {
-  if (!directory || directory.trim() === "") {
-    throw new Error("Invalid directory: empty");
-  }
-  if (/\.\.[/\\]/.test(directory)) {
-    throw new Error("Invalid directory: path traversal detected");
-  }
-  if (directory.startsWith("/") || directory.startsWith("\\")) {
-    throw new Error("Invalid directory: absolute path");
-  }
-  if (/^[A-Za-z]:[\\/]/.test(directory)) {
-    throw new Error("Invalid directory: Windows absolute path");
-  }
-}
 var DEFAULT_CONTEXT_BUDGET_CONFIG = {
   enabled: true,
   budgetTokens: 40000,
@@ -49252,10 +49791,14 @@ async function readBudgetState(directory) {
     return null;
   }
 }
-async function writeBudgetState(directory, state2) {
-  const resolvedPath = validateSwarmPath(directory, "session/budget-state.json");
-  const content = JSON.stringify(state2, null, 2);
-  await Bun.write(resolvedPath, content);
+async function writeBudgetState(directory, state) {
+  try {
+    const resolvedPath = validateSwarmPath(directory, "session/budget-state.json");
+    const content = JSON.stringify(state, null, 2);
+    await Bun.write(resolvedPath, content);
+  } catch (error93) {
+    console.warn("[context-budget] Failed to write budget state:", error93 instanceof Error ? error93.message : String(error93));
+  }
 }
 async function countEvents(directory) {
   const content = await readSwarmFileAsync(directory, "events.jsonl");
@@ -49343,25 +49886,25 @@ async function formatBudgetWarning(report, directory, config3) {
     return formatWarningMessage(report);
   }
   const budgetState = await readBudgetState(directory);
-  const state2 = budgetState || {
+  const state = budgetState || {
     warningFiredAtTurn: null,
     criticalFiredAtTurn: null,
     lastInjectedAtTurn: null
   };
   const currentTurn = report.estimatedTurnCount;
   if (report.status === "warning") {
-    if (config3.warningMode === "once" && state2.warningFiredAtTurn !== null) {
+    if (config3.warningMode === "once" && state.warningFiredAtTurn !== null) {
       return null;
     }
-    if (config3.warningMode === "interval" && state2.warningFiredAtTurn !== null && currentTurn - state2.warningFiredAtTurn < config3.warningIntervalTurns) {
+    if (config3.warningMode === "interval" && state.warningFiredAtTurn !== null && currentTurn - state.warningFiredAtTurn < config3.warningIntervalTurns) {
       return null;
     }
-    state2.warningFiredAtTurn = currentTurn;
-    state2.lastInjectedAtTurn = currentTurn;
-    await writeBudgetState(directory, state2);
+    state.warningFiredAtTurn = currentTurn;
+    state.lastInjectedAtTurn = currentTurn;
+    await writeBudgetState(directory, state);
   } else if (report.status === "critical") {
-    state2.criticalFiredAtTurn = currentTurn;
-    state2.lastInjectedAtTurn = currentTurn;
+    state.criticalFiredAtTurn = currentTurn;
+    state.lastInjectedAtTurn = currentTurn;
   }
   return formatWarningMessage(report);
 }
@@ -49525,6 +50068,7 @@ async function handleTurboCommand(_directory, args2, sessionID) {
 
 // src/tools/write-retro.ts
 init_tool();
+init_evidence_schema();
 init_manager();
 init_create_tool();
 async function executeWriteRetro(args2, directory) {
@@ -49759,8 +50303,9 @@ async function executeWriteRetro(args2, directory) {
   };
   const taxonomy = [];
   try {
-    for (const taskSuffix of ["1", "2", "3", "4", "5"]) {
-      const phaseTaskId = `${phase}.${taskSuffix}`;
+    const allTaskIds = await listEvidenceTaskIds(directory);
+    const phaseTaskIds = allTaskIds.filter((id) => id.startsWith(`${phase}.`));
+    for (const phaseTaskId of phaseTaskIds) {
       const result = await loadEvidence(directory, phaseTaskId);
       if (result.status !== "found")
         continue;
@@ -49794,6 +50339,13 @@ async function executeWriteRetro(args2, directory) {
     }
   } catch {}
   retroEntry.error_taxonomy = [...new Set(taxonomy)];
+  const validationResult = RetrospectiveEvidenceSchema.safeParse(retroEntry);
+  if (!validationResult.success) {
+    return JSON.stringify({
+      success: false,
+      error: `Retrospective entry failed validation: ${validationResult.error.message}`
+    }, null, 2);
+  }
   try {
     await saveEvidence(directory, taskId, retroEntry);
     return JSON.stringify({
@@ -49858,7 +50410,7 @@ var write_retro = createSwarmTool({
   }
 });
 
-// src/commands/write_retro.ts
+// src/commands/write-retro.ts
 async function handleWriteRetroCommand(directory, args2) {
   if (args2.length === 0 || !args2[0] || args2[0].trim() === "") {
     return `## Usage: /swarm write-retro <json>
@@ -50124,6 +50676,7 @@ init_schema();
 
 // src/hooks/agent-activity.ts
 import { renameSync as renameSync8, unlinkSync as unlinkSync4 } from "fs";
+import * as nodePath2 from "path";
 init_utils();
 init_utils2();
 function createAgentActivityHooks(config3, directory) {
@@ -50148,7 +50701,7 @@ function createAgentActivityHooks(config3, directory) {
         return;
       swarmState.activeToolCalls.delete(input.callID);
       const duration5 = Date.now() - entry.startTime;
-      const success3 = output.output != null;
+      const success3 = output.success === true;
       const key = entry.tool;
       const existing = swarmState.toolAggregates.get(key) ?? {
         tool: key,
@@ -50193,7 +50746,7 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path30 = `${directory}/.swarm/context.md`;
+    const path30 = nodePath2.join(directory, ".swarm", "context.md");
     const tempPath = `${path30}.tmp`;
     try {
       await Bun.write(tempPath, updated);
@@ -50247,7 +50800,7 @@ ${content.substring(endIndex + 1)}`;
 // src/hooks/compaction-customizer.ts
 init_manager2();
 import * as fs20 from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 init_utils2();
 function createCompactionCustomizerHook(config3, directory) {
   const enabled = config3.hooks?.compaction !== false;
@@ -50293,7 +50846,7 @@ function createCompactionCustomizerHook(config3, directory) {
         }
       }
       try {
-        const summariesDir = join26(directory, ".swarm", "summaries");
+        const summariesDir = join27(directory, ".swarm", "summaries");
         const files = await fs20.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
@@ -50849,6 +51402,67 @@ init_telemetry();
 import * as path30 from "path";
 init_constants();
 init_schema();
+
+// src/context/zone-classifier.ts
+function classifyFile(filePath) {
+  const normalized = filePath.toLowerCase().replace(/\\/g, "/");
+  if (normalized.endsWith(".wasm") || normalized.includes("/dist/") || normalized.includes("/build/") || normalized.includes(".swarm/checkpoints/")) {
+    return {
+      filePath,
+      zone: "generated",
+      confidence: "high",
+      reason: "path matches generated file patterns"
+    };
+  }
+  if (normalized.includes("/test/") || normalized.includes("/tests/") || normalized.includes("/__tests__/") || normalized.includes(".test.") || normalized.includes(".spec.") || normalized.includes("/mocks/")) {
+    return {
+      filePath,
+      zone: "test",
+      confidence: "high",
+      reason: "path matches test/**, tests/**, __tests__/**, *.test.*, *.spec.*, or **/mocks/**"
+    };
+  }
+  if (normalized.includes("/scripts/") || normalized.includes("makefile") || normalized.includes("dockerfile") || normalized.includes(".github/")) {
+    return {
+      filePath,
+      zone: "build",
+      confidence: "high",
+      reason: "path matches build scripts or CI configuration"
+    };
+  }
+  if (normalized.endsWith(".json") && !normalized.includes(".github/") || normalized.endsWith(".yaml") && !normalized.includes(".github/") || normalized.endsWith(".yml") && !normalized.includes(".github/") || normalized.endsWith(".toml") || normalized.includes(".env") || normalized.endsWith("biome.json") || normalized.endsWith("tsconfig.json")) {
+    return {
+      filePath,
+      zone: "config",
+      confidence: "high",
+      reason: "extension is config file type"
+    };
+  }
+  if (normalized.includes("/docs/") || normalized.endsWith(".md") && !normalized.includes("/") || normalized.includes("readme") || normalized.includes("changelog") || normalized.includes("license")) {
+    return {
+      filePath,
+      zone: "docs",
+      confidence: "high",
+      reason: "path matches docs/** or documentation files"
+    };
+  }
+  if (normalized.includes("/src/") || normalized.includes("/lib/")) {
+    return {
+      filePath,
+      zone: "production",
+      confidence: "high",
+      reason: "path matches src/** or lib/**"
+    };
+  }
+  return {
+    filePath,
+    zone: "production",
+    confidence: "medium",
+    reason: "default classification"
+  };
+}
+
+// src/hooks/guardrails.ts
 init_manager2();
 init_telemetry();
 init_utils();
@@ -51138,6 +51752,12 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
           const delegArgs = output.args;
           const delegTargetPath = delegArgs?.filePath ?? delegArgs?.path ?? delegArgs?.file ?? delegArgs?.target;
           if (typeof delegTargetPath === "string" && delegTargetPath.length > 0) {
+            const agentName2 = swarmState.activeAgent.get(input.sessionID) ?? "unknown";
+            const cwd = directory ?? process.cwd();
+            const authorityCheck = checkFileAuthority(agentName2, delegTargetPath, cwd);
+            if (!authorityCheck.allowed) {
+              throw new Error(`WRITE BLOCKED: Agent "${agentName2}" is not authorised to write "${delegTargetPath}". Reason: ${authorityCheck.reason}`);
+            }
             if (!currentSession.modifiedFilesThisCoderTask.includes(delegTargetPath)) {
               currentSession.modifiedFilesThisCoderTask.push(delegTargetPath);
             }
@@ -51446,7 +52066,7 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
           session.partialGateWarningsIssuedForTask?.delete(session.currentTaskId);
           if (session.declaredCoderScope !== null) {
             const undeclaredFiles = session.modifiedFilesThisCoderTask.map((f) => f.replace(/[\r\n\t]/g, "_")).filter((f) => !isInDeclaredScope(f, session.declaredCoderScope));
-            if (undeclaredFiles.length > 2) {
+            if (undeclaredFiles.length >= 1) {
               const safeTaskId = String(session.currentTaskId ?? "").replace(/[\r\n\t]/g, "_");
               session.lastScopeViolation = `Scope violation for task ${safeTaskId}: ` + `${undeclaredFiles.length} undeclared files modified: ` + undeclaredFiles.join(", ");
               session.scopeViolationDetected = true;
@@ -51832,6 +52452,98 @@ function hashArgs(args2) {
     return 0;
   }
 }
+var AGENT_AUTHORITY_RULES = {
+  architect: {
+    blockedExact: [".swarm/plan.md", ".swarm/plan.json"],
+    blockedZones: ["generated"]
+  },
+  coder: {
+    blockedPrefix: [".swarm/"],
+    allowedPrefix: ["src/", "tests/", "docs/", "scripts/"],
+    blockedZones: ["generated", "config"]
+  },
+  reviewer: {
+    blockedExact: [".swarm/plan.md", ".swarm/plan.json"],
+    blockedPrefix: ["src/"],
+    allowedPrefix: [".swarm/evidence/", ".swarm/outputs/"],
+    blockedZones: ["generated"]
+  },
+  explorer: {
+    readOnly: true
+  },
+  sme: {
+    readOnly: true
+  },
+  test_engineer: {
+    blockedExact: [".swarm/plan.md", ".swarm/plan.json"],
+    blockedPrefix: ["src/"],
+    allowedPrefix: ["tests/", ".swarm/evidence/"],
+    blockedZones: ["generated"]
+  },
+  docs: {
+    allowedPrefix: ["docs/", ".swarm/outputs/"],
+    blockedZones: ["generated"]
+  },
+  designer: {
+    allowedPrefix: ["docs/", ".swarm/outputs/"],
+    blockedZones: ["generated"]
+  },
+  critic: {
+    allowedPrefix: [".swarm/evidence/"],
+    blockedZones: ["generated"]
+  }
+};
+function checkFileAuthority(agentName, filePath, _cwd) {
+  const normalizedAgent = agentName.toLowerCase();
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const rules = AGENT_AUTHORITY_RULES[normalizedAgent];
+  if (!rules) {
+    return { allowed: false, reason: `Unknown agent: ${agentName}` };
+  }
+  if (rules.readOnly) {
+    return {
+      allowed: false,
+      reason: `Path blocked: ${normalizedPath} (agent ${normalizedAgent} is read-only)`
+    };
+  }
+  if (rules.blockedExact) {
+    for (const blocked of rules.blockedExact) {
+      if (normalizedPath === blocked) {
+        return { allowed: false, reason: `Path blocked: ${normalizedPath}` };
+      }
+    }
+  }
+  if (rules.blockedPrefix) {
+    for (const prefix of rules.blockedPrefix) {
+      if (normalizedPath.startsWith(prefix)) {
+        return {
+          allowed: false,
+          reason: `Path blocked: ${normalizedPath} is under ${prefix}`
+        };
+      }
+    }
+  }
+  if (rules.allowedPrefix && rules.allowedPrefix.length > 0) {
+    const isAllowed = rules.allowedPrefix.some((prefix) => normalizedPath.startsWith(prefix));
+    if (!isAllowed) {
+      return {
+        allowed: false,
+        reason: `Path ${normalizedPath} not in allowed list for ${normalizedAgent}`
+      };
+    }
+  }
+  if (rules.blockedZones && rules.blockedZones.length > 0) {
+    const { zone } = classifyFile(normalizedPath);
+    if (rules.blockedZones.includes(zone)) {
+      return {
+        allowed: false,
+        reason: `Path blocked: ${normalizedPath} is in ${zone} zone`,
+        zone
+      };
+    }
+  }
+  return { allowed: true };
+}
 
 // src/hooks/delegation-gate.ts
 init_utils2();
@@ -51936,8 +52648,8 @@ function createDelegationGateHook(config3, directory) {
     const session = swarmState.agentSessions.get(input.sessionID);
     if (!session || !session.taskWorkflowStates)
       return;
-    for (const [taskId, state2] of session.taskWorkflowStates) {
-      if (state2 !== "coder_delegated")
+    for (const [taskId, state] of session.taskWorkflowStates) {
+      if (state !== "coder_delegated")
         continue;
       const turbo = hasActiveTurboMode(input.sessionID);
       if (turbo) {
@@ -51968,23 +52680,23 @@ function createDelegationGateHook(config3, directory) {
         if (targetAgent === "test_engineer")
           hasTestEngineer = true;
         if (targetAgent === "reviewer" && session.taskWorkflowStates) {
-          for (const [taskId, state2] of session.taskWorkflowStates) {
-            if (state2 === "coder_delegated" || state2 === "pre_check_passed") {
+          for (const [taskId, state] of session.taskWorkflowStates) {
+            if (state === "coder_delegated" || state === "pre_check_passed") {
               try {
                 advanceTaskState(session, taskId, "reviewer_run");
               } catch (err2) {
-                console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state2}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
               }
             }
           }
         }
         if (targetAgent === "test_engineer" && session.taskWorkflowStates) {
-          for (const [taskId, state2] of session.taskWorkflowStates) {
-            if (state2 === "reviewer_run") {
+          for (const [taskId, state] of session.taskWorkflowStates) {
+            if (state === "reviewer_run") {
               try {
                 advanceTaskState(session, taskId, "tests_run");
               } catch (err2) {
-                console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state2}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
               }
             }
           }
@@ -52000,12 +52712,12 @@ function createDelegationGateHook(config3, directory) {
               if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
                 otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
               }
-              for (const [taskId, state2] of otherSession.taskWorkflowStates) {
-                if (state2 === "coder_delegated" || state2 === "pre_check_passed") {
+              for (const [taskId, state] of otherSession.taskWorkflowStates) {
+                if (state === "coder_delegated" || state === "pre_check_passed") {
                   try {
                     advanceTaskState(otherSession, taskId, "reviewer_run");
                   } catch (err2) {
-                    console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state2}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -52015,12 +52727,12 @@ function createDelegationGateHook(config3, directory) {
               if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
                 otherSession.taskWorkflowStates.set(seedTaskId, "reviewer_run");
               }
-              for (const [taskId, state2] of otherSession.taskWorkflowStates) {
-                if (state2 === "reviewer_run") {
+              for (const [taskId, state] of otherSession.taskWorkflowStates) {
+                if (state === "reviewer_run") {
                   try {
                     advanceTaskState(otherSession, taskId, "tests_run");
                   } catch (err2) {
-                    console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state2}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -52084,23 +52796,23 @@ function createDelegationGateHook(config3, directory) {
             session.qaSkipTaskIds = [];
           }
           if (lastCoderIndex !== -1 && hasReviewer && session.taskWorkflowStates) {
-            for (const [taskId, state2] of session.taskWorkflowStates) {
-              if (state2 === "coder_delegated" || state2 === "pre_check_passed") {
+            for (const [taskId, state] of session.taskWorkflowStates) {
+              if (state === "coder_delegated" || state === "pre_check_passed") {
                 try {
                   advanceTaskState(session, taskId, "reviewer_run");
                 } catch (err2) {
-                  console.warn(`[delegation-gate] fallback: could not advance ${taskId} (${state2}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                  console.warn(`[delegation-gate] fallback: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                 }
               }
             }
           }
           if (lastCoderIndex !== -1 && hasReviewer && hasTestEngineer && session.taskWorkflowStates) {
-            for (const [taskId, state2] of session.taskWorkflowStates) {
-              if (state2 === "reviewer_run") {
+            for (const [taskId, state] of session.taskWorkflowStates) {
+              if (state === "reviewer_run") {
                 try {
                   advanceTaskState(session, taskId, "tests_run");
                 } catch (err2) {
-                  console.warn(`[delegation-gate] fallback: could not advance ${taskId} (${state2}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                  console.warn(`[delegation-gate] fallback: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                 }
               }
             }
@@ -52115,12 +52827,12 @@ function createDelegationGateHook(config3, directory) {
               if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
                 otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
               }
-              for (const [taskId, state2] of otherSession.taskWorkflowStates) {
-                if (state2 === "coder_delegated" || state2 === "pre_check_passed") {
+              for (const [taskId, state] of otherSession.taskWorkflowStates) {
+                if (state === "coder_delegated" || state === "pre_check_passed") {
                   try {
                     advanceTaskState(otherSession, taskId, "reviewer_run");
                   } catch (err2) {
-                    console.warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state2}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    console.warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -52136,12 +52848,12 @@ function createDelegationGateHook(config3, directory) {
               if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
                 otherSession.taskWorkflowStates.set(seedTaskId, "reviewer_run");
               }
-              for (const [taskId, state2] of otherSession.taskWorkflowStates) {
-                if (state2 === "reviewer_run") {
+              for (const [taskId, state] of otherSession.taskWorkflowStates) {
+                if (state === "reviewer_run") {
                   try {
                     advanceTaskState(otherSession, taskId, "tests_run");
                   } catch (err2) {
-                    console.warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state2}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    console.warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -52720,7 +53432,7 @@ init_schema();
 init_manager();
 init_detector();
 init_manager2();
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
@@ -53592,6 +54304,13 @@ function createSystemEnhancerHook(config3, directory) {
         const maxInjectionTokens = config3.context_budget?.max_injection_tokens ?? Number.POSITIVE_INFINITY;
         let injectedTokens = 0;
         const contextContent = await readSwarmFileAsync(directory, "context.md");
+        try {
+          const { scanDocIndex: scanDocIndex2 } = await Promise.resolve().then(() => (init_doc_scan(), exports_doc_scan));
+          const { manifest, cached: cached3 } = await scanDocIndex2(directory);
+          if (!cached3) {
+            warn(`[system-enhancer] Doc manifest generated: ${manifest.files.length} files indexed`);
+          }
+        } catch {}
         const scoringEnabled = config3.context_budget?.scoring?.enabled === true;
         if (!scoringEnabled) {
           let plan2 = null;
@@ -53623,11 +54342,11 @@ function createSystemEnhancerHook(config3, directory) {
               if (handoffContent) {
                 const handoffPath = validateSwarmPath(directory, "handoff.md");
                 const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-                if (fs25.existsSync(consumedPath)) {
+                if (fs26.existsSync(consumedPath)) {
                   warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                  fs25.unlinkSync(consumedPath);
+                  fs26.unlinkSync(consumedPath);
                 }
-                fs25.renameSync(handoffPath, consumedPath);
+                fs26.renameSync(handoffPath, consumedPath);
                 const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -53773,7 +54492,7 @@ ${handoffBlock}`);
                   const lastHint = session.lastCompactionHint || 0;
                   for (const threshold of thresholds) {
                     if (totalToolCalls >= threshold && lastHint < threshold) {
-                      const totalToolCallsPlaceholder = "$" + "{totalToolCalls}";
+                      const totalToolCallsPlaceholder = "${totalToolCalls}";
                       const messageTemplate = compactionConfig?.message ?? `[SWARM HINT] Session has ${totalToolCallsPlaceholder} tool calls. Consider compacting at next phase boundary to maintain context quality.`;
                       const message = messageTemplate.replace(totalToolCallsPlaceholder, String(totalToolCalls));
                       tryInject(message);
@@ -53908,11 +54627,11 @@ ${budgetWarning}`);
             if (handoffContent) {
               const handoffPath = validateSwarmPath(directory, "handoff.md");
               const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-              if (fs25.existsSync(consumedPath)) {
+              if (fs26.existsSync(consumedPath)) {
                 warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                fs25.unlinkSync(consumedPath);
+                fs26.unlinkSync(consumedPath);
               }
-              fs25.renameSync(handoffPath, consumedPath);
+              fs26.renameSync(handoffPath, consumedPath);
               const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -54109,7 +54828,7 @@ ${handoffBlock}`;
                 const lastHint_b = session_b.lastCompactionHint || 0;
                 for (const threshold of thresholds_b) {
                   if (totalToolCalls_b >= threshold && lastHint_b < threshold) {
-                    const totalToolCallsPlaceholder_b = "$" + "{totalToolCalls}";
+                    const totalToolCallsPlaceholder_b = "${totalToolCalls}";
                     const messageTemplate_b = compactionConfig_b?.message ?? `[SWARM HINT] Session has ${totalToolCallsPlaceholder_b} tool calls. Consider compacting at next phase boundary to maintain context quality.`;
                     const compactionText = messageTemplate_b.replace(totalToolCallsPlaceholder_b, String(totalToolCalls_b));
                     candidates.push({
@@ -54682,8 +55401,8 @@ function isReadTool(toolName) {
 }
 
 // src/hooks/incremental-verify.ts
-import * as fs26 from "fs";
-import * as path36 from "path";
+import * as fs27 from "fs";
+import * as path37 from "path";
 
 // src/hooks/spawn-helper.ts
 import { spawn } from "child_process";
@@ -54758,21 +55477,21 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs26.existsSync(path36.join(projectDir, "bun.lockb")))
+  if (fs27.existsSync(path37.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs26.existsSync(path36.join(projectDir, "pnpm-lock.yaml")))
+  if (fs27.existsSync(path37.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs26.existsSync(path36.join(projectDir, "yarn.lock")))
+  if (fs27.existsSync(path37.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs26.existsSync(path36.join(projectDir, "package-lock.json")))
+  if (fs27.existsSync(path37.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path36.join(projectDir, "package.json");
-  if (fs26.existsSync(pkgPath)) {
+  const pkgPath = path37.join(projectDir, "package.json");
+  if (fs27.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs27.readFileSync(pkgPath, "utf8"));
       const scripts = pkg.scripts;
       if (scripts?.typecheck) {
         const pm = detectPackageManager(projectDir);
@@ -54786,8 +55505,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs26.existsSync(path36.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs26.existsSync(path36.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs27.existsSync(path37.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs27.existsSync(path37.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -54795,17 +55514,17 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs26.existsSync(path36.join(projectDir, "go.mod"))) {
+  if (fs27.existsSync(path37.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs26.existsSync(path36.join(projectDir, "Cargo.toml"))) {
+  if (fs27.existsSync(path37.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs26.existsSync(path36.join(projectDir, "pyproject.toml")) || fs26.existsSync(path36.join(projectDir, "requirements.txt")) || fs26.existsSync(path36.join(projectDir, "setup.py"))) {
+  if (fs27.existsSync(path37.join(projectDir, "pyproject.toml")) || fs27.existsSync(path37.join(projectDir, "requirements.txt")) || fs27.existsSync(path37.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
-    const entries = fs26.readdirSync(projectDir);
+    const entries = fs27.readdirSync(projectDir);
     if (entries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       return {
         command: ["dotnet", "build", "--no-restore"],
@@ -54874,9 +55593,10 @@ ${errorSummary}`);
 }
 
 // src/hooks/knowledge-reader.ts
-import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import * as path37 from "path";
+init_knowledge_store();
+import { existsSync as existsSync23 } from "fs";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import * as path38 from "path";
 var JACCARD_THRESHOLD = 0.6;
 var HIVE_TIER_BOOST = 0.05;
 var SAME_PROJECT_PENALTY = -0.05;
@@ -54924,16 +55644,16 @@ function inferCategoriesFromPhase(phaseDescription) {
   return ["process", "tooling"];
 }
 async function recordLessonsShown(directory, lessonIds, currentPhase) {
-  const shownFile = path37.join(directory, ".swarm", ".knowledge-shown.json");
+  const shownFile = path38.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     let shownData = {};
-    if (existsSync22(shownFile)) {
-      const content = await readFile5(shownFile, "utf-8");
+    if (existsSync23(shownFile)) {
+      const content = await readFile6(shownFile, "utf-8");
       shownData = JSON.parse(content);
     }
     shownData[currentPhase] = lessonIds;
-    await mkdir5(path37.dirname(shownFile), { recursive: true });
-    await writeFile4(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+    await mkdir6(path38.dirname(shownFile), { recursive: true });
+    await writeFile5(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
     console.warn("[swarm] Knowledge: failed to record shown lessons");
   }
@@ -55029,12 +55749,12 @@ async function readMergedKnowledge(directory, config3, context) {
   return topN;
 }
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
-  const shownFile = path37.join(directory, ".swarm", ".knowledge-shown.json");
+  const shownFile = path38.join(directory, ".swarm", ".knowledge-shown.json");
   try {
-    if (!existsSync22(shownFile)) {
+    if (!existsSync23(shownFile)) {
       return;
     }
-    const content = await readFile5(shownFile, "utf-8");
+    const content = await readFile6(shownFile, "utf-8");
     const shownData = JSON.parse(content);
     const shownIds = shownData[phaseInfo];
     if (!shownIds || shownIds.length === 0) {
@@ -55062,7 +55782,7 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
     const remainingIds = shownIds.filter((id) => !foundInSwarm.has(id));
     if (remainingIds.length === 0) {
       delete shownData[phaseInfo];
-      await writeFile4(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+      await writeFile5(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
       return;
     }
     const hivePath = resolveHiveKnowledgePath();
@@ -55083,13 +55803,14 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
       await rewriteKnowledge(hivePath, hiveEntries);
     }
     delete shownData[phaseInfo];
-    await writeFile4(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+    await writeFile5(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
     console.warn("[swarm] Knowledge: failed to update retrieval outcomes");
   }
 }
 
 // src/hooks/knowledge-curator.ts
+init_knowledge_store();
 init_utils2();
 var seenRetroSections = new Map;
 function pruneSeenRetroSections() {
@@ -55416,20 +56137,6 @@ init_manager2();
 
 // src/services/run-memory.ts
 init_utils2();
-function validateDirectory2(directory) {
-  if (!directory || directory.trim() === "") {
-    throw new Error("Invalid directory: empty");
-  }
-  if (/\.\.[/\\]/.test(directory)) {
-    throw new Error("Invalid directory: path traversal detected");
-  }
-  if (directory.startsWith("/") || directory.startsWith("\\")) {
-    throw new Error("Invalid directory: absolute path");
-  }
-  if (/^[A-Za-z]:[\\/]/.test(directory)) {
-    throw new Error("Invalid directory: Windows absolute path");
-  }
-}
 var RUN_MEMORY_FILENAME = "run-memory.jsonl";
 var MAX_SUMMARY_TOKENS = 500;
 function groupByTaskId(entries) {
@@ -55461,7 +56168,7 @@ function summarizeTask(taskId, entries) {
   }
 }
 async function getRunMemorySummary(directory) {
-  validateDirectory2(directory);
+  validateDirectory(directory);
   const content = await readSwarmFileAsync(directory, RUN_MEMORY_FILENAME);
   if (!content) {
     return null;
@@ -55509,7 +56216,7 @@ Use this data to avoid repeating known failure patterns.`;
     const availableContentTokens = MAX_SUMMARY_TOKENS - prefixTokens - suffixTokens;
     if (availableContentTokens > 0) {
       const maxContentChars = Math.floor(availableContentTokens / 0.33);
-      summaryText = summaryText.slice(-maxContentChars);
+      summaryText = summaryText.slice(0, maxContentChars);
     } else {
       summaryText = "";
     }
@@ -55519,6 +56226,7 @@ Use this data to avoid repeating known failure patterns.`;
 
 // src/hooks/knowledge-injector.ts
 init_curator_drift();
+init_knowledge_store();
 init_utils2();
 function formatStars(confidence) {
   if (confidence >= 0.9)
@@ -55664,7 +56372,7 @@ ${injectionText}`;
 // src/hooks/scope-guard.ts
 init_constants();
 init_schema();
-import * as path39 from "path";
+import * as path40 from "path";
 var WRITE_TOOLS = new Set([
   "write",
   "edit",
@@ -55726,13 +56434,13 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
 }
 function isFileInScope(filePath, scopeEntries, directory) {
   const dir = directory ?? process.cwd();
-  const resolvedFile = path39.resolve(dir, filePath);
+  const resolvedFile = path40.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path39.resolve(dir, scope);
+    const resolvedScope = path40.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path39.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path39.isAbsolute(rel);
+    const rel = path40.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path40.isAbsolute(rel);
   });
 }
 
@@ -55781,8 +56489,8 @@ function createSelfReviewHook(config3, injectAdvisory) {
 }
 
 // src/hooks/slop-detector.ts
-import * as fs28 from "fs";
-import * as path40 from "path";
+import * as fs29 from "fs";
+import * as path41 from "path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -55827,12 +56535,12 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
 function walkFiles(dir, exts, deadline) {
   const results = [];
   try {
-    for (const entry of fs28.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs29.readdirSync(dir, { withFileTypes: true })) {
       if (deadline !== undefined && Date.now() > deadline)
         break;
       if (entry.isSymbolicLink())
         continue;
-      const full = path40.join(dir, entry.name);
+      const full = path41.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -55847,7 +56555,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs28.existsSync(path40.join(projectDir, "package.json"));
+  const hasPackageJson = fs29.existsSync(path41.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -55870,7 +56578,7 @@ function checkDeadExports(content, projectDir, startTime) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = fs28.readFileSync(file3, "utf-8");
+          const text = fs29.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -56003,7 +56711,7 @@ Review before proceeding.`;
 
 // src/hooks/steering-consumed.ts
 init_utils2();
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -56012,7 +56720,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs29.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs30.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -56057,6 +56765,19 @@ init_config_doctor();
 
 // src/session/snapshot-reader.ts
 init_utils2();
+var TRANSIENT_SESSION_FIELDS = [
+  { name: "revisionLimitHit", resetValue: false },
+  { name: "coderRevisions", resetValue: 0 },
+  { name: "selfFixAttempted", resetValue: false },
+  { name: "lastGateFailure", resetValue: null },
+  { name: "architectWriteCount", resetValue: 0 },
+  { name: "selfCodingWarnedAtCount", resetValue: 0 },
+  { name: "pendingAdvisoryMessages", resetValue: [] },
+  { name: "model_fallback_index", resetValue: 0 },
+  { name: "modelFallbackExhausted", resetValue: false },
+  { name: "scopeViolationDetected", resetValue: false },
+  { name: "delegationActive", resetValue: false }
+];
 var VALID_TASK_WORKFLOW_STATES = [
   "idle",
   "coder_delegated",
@@ -56203,17 +56924,9 @@ async function rehydrateState(snapshot) {
           window2.warningReason = "";
         }
       }
-      session.revisionLimitHit = false;
-      session.coderRevisions = 0;
-      session.selfFixAttempted = false;
-      session.lastGateFailure = null;
-      session.architectWriteCount = 0;
-      session.selfCodingWarnedAtCount = 0;
-      session.pendingAdvisoryMessages = [];
-      session.model_fallback_index = 0;
-      session.modelFallbackExhausted = false;
-      session.scopeViolationDetected = false;
-      session.delegationActive = false;
+      for (const field of TRANSIENT_SESSION_FIELDS) {
+        session[field.name] = field.resetValue;
+      }
       swarmState.agentSessions.set(sessionId, session);
     }
   }
@@ -56409,8 +57122,8 @@ var build_check = createSwarmTool({
 init_dist();
 init_manager();
 init_create_tool();
-import * as fs30 from "fs";
-import * as path41 from "path";
+import * as fs31 from "fs";
+import * as path42 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
 var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
 function isValidTaskId3(taskId) {
@@ -56427,18 +57140,18 @@ function isValidTaskId3(taskId) {
   return TASK_ID_PATTERN2.test(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path41.resolve(workspaceRoot);
-  const swarmPath = path41.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path41.resolve(filePath);
+  const normalizedWorkspace = path42.resolve(workspaceRoot);
+  const swarmPath = path42.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path42.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs30.existsSync(evidencePath)) {
+  if (!fs31.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs30.readFileSync(evidencePath, "utf-8");
+    content = fs31.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -56492,7 +57205,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path41.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path42.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -56584,8 +57297,8 @@ init_checkpoint();
 // src/tools/completion-verify.ts
 init_dist();
 init_utils2();
-import * as fs31 from "fs";
-import * as path42 from "path";
+import * as fs32 from "fs";
+import * as path43 from "path";
 init_create_tool();
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
@@ -56667,7 +57380,7 @@ async function executeCompletionVerify(args2, directory) {
   let plan;
   try {
     const planPath = validateSwarmPath(directory, "plan.json");
-    const planRaw = fs31.readFileSync(planPath, "utf-8");
+    const planRaw = fs32.readFileSync(planPath, "utf-8");
     plan = JSON.parse(planRaw);
   } catch {
     const result2 = {
@@ -56697,7 +57410,7 @@ async function executeCompletionVerify(args2, directory) {
     return JSON.stringify(result2, null, 2);
   }
   let tasksChecked = 0;
-  let tasksSkipped = 0;
+  const tasksSkipped = 0;
   let tasksBlocked = 0;
   const blockedTasks = [];
   for (const task of targetPhase.tasks) {
@@ -56708,20 +57421,33 @@ async function executeCompletionVerify(args2, directory) {
     const fileTargets = parseFilePaths(task.description, task.files_touched);
     const identifiers = parseIdentifiers(task.description);
     if (fileTargets.length === 0) {
-      tasksSkipped++;
+      blockedTasks.push({
+        task_id: task.id,
+        identifier: "",
+        file_path: "",
+        reason: "No file targets \u2014 cannot verify completion without files_touched"
+      });
+      tasksBlocked++;
       continue;
     }
     if (identifiers.length === 0) {
-      tasksSkipped++;
+      blockedTasks.push({
+        task_id: task.id,
+        identifier: "",
+        file_path: "",
+        reason: "No identifiers \u2014 cannot verify completion without identifiers"
+      });
+      tasksBlocked++;
       continue;
     }
-    let foundCount = 0;
+    const foundIdentifiers = new Set;
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
-      const resolvedPath = path42.resolve(directory, filePath);
+      const normalizedPath = filePath.replace(/\\/g, "/");
+      const resolvedPath = path43.resolve(directory, normalizedPath);
       let fileContent;
       try {
-        fileContent = fs31.readFileSync(resolvedPath, "utf-8");
+        fileContent = fs32.readFileSync(resolvedPath, "utf-8");
       } catch {
         blockedTasks.push({
           task_id: task.id,
@@ -56734,11 +57460,11 @@ async function executeCompletionVerify(args2, directory) {
       }
       for (const identifier of identifiers) {
         if (fileContent.includes(identifier)) {
-          foundCount++;
-          break;
+          foundIdentifiers.add(identifier);
         }
       }
     }
+    const foundCount = foundIdentifiers.size;
     if (hasFileReadFailure || foundCount === 0) {
       if (!hasFileReadFailure) {
         blockedTasks.push({
@@ -56763,9 +57489,9 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path42.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path42.join(evidenceDir, "completion-verify.json");
-    fs31.mkdirSync(evidenceDir, { recursive: true });
+    const evidenceDir = path43.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path43.join(evidenceDir, "completion-verify.json");
+    fs32.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
       task_id: "completion-verify",
@@ -56786,7 +57512,7 @@ async function executeCompletionVerify(args2, directory) {
         }
       ]
     };
-    fs31.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
+    fs32.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
   } catch {}
   return JSON.stringify(result, null, 2);
 }
@@ -56826,16 +57552,13 @@ var completion_verify = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_dist();
 init_create_tool();
-import * as fs32 from "fs";
-import * as path43 from "path";
+import * as fs33 from "fs";
+import * as path44 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
 var DEFAULT_TOP_N = 20;
 var DEFAULT_EXTENSIONS = "ts,tsx,js,jsx,py,rs,ps1";
 var SHELL_METACHAR_REGEX = /[;&|%$`\\]/;
-function containsControlChars3(str) {
-  return /[\0\t\r\n]/.test(str);
-}
 function validateDays(days) {
   if (typeof days === "undefined") {
     return { valid: true, value: DEFAULT_DAYS, error: null };
@@ -56867,7 +57590,7 @@ function validateExtensions(extensions) {
   if (typeof extensions !== "string") {
     return { valid: false, value: "", error: "extensions must be a string" };
   }
-  if (containsControlChars3(extensions)) {
+  if (containsControlChars(extensions)) {
     return {
       valid: false,
       value: "",
@@ -56956,11 +57679,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs32.statSync(filePath);
+    const stat2 = fs33.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs32.readFileSync(filePath, "utf-8");
+    const content = fs33.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -56971,7 +57694,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path43.extname(file3).toLowerCase();
+    const ext = path44.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -56981,8 +57704,8 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs32.existsSync(fullPath)) {
-      fullPath = path43.join(cwd, file3);
+    if (!fs33.existsSync(fullPath)) {
+      fullPath = path44.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
     if (complexity !== null) {
@@ -57190,8 +57913,8 @@ var curator_analyze = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs33 from "fs";
-import * as path44 from "path";
+import * as fs34 from "fs";
+import * as path45 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
   const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
@@ -57270,8 +57993,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path44.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path44.sep);
+    normalizedDir = path45.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path45.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -57281,11 +58004,11 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path44.resolve(normalizedDir);
+    const resolvedDir = path45.resolve(normalizedDir);
     try {
-      const realPath = fs33.realpathSync(resolvedDir);
-      const planPath2 = path44.join(realPath, ".swarm", "plan.json");
-      if (!fs33.existsSync(planPath2)) {
+      const realPath = fs34.realpathSync(resolvedDir);
+      const planPath2 = path45.join(realPath, ".swarm", "plan.json");
+      if (!fs34.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -57308,8 +58031,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     console.warn("[declare-scope] fallbackDir is undefined, falling back to process.cwd()");
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path44.resolve(directory, ".swarm", "plan.json");
-  if (!fs33.existsSync(planPath)) {
+  const planPath = path45.resolve(directory, ".swarm", "plan.json");
+  if (!fs34.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -57318,7 +58041,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs33.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs34.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -57404,6 +58127,11 @@ var languageDefinitions = [
     id: "rust",
     extensions: [".rs"],
     commentNodes: ["line_comment", "block_comment"]
+  },
+  {
+    id: "php",
+    extensions: [".php", ".phtml"],
+    commentNodes: ["comment"]
   }
 ];
 var extensionMap = new Map;
@@ -57467,10 +58195,16 @@ async function computeASTDiff(filePath, oldContent, newContent) {
     };
   }
   try {
+    let timeoutId;
     const parser = await Promise.race([
       loadGrammar(language.id),
-      new Promise((_, reject) => setTimeout(() => reject(new Error("AST_TIMEOUT")), AST_TIMEOUT_MS))
-    ]);
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("AST_TIMEOUT")), AST_TIMEOUT_MS);
+      })
+    ]).finally(() => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+    });
     const oldTree = parser.parse(oldContent);
     const newTree = parser.parse(newContent);
     if (!oldTree || !newTree) {
@@ -57643,20 +58377,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path45 of paths) {
-    if (!path45 || path45.length === 0) {
+  for (const path46 of paths) {
+    if (!path46 || path46.length === 0) {
       return "empty path not allowed";
     }
-    if (path45.length > MAX_PATH_LENGTH) {
+    if (path46.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path45)) {
+    if (SHELL_METACHARACTERS2.test(path46)) {
       return "path contains shell metacharacters";
     }
-    if (path45.startsWith("-")) {
+    if (path46.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path45)) {
+    if (CONTROL_CHAR_PATTERN2.test(path46)) {
       return "path contains control characters";
     }
   }
@@ -57737,8 +58471,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path45 = parts2[2];
-          files.push({ path: path45, additions, deletions });
+          const path46 = parts2[2];
+          files.push({ path: path46, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -57833,391 +58567,10 @@ var diff = createSwarmTool({
     }
   }
 });
-// src/tools/doc-scan.ts
-init_dist();
-init_schema();
-import * as crypto4 from "crypto";
-import * as fs34 from "fs";
-import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import * as path45 from "path";
-init_create_tool();
-var SKIP_DIRECTORIES2 = new Set([
-  "node_modules",
-  ".git",
-  ".swarm",
-  "dist",
-  "build",
-  ".next",
-  "vendor"
-]);
-var SKIP_PATTERNS = [/\.test\./, /\.spec\./, /\.d\.ts$/];
-var MAX_SUMMARY_LENGTH = 200;
-var MAX_INDEXED_FILES = 100;
-var READ_LINES_LIMIT = 30;
-var MIN_LESSON_LENGTH = 15;
-var MAX_CONSTRAINTS_PER_DOC = 5;
-var MAX_CONSTRAINT_LENGTH = 200;
-var RELEVANCE_THRESHOLD = 0.1;
-var DEDUP_THRESHOLD = 0.6;
-function normalizeSeparators(filePath) {
-  return filePath.replace(/\\/g, "/");
-}
-function matchesDocPattern(filePath, patterns) {
-  const normalizedPath = normalizeSeparators(filePath);
-  const basename5 = path45.basename(filePath);
-  for (const pattern of patterns) {
-    if (!pattern.includes("/") && !pattern.includes("\\")) {
-      if (basename5 === pattern) {
-        return true;
-      }
-      continue;
-    }
-    if (pattern.startsWith("**/")) {
-      const filenamePattern = pattern.slice(3);
-      if (basename5 === filenamePattern) {
-        return true;
-      }
-      continue;
-    }
-    const patternNormalized = normalizeSeparators(pattern);
-    const dirPrefix = patternNormalized.replace(/\/\*\*.*$/, "").replace(/\/\*.*$/, "");
-    if (normalizedPath.startsWith(`${dirPrefix}/`) || normalizedPath === dirPrefix) {
-      return true;
-    }
-  }
-  return false;
-}
-function extractTitleAndSummary(content, filename) {
-  const lines = content.split(`
-`);
-  let title = filename;
-  let summary = "";
-  let foundTitle = false;
-  const potentialSummaryLines = [];
-  for (let i2 = 0;i2 < lines.length && i2 < READ_LINES_LIMIT; i2++) {
-    const line = lines[i2].trim();
-    if (!foundTitle && line.startsWith("# ")) {
-      title = line.slice(2).trim();
-      foundTitle = true;
-      continue;
-    }
-    if (line && !line.startsWith("#")) {
-      potentialSummaryLines.push(line);
-    }
-  }
-  for (const line of potentialSummaryLines) {
-    summary += (summary ? " " : "") + line;
-    if (summary.length >= MAX_SUMMARY_LENGTH) {
-      break;
-    }
-  }
-  if (summary.length > MAX_SUMMARY_LENGTH) {
-    summary = `${summary.slice(0, MAX_SUMMARY_LENGTH - 3)}...`;
-  }
-  return { title, summary };
-}
-function stripMarkdown(text) {
-  return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s*[-*\u2022]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "").trim();
-}
-async function scanDocIndex(directory) {
-  const manifestPath = path45.join(directory, ".swarm", "doc-manifest.json");
-  const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
-  const extraPatterns = [
-    "ARCHITECTURE.md",
-    "CLAUDE.md",
-    "AGENTS.md",
-    ".github/*.md",
-    "doc/**/*.md"
-  ];
-  const allPatterns = [...defaultPatterns, ...extraPatterns];
-  try {
-    const manifestContent = await readFile6(manifestPath, "utf-8");
-    const existingManifest = JSON.parse(manifestContent);
-    if (existingManifest.schema_version === 1 && existingManifest.files) {
-      let cacheValid = true;
-      for (const file3 of existingManifest.files) {
-        try {
-          const fullPath = path45.join(directory, file3.path);
-          const stat2 = fs34.statSync(fullPath);
-          if (stat2.mtimeMs > new Date(existingManifest.scanned_at).getTime()) {
-            cacheValid = false;
-            break;
-          }
-        } catch {
-          cacheValid = false;
-          break;
-        }
-      }
-      if (cacheValid) {
-        return { manifest: existingManifest, cached: true };
-      }
-    }
-  } catch {}
-  const discoveredFiles = [];
-  let rawEntries;
-  try {
-    rawEntries = fs34.readdirSync(directory, { recursive: true });
-  } catch {
-    const manifest2 = {
-      schema_version: 1,
-      scanned_at: new Date().toISOString(),
-      files: []
-    };
-    return { manifest: manifest2, cached: false };
-  }
-  const entries = rawEntries.filter((e) => typeof e === "string");
-  for (const entry of entries) {
-    const fullPath = path45.join(directory, entry);
-    let stat2;
-    try {
-      stat2 = fs34.statSync(fullPath);
-    } catch {
-      continue;
-    }
-    if (!stat2.isFile())
-      continue;
-    const pathParts = normalizeSeparators(entry).split("/");
-    let skipThisFile = false;
-    for (const part of pathParts) {
-      if (SKIP_DIRECTORIES2.has(part)) {
-        skipThisFile = true;
-        break;
-      }
-    }
-    if (skipThisFile)
-      continue;
-    for (const pattern of SKIP_PATTERNS) {
-      if (pattern.test(entry)) {
-        skipThisFile = true;
-        break;
-      }
-    }
-    if (skipThisFile)
-      continue;
-    if (!matchesDocPattern(entry, allPatterns)) {
-      continue;
-    }
-    let content;
-    try {
-      content = fs34.readFileSync(fullPath, "utf-8");
-    } catch {
-      continue;
-    }
-    const { title, summary } = extractTitleAndSummary(content, path45.basename(entry));
-    const lineCount = content.split(`
-`).length;
-    discoveredFiles.push({
-      path: entry,
-      title,
-      summary,
-      lines: lineCount,
-      mtime: stat2.mtimeMs
-    });
-  }
-  discoveredFiles.sort((a, b) => a.path.toLowerCase().localeCompare(b.path.toLowerCase()));
-  let truncated = false;
-  if (discoveredFiles.length > MAX_INDEXED_FILES) {
-    discoveredFiles.splice(MAX_INDEXED_FILES);
-    truncated = true;
-  }
-  if (truncated && discoveredFiles.length > 0) {
-    discoveredFiles[0].summary = `[Warning: ${MAX_INDEXED_FILES}+ docs found, listing first ${MAX_INDEXED_FILES}] ` + discoveredFiles[0].summary;
-  }
-  const manifest = {
-    schema_version: 1,
-    scanned_at: new Date().toISOString(),
-    files: discoveredFiles
-  };
-  try {
-    await mkdir6(path45.dirname(manifestPath), { recursive: true });
-    await writeFile5(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
-  } catch {}
-  return { manifest, cached: false };
-}
-var CONSTRAINT_PATTERNS = [
-  /\bMUST\b/,
-  /\bMUST NOT\b/,
-  /\bSHOULD\b/,
-  /\bSHOULD NOT\b/,
-  /\bDO NOT\b/,
-  /\bALWAYS\b/,
-  /\bNEVER\b/,
-  /\bREQUIRED\b/
-];
-var ACTION_WORDS = /\b(must|should|don't|avoid|ensure|use|follow)\b/i;
-function isConstraintLine(line) {
-  const upperLine = line.toUpperCase();
-  for (const pattern of CONSTRAINT_PATTERNS) {
-    if (pattern.test(upperLine)) {
-      return true;
-    }
-  }
-  if (/^\s*[-*\u2022]/.test(line) && ACTION_WORDS.test(line)) {
-    return true;
-  }
-  return false;
-}
-function extractConstraintsFromContent(content) {
-  const lines = content.split(`
-`);
-  const constraints = [];
-  for (const line of lines) {
-    if (constraints.length >= MAX_CONSTRAINTS_PER_DOC) {
-      break;
-    }
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    if (isConstraintLine(trimmed)) {
-      const cleaned = stripMarkdown(trimmed);
-      const len = cleaned.length;
-      if (len >= MIN_LESSON_LENGTH && len <= MAX_CONSTRAINT_LENGTH) {
-        constraints.push(cleaned);
-      }
-    }
-  }
-  return constraints;
-}
-async function extractDocConstraints(directory, taskFiles, taskDescription) {
-  const manifestPath = path45.join(directory, ".swarm", "doc-manifest.json");
-  let manifest;
-  try {
-    const content = await readFile6(manifestPath, "utf-8");
-    manifest = JSON.parse(content);
-  } catch {
-    const result = await scanDocIndex(directory);
-    manifest = result.manifest;
-  }
-  const knowledgePath = resolveSwarmKnowledgePath(directory);
-  const existingEntries = await readKnowledge(knowledgePath);
-  const taskContext = [...taskFiles, taskDescription].join(" ");
-  const taskBigrams = wordBigrams(normalize2(taskContext));
-  let extractedCount = 0;
-  let skippedCount = 0;
-  const details = [];
-  for (const docFile of manifest.files) {
-    const docContext = `${docFile.path} ${docFile.title} ${docFile.summary}`;
-    const docBigrams = wordBigrams(normalize2(docContext));
-    const score = jaccardBigram(taskBigrams, docBigrams);
-    if (score <= RELEVANCE_THRESHOLD) {
-      skippedCount++;
-      continue;
-    }
-    let fullContent;
-    try {
-      fullContent = await readFile6(path45.join(directory, docFile.path), "utf-8");
-    } catch {
-      skippedCount++;
-      continue;
-    }
-    const constraints = extractConstraintsFromContent(fullContent);
-    if (constraints.length === 0) {
-      skippedCount++;
-      continue;
-    }
-    const docDetails = {
-      path: docFile.path,
-      score,
-      constraints: []
-    };
-    for (const constraint of constraints) {
-      const duplicate = findNearDuplicate(constraint, existingEntries, DEDUP_THRESHOLD);
-      if (!duplicate) {
-        const entry = {
-          id: crypto4.randomUUID(),
-          tier: "swarm",
-          lesson: constraint,
-          category: "architecture",
-          tags: ["doc-scan", path45.basename(docFile.path)],
-          scope: "global",
-          confidence: 0.5,
-          status: "candidate",
-          confirmed_by: [],
-          project_name: "",
-          retrieval_outcomes: {
-            applied_count: 0,
-            succeeded_after_count: 0,
-            failed_after_count: 0
-          },
-          schema_version: 1,
-          created_at: new Date().toISOString(),
-          updated_at: new Date().toISOString(),
-          auto_generated: true,
-          hive_eligible: false
-        };
-        await appendKnowledge(knowledgePath, entry);
-        existingEntries.push(entry);
-        extractedCount++;
-        docDetails.constraints.push(constraint);
-      }
-    }
-    if (docDetails.constraints.length > 0) {
-      details.push(docDetails);
-    } else {
-      skippedCount++;
-    }
-  }
-  return { extracted: extractedCount, skipped: skippedCount, details };
-}
-var doc_scan = createSwarmTool({
-  description: "Scan project documentation files and build an index manifest. Caches results in .swarm/doc-manifest.json for fast subsequent scans.",
-  args: {
-    force: tool.schema.boolean().optional().describe("Force re-scan even if cache is valid")
-  },
-  execute: async (args2, directory) => {
-    let force = false;
-    try {
-      if (args2 && typeof args2 === "object") {
-        const obj = args2;
-        if (obj.force === true)
-          force = true;
-      }
-    } catch {}
-    if (force) {
-      const manifestPath = path45.join(directory, ".swarm", "doc-manifest.json");
-      try {
-        fs34.unlinkSync(manifestPath);
-      } catch {}
-    }
-    const { manifest, cached: cached3 } = await scanDocIndex(directory);
-    return JSON.stringify({
-      success: true,
-      files_count: manifest.files.length,
-      cached: cached3,
-      manifest
-    }, null, 2);
-  }
-});
-var doc_extract = createSwarmTool({
-  description: "Extract actionable constraints from project documentation relevant to the current task. Scans docs via doc-manifest, scores relevance via Jaccard bigram similarity, and stores non-duplicate constraints in .swarm/knowledge.jsonl.",
-  args: {
-    task_files: tool.schema.array(tool.schema.string()).describe("List of file paths involved in the current task"),
-    task_description: tool.schema.string().describe("Description of the current task")
-  },
-  execute: async (args2, directory) => {
-    let taskFiles = [];
-    let taskDescription = "";
-    try {
-      if (args2 && typeof args2 === "object") {
-        const obj = args2;
-        if (Array.isArray(obj.task_files)) {
-          taskFiles = obj.task_files.filter((f) => typeof f === "string");
-        }
-        if (typeof obj.task_description === "string") {
-          taskDescription = obj.task_description;
-        }
-      }
-    } catch {}
-    if (taskFiles.length === 0 && !taskDescription) {
-      return JSON.stringify({
-        success: false,
-        error: "task_files or task_description is required"
-      });
-    }
-    const result = await extractDocConstraints(directory, taskFiles, taskDescription);
-    return JSON.stringify({ success: true, ...result }, null, 2);
-  }
-});
+
+// src/tools/index.ts
+init_doc_scan();
+
 // src/tools/domain-detector.ts
 init_tool();
 var DOMAIN_PATTERNS = {
@@ -58416,11 +58769,8 @@ var LEGACY_EVIDENCE_ALIAS_MAP = {
 function normalizeEvidenceType(type) {
   return LEGACY_EVIDENCE_ALIAS_MAP[type.toLowerCase()] || type;
 }
-function containsControlChars4(str) {
-  return /[\0\t\r\n]/.test(str);
-}
 function validateRequiredTypes(input) {
-  if (containsControlChars4(input)) {
+  if (containsControlChars(input)) {
     return "required_types contains control characters";
   }
   if (SHELL_METACHAR_REGEX2.test(input)) {
@@ -58859,12 +59209,6 @@ var BINARY_SIGNATURES2 = [
 var BINARY_PREFIX_BYTES2 = 4;
 var BINARY_NULL_CHECK_BYTES2 = 8192;
 var BINARY_NULL_THRESHOLD2 = 0.1;
-function containsPathTraversal3(str) {
-  return /\.\.[/\\]/.test(str);
-}
-function containsControlChars5(str) {
-  return /[\0\t\r\n]/.test(str);
-}
 function validateFileInput(file3) {
   if (!file3 || file3.length === 0) {
     return "file is required";
@@ -58872,10 +59216,10 @@ function validateFileInput(file3) {
   if (file3.length > MAX_FILE_PATH_LENGTH2) {
     return `file exceeds maximum length of ${MAX_FILE_PATH_LENGTH2}`;
   }
-  if (containsControlChars5(file3)) {
+  if (containsControlChars(file3)) {
     return "file contains control characters";
   }
-  if (containsPathTraversal3(file3)) {
+  if (containsPathTraversal(file3)) {
     return "file contains path traversal";
   }
   return null;
@@ -58887,10 +59231,10 @@ function validateSymbolInput(symbol3) {
   if (symbol3.length > MAX_SYMBOL_LENGTH) {
     return `symbol exceeds maximum length of ${MAX_SYMBOL_LENGTH}`;
   }
-  if (containsControlChars5(symbol3)) {
+  if (containsControlChars(symbol3)) {
     return "symbol contains control characters";
   }
-  if (containsPathTraversal3(symbol3)) {
+  if (containsPathTraversal(symbol3)) {
     return "symbol contains path traversal";
   }
   return null;
@@ -59047,7 +59391,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
   return files;
 }
 var imports = createSwarmTool({
-  description: "Find all consumers that import from a given file. Returns JSON with file path, line numbers, and import metadata for each consumer. Useful for understanding dependency relationships.",
+  description: "Find all reverse dependencies (consumers) that import from a given file. Returns JSON with file path, line numbers, and import metadata for each consumer. Use this to understand who depends on a module before refactoring.",
   args: {
     file: tool.schema.string().describe('Source file path to find importers for (e.g., "./src/utils.ts")'),
     symbol: tool.schema.string().optional().describe('Optional specific symbol to filter imports (e.g., "MyClass")')
@@ -59202,6 +59546,9 @@ var imports = createSwarmTool({
 });
 // src/tools/knowledge-add.ts
 init_dist();
+init_config();
+init_knowledge_store();
+import { randomUUID as randomUUID4 } from "crypto";
 init_manager2();
 init_create_tool();
 var VALID_CATEGORIES2 = [
@@ -59276,7 +59623,7 @@ var knowledgeAdd = createSwarmTool({
       project_name = plan?.title ?? "";
     } catch {}
     const entry = {
-      id: crypto.randomUUID(),
+      id: randomUUID4(),
       tier: "swarm",
       lesson,
       category,
@@ -59297,6 +59644,22 @@ var knowledgeAdd = createSwarmTool({
       auto_generated: true,
       hive_eligible: false
     };
+    try {
+      const { config: config3 } = loadPluginConfigWithMeta(directory);
+      if (config3.knowledge?.validation_enabled !== false) {
+        const validation = validateLesson(lesson, [], {
+          category,
+          scope,
+          confidence: 0.5
+        });
+        if (!validation.valid) {
+          return JSON.stringify({
+            success: false,
+            error: `Validation failed: ${validation.reason}`
+          });
+        }
+      }
+    } catch {}
     try {
       await appendKnowledge(resolveSwarmKnowledgePath(directory), entry);
     } catch (err2) {
@@ -59315,8 +59678,10 @@ var knowledgeAdd = createSwarmTool({
 });
 // src/tools/knowledge-query.ts
 init_dist();
-import { existsSync as existsSync30 } from "fs";
+init_config();
+init_knowledge_store();
 init_create_tool();
+import { existsSync as existsSync31 } from "fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -59385,19 +59750,19 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync30(swarmPath)) {
+  if (!existsSync31(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync30(hivePath)) {
+  if (!existsSync31(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
 }
-function filterSwarmEntries(entries, filters) {
+function filterSwarmEntries(entries, filters, scopeFilter) {
   return entries.filter((entry) => {
     if (filters.status && entry.status !== filters.status) {
       return false;
@@ -59408,6 +59773,12 @@ function filterSwarmEntries(entries, filters) {
     if (filters.minScore !== undefined && entry.confidence < filters.minScore) {
       return false;
     }
+    if (scopeFilter && scopeFilter.length > 0) {
+      const entryScope = entry.scope ?? "global";
+      if (!scopeFilter.some((pattern) => entryScope === pattern)) {
+        return false;
+      }
+    }
     return true;
   });
 }
@@ -59492,9 +59863,14 @@ var knowledge_query = createSwarmTool({
       minScore: minScore ?? undefined
     };
     const results = [];
+    let scopeFilter;
+    try {
+      const { config: config3 } = loadPluginConfigWithMeta(directory);
+      scopeFilter = config3.knowledge?.scope_filter;
+    } catch {}
     if (tier === "swarm" || tier === "all") {
       const swarmEntries = await readSwarmKnowledge(directory);
-      const filtered = filterSwarmEntries(swarmEntries, filters);
+      const filtered = filterSwarmEntries(swarmEntries, filters, scopeFilter);
       for (const entry of filtered) {
         results.push({ entry, tier: "swarm" });
       }
@@ -59544,6 +59920,7 @@ var knowledge_query = createSwarmTool({
 });
 // src/tools/knowledge-recall.ts
 init_dist();
+init_knowledge_store();
 init_create_tool();
 var knowledgeRecall = createSwarmTool({
   description: "Search the knowledge base for relevant past decisions, patterns, and lessons learned. Returns ranked results by semantic similarity.",
@@ -59627,6 +60004,7 @@ var knowledgeRecall = createSwarmTool({
 });
 // src/tools/knowledge-remove.ts
 init_dist();
+init_knowledge_store();
 init_create_tool();
 var knowledgeRemove = createSwarmTool({
   description: "Delete an outdated knowledge entry by ID. Double-deletion is idempotent \u2014 removing a non-existent entry returns a clear message without error.",
@@ -60022,7 +60400,14 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
       const projectName = path49.basename(dir);
-      await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
+      const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
+      if (curationResult) {
+        const sessionState = swarmState.agentSessions.get(sessionID);
+        if (sessionState) {
+          sessionState.pendingAdvisoryMessages ??= [];
+          sessionState.pendingAdvisoryMessages.push(`[CURATOR] Knowledge curation: ${curationResult.stored} stored, ${curationResult.skipped} skipped, ${curationResult.rejected} rejected.`);
+        }
+      }
     } catch (error93) {
       safeWarn("[phase_complete] Failed to curate lessons from retrospective:", error93);
     }
@@ -60056,7 +60441,17 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   } catch (curatorError) {
     safeWarn("[phase_complete] Curator pipeline error (non-blocking):", curatorError);
   }
-  const effectiveRequired = [...phaseCompleteConfig.required_agents];
+  let phaseRequiredAgents;
+  try {
+    const planPath = validateSwarmPath(dir, "plan.json");
+    const planRaw = fs38.readFileSync(planPath, "utf-8");
+    const plan = JSON.parse(planRaw);
+    const phaseObj = plan.phases.find((p) => p.id === phase);
+    phaseRequiredAgents = phaseObj?.required_agents;
+  } catch {}
+  const effectiveRequired = [
+    ...phaseRequiredAgents ?? phaseCompleteConfig.required_agents
+  ];
   if (phaseCompleteConfig.require_docs && !effectiveRequired.includes("docs")) {
     effectiveRequired.push("docs");
   }
@@ -62521,7 +62916,7 @@ var javascriptRules = [
     languages: ["javascript", "typescript"],
     description: "Potential command injection via child_process.exec() with unsanitized input",
     remediation: "Never pass user input directly to exec(). Use execFile() with arguments array or sanitize input thoroughly.",
-    pattern: /exec\s*\(\s*[`'"]/,
+    pattern: /exec\s*\(\s*(?:[`'"]|\w)/,
     validate: (_match, _context) => {
       return true;
     }
@@ -62844,9 +63239,7 @@ function executeRulesSync(filePath, content, language) {
 }
 
 // src/sast/semgrep.ts
-import { execFile as execFile2, execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var _execFileAsync = promisify2(execFile2);
+import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
@@ -62871,7 +63264,12 @@ function parseSemgrepResults(semgrepOutput) {
   try {
     const parsed = JSON.parse(semgrepOutput);
     const results = parsed.results || parsed;
+    if (!Array.isArray(results)) {
+      return [];
+    }
     for (const result of results) {
+      if (!result || typeof result !== "object")
+        continue;
       const severity = mapSemgrepSeverity(result.extra?.severity || result.severity);
       findings.push({
         rule_id: result.check_id || result.rule_id || "unknown",
@@ -63340,7 +63738,7 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   }
   return null;
 }
-function validateDirectory3(dir, workspaceDir) {
+function validateDirectory2(dir, workspaceDir) {
   if (!dir || dir.length === 0) {
     return "directory is required";
   }
@@ -63697,7 +64095,7 @@ async function runQualityBudgetWrapped(changedFiles, directory, _config) {
 async function runPreCheckBatch(input, workspaceDir, contextDir) {
   const effectiveWorkspaceDir = workspaceDir || input.directory || contextDir;
   const { files, directory, sast_threshold = "medium", config: config3 } = input;
-  const dirError = validateDirectory3(directory, effectiveWorkspaceDir);
+  const dirError = validateDirectory2(directory, effectiveWorkspaceDir);
   if (dirError) {
     warn(`pre_check_batch: Invalid directory: ${dirError}`);
     return {
@@ -63908,7 +64306,7 @@ var pre_check_batch = createSwarmTool({
     }
     const resolvedDirectory = path53.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
-    const dirError = validateDirectory3(resolvedDirectory, workspaceAnchor);
+    const dirError = validateDirectory2(resolvedDirectory, workspaceAnchor);
     if (dirError) {
       const errorResult = {
         gates_passed: false,
@@ -64021,10 +64419,11 @@ import * as path54 from "path";
 var LOCKS_DIR = ".swarm/locks";
 var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
 function getLockFilePath(directory, filePath) {
-  if (filePath.includes("..")) {
+  const normalized = path54.resolve(directory, filePath);
+  if (!normalized.startsWith(path54.resolve(directory))) {
     throw new Error("Invalid file path: path traversal not allowed");
   }
-  const hash3 = Buffer.from(filePath).toString("base64").replace(/[/+=]/g, "_");
+  const hash3 = Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
   return path54.join(directory, LOCKS_DIR, `${hash3}.lock`);
 }
 function tryAcquireLock(directory, filePath, agent, taskId) {
@@ -64204,12 +64603,24 @@ async function executeSavePlan(args2, fallbackDir) {
         });
         await fs44.promises.writeFile(markerPath, marker, "utf8");
       } catch {}
+      const warnings = [];
+      let criticReviewFound = false;
+      for (const [, session] of swarmState.agentSessions) {
+        if (session.phaseAgentsDispatched?.has("critic") || session.lastCompletedPhaseAgentsDispatched?.has("critic")) {
+          criticReviewFound = true;
+          break;
+        }
+      }
+      if (!criticReviewFound) {
+        warnings.push("No critic review detected before plan save. Consider delegating to critic for plan validation.");
+      }
       return {
         success: true,
         message: "Plan saved successfully",
         plan_path: path55.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
-        tasks_count: tasksCount
+        tasks_count: tasksCount,
+        ...warnings.length > 0 ? { warnings } : {}
       };
     } finally {
       releaseLock(dir, planFilePath, lockTaskId);
@@ -64679,7 +65090,7 @@ function parseYarnLock(content) {
   const components = [];
   const blocks = content.split(/^(?=@?[\w-]+@)/m);
   for (const block of blocks) {
-    const pkgMatch = block.match(/^(@?[\w-]+)@([\d.]+)/m);
+    const pkgMatch = block.match(/^(@?[\w-]+)@(\d+\.\d+\.\d+(?:-[\w.]+)?)/m);
     if (!pkgMatch)
       continue;
     const name2 = pkgMatch[1];
@@ -64943,8 +65354,8 @@ function parsePackageResolved(content) {
     const pins = resolved.pins || [];
     for (const pin of pins) {
       const identity = pin.identity || pin.package || "";
-      const state2 = pin.state || {};
-      const version3 = state2.version || state2.revision || "";
+      const state = pin.state || {};
+      const version3 = state.version || state.revision || "";
       let org = "";
       const location = pin.location || "";
       const orgMatch = location.match(/github\.com\/([^/]+)\//);
@@ -65030,7 +65441,9 @@ function detectComponents(filePath, content) {
       if (components.length > 0) {
         return components;
       }
-    } catch {}
+    } catch (error93) {
+      console.warn(`[sbom] Detector failed for ${filePath}:`, error93 instanceof Error ? error93.message : String(error93));
+    }
   }
   return [];
 }
@@ -65638,15 +66051,6 @@ var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsControlCharacters(str) {
   return /[\0\t\n\r]/.test(str);
 }
-function containsPathTraversal4(str) {
-  if (/^\/|^[A-Za-z]:[/\\]|\.\.[/\\]|\.\.$|~\/|^\\/.test(str)) {
-    return true;
-  }
-  if (str.includes("%2e%2e") || str.includes("%2E%2E")) {
-    return true;
-  }
-  return false;
-}
 function containsWindowsAttacks(str) {
   if (/:[^\\/]/.test(str)) {
     return true;
@@ -65920,7 +66324,7 @@ var symbols = createSwarmTool({
         symbols: []
       }, null, 2);
     }
-    if (containsPathTraversal4(file3)) {
+    if (containsPathTraversal(file3)) {
       return JSON.stringify({
         file: file3,
         error: "Path contains path traversal sequence",
@@ -66023,17 +66427,11 @@ var PRIORITY_MAP = {
   NOTE: "low"
 };
 var SHELL_METACHAR_REGEX3 = /[;&|%$`\\]/;
-function containsPathTraversal5(str) {
-  return /\.\.[/\\]/.test(str);
-}
-function containsControlChars6(str) {
-  return /[\0\t\r\n]/.test(str);
-}
 function validateTagsInput(tags) {
   if (!tags || tags.length === 0) {
     return "tags cannot be empty";
   }
-  if (containsControlChars6(tags)) {
+  if (containsControlChars(tags)) {
     return "tags contains control characters";
   }
   if (SHELL_METACHAR_REGEX3.test(tags)) {
@@ -66048,10 +66446,10 @@ function validatePathsInput(paths, cwd) {
   if (!paths || paths.length === 0) {
     return { error: null, resolvedPath: cwd };
   }
-  if (containsControlChars6(paths)) {
+  if (containsControlChars(paths)) {
     return { error: "paths contains control characters", resolvedPath: null };
   }
-  if (containsPathTraversal5(paths)) {
+  if (containsPathTraversal(paths)) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
@@ -66434,8 +66832,8 @@ function checkReviewerGate(taskId, workingDirectory) {
         continue;
       }
       validSessionCount++;
-      const state2 = getTaskState(session, taskId);
-      if (state2 === "tests_run" || state2 === "complete") {
+      const state = getTaskState(session, taskId);
+      if (state === "tests_run" || state === "complete") {
         return { blocked: false, reason: "" };
       }
     }
@@ -66446,8 +66844,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     for (const [sessionId, session] of swarmState.agentSessions) {
       if (!(session.taskWorkflowStates instanceof Map))
         continue;
-      const state2 = getTaskState(session, taskId);
-      stateEntries.push(`${sessionId}: ${state2}`);
+      const state = getTaskState(session, taskId);
+      stateEntries.push(`${sessionId}: ${state}`);
     }
     try {
       const resolvedDir2 = workingDirectory;
@@ -66670,19 +67068,35 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     }
   } else {
     if (!fallbackDir) {
-      console.warn("[update-task-status] fallbackDir is undefined");
+      return {
+        success: false,
+        message: "No working_directory provided and fallbackDir is undefined",
+        errors: ["Cannot resolve directory for task status update"]
+      };
     }
     directory = fallbackDir;
   }
   if (args2.status === "completed") {
     recoverTaskStateFromDelegations(args2.task_id);
-    const reviewerCheck = await checkReviewerGateWithScope(args2.task_id, directory);
-    if (reviewerCheck.blocked) {
-      return {
-        success: false,
-        message: "Gate check failed: reviewer delegation required before marking task as completed",
-        errors: [reviewerCheck.reason]
-      };
+    let phaseRequiresReviewer = true;
+    try {
+      const planPath = path61.join(directory, ".swarm", "plan.json");
+      const planRaw = fs50.readFileSync(planPath, "utf-8");
+      const plan = JSON.parse(planRaw);
+      const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
+      if (taskPhase?.required_agents && !taskPhase.required_agents.includes("reviewer")) {
+        phaseRequiresReviewer = false;
+      }
+    } catch {}
+    if (phaseRequiresReviewer) {
+      const reviewerCheck = await checkReviewerGateWithScope(args2.task_id, directory);
+      if (reviewerCheck.blocked) {
+        return {
+          success: false,
+          message: "Gate check failed: reviewer delegation required before marking task as completed",
+          errors: [reviewerCheck.reason]
+        };
+      }
     }
   }
   try {