opencode-swarm 6.38.0 → 6.39.0

package/dist/index.js

@@ -4,43 +4,25 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
+        get: () => mod[key],
         enumerable: true
       });
-  if (canCache)
-    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name2, newValue) {
-  this[name2] = __returnValue.bind(null, newValue);
-}
 var __export = (target, all) => {
   for (var name2 in all)
     __defProp(target, name2, {
       get: all[name2],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name2)
+      set: (newValue) => all[name2] = () => newValue
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -80,7 +62,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 +134,7 @@ var init_constants = __esm(() => {
     architect: [
       "checkpoint",
       "check_gate_status",
+      "completion_verify",
       "complexity_hotspots",
       "detect_domains",
       "evidence_check",
@@ -157,6 +146,7 @@ var init_constants = __esm(() => {
       "diff",
       "pkg_audit",
       "pre_check_batch",
+      "quality_budget",
       "retrieve_summary",
       "save_plan",
       "schema_drift",
@@ -166,7 +156,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 +179,9 @@ var init_constants = __esm(() => {
       "retrieve_summary",
       "schema_drift",
       "symbols",
-      "todo_extract"
+      "todo_extract",
+      "doc_scan",
+      "knowledgeRecall"
     ],
     coder: [
       "diff",
@@ -185,7 +189,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 +203,9 @@ var init_constants = __esm(() => {
       "retrieve_summary",
       "imports",
       "complexity_hotspots",
-      "pkg_audit"
+      "pkg_audit",
+      "build_check",
+      "syntax_check"
     ],
     sme: [
       "complexity_hotspots",
@@ -204,7 +214,8 @@ var init_constants = __esm(() => {
       "imports",
       "retrieve_summary",
       "schema_drift",
-      "symbols"
+      "symbols",
+      "knowledgeRecall"
     ],
     reviewer: [
       "diff",
@@ -217,28 +228,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 +265,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));
@@ -31853,6 +31876,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, {
@@ -33735,6 +33915,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";
@@ -34133,19 +34360,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 +34412,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 +35023,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 +35034,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 +35054,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 +35885,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 +35894,7 @@ var init_test_runner = __esm(() => {
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      if (containsPathTraversal2(workingDir)) {
+      if (containsPathTraversal(workingDir)) {
         const errorResult = {
           success: false,
           framework: "none",
@@ -36643,6 +36826,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 +37223,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();
@@ -36681,10 +37253,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 +38846,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;
@@ -40701,10 +41273,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 +42996,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)
 
@@ -44729,162 +45303,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 +45806,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 +46416,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 +46445,7 @@ function formatCurationSummary(summary) {
 }
 
 // src/commands/dark-matter.ts
+init_knowledge_store();
 import path17 from "path";
 
 // src/tools/co-change-analyzer.ts
@@ -47927,6 +48352,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 +48581,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) {
@@ -49212,20 +49639,6 @@ function getCompactionMetrics() {
 
 // 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,
@@ -52720,7 +53133,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 +54005,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 +54043,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 +54193,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 +54328,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 +54529,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 +55102,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 +55178,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 +55206,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 +55215,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 +55294,10 @@ ${errorSummary}`);
 }
 
 // src/hooks/knowledge-reader.ts
+init_knowledge_store();
 import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import * as path37 from "path";
+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 +55345,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");
+      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 +55450,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)) {
       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 +55483,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 +55504,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 +55838,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 +55869,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;
@@ -55519,6 +55927,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 +56073,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 +56135,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 +56190,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 +56236,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 +56256,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 +56279,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 +56412,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 +56421,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 {}
 }
@@ -56409,8 +56818,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 +56836,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 +56901,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 +56993,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 +57076,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 = {
@@ -56718,10 +57127,10 @@ async function executeCompletionVerify(args2, directory) {
     let foundCount = 0;
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
-      const resolvedPath = path42.resolve(directory, filePath);
+      const resolvedPath = path43.resolve(directory, filePath);
       let fileContent;
       try {
-        fileContent = fs31.readFileSync(resolvedPath, "utf-8");
+        fileContent = fs32.readFileSync(resolvedPath, "utf-8");
       } catch {
         blockedTasks.push({
           task_id: task.id,
@@ -56763,9 +57172,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 +57195,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 +57235,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 +57273,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 +57362,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 +57377,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 +57387,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 +57596,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 +57676,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 +57687,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 +57714,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 +57724,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,
@@ -57643,20 +58049,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 +58143,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 +58239,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 +58441,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 +58881,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 +58888,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 +58903,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;
@@ -59202,6 +59218,7 @@ var imports = createSwarmTool({
 });
 // src/tools/knowledge-add.ts
 init_dist();
+init_knowledge_store();
 init_manager2();
 init_create_tool();
 var VALID_CATEGORIES2 = [
@@ -59315,8 +59332,9 @@ var knowledgeAdd = createSwarmTool({
 });
 // src/tools/knowledge-query.ts
 init_dist();
-import { existsSync as existsSync30 } from "fs";
+init_knowledge_store();
 init_create_tool();
+import { existsSync as existsSync30 } from "fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -59544,6 +59562,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 +59646,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.",
@@ -63340,7 +63360,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 +63717,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 +63928,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,
@@ -65638,15 +65658,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 +65931,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 +66034,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 +66053,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 {