opencode-swarm 7.84.0 → 7.86.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.84.0",
+    version: "7.86.0",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -419,6 +419,10 @@ var init_tool_metadata = __esm(() => {
         "test_engineer"
       ]
     },
+    retrieve_lane_output: {
+      description: "retrieve paged full dispatch lane output by output_ref; use before consuming truncated lane previews or routing candidates from lane results",
+      agents: ["architect"]
+    },
     extract_code_blocks: {
       description: "extract code blocks from text content and save them to files",
       agents: [
@@ -15653,7 +15657,7 @@ var init_schema = __esm(() => {
     max_summary_chars: exports_external.number().min(100).max(5000).default(1000),
     max_stored_bytes: exports_external.number().min(10240).max(104857600).default(10485760),
     retention_days: exports_external.number().min(1).max(365).default(7),
-    exempt_tools: exports_external.array(exports_external.string()).default(["retrieve_summary", "task", "read"])
+    exempt_tools: exports_external.array(exports_external.string()).default(["retrieve_summary", "retrieve_lane_output", "task", "read"])
   });
   ReviewPassesConfigSchema = exports_external.object({
     always_security_review: exports_external.boolean().default(false),
@@ -43497,7 +43501,13 @@ var init_pending_delegations = __esm(() => {
     error: exports_external.string().optional(),
     chars: exports_external.number(),
     truncated: exports_external.boolean(),
-    digest: exports_external.string()
+    digest: exports_external.string(),
+    outputRef: exports_external.string().optional(),
+    outputPreviewChars: exports_external.number().optional(),
+    outputDegraded: exports_external.boolean().optional(),
+    outputArtifactError: exports_external.string().optional(),
+    transcriptIncomplete: exports_external.boolean().optional(),
+    messageCount: exports_external.number().optional()
   }).strict();
   WorkspaceSchema = exports_external.object({
     directory: exports_external.string(),
@@ -45058,7 +45068,7 @@ function recordSessionStart(directory, startMs) {
     const filePath = path32.join(sessionDir, SESSION_START_FILE);
     const line = JSON.stringify({ startMs, ts: Date.now() });
     mkdirSync11(sessionDir, { recursive: true });
-    writeFileSync6(filePath, line + `
+    writeFileSync6(filePath, `${line}
 `, { flag: "a" });
   } catch {}
 }
@@ -107480,7 +107490,7 @@ __export(exports_design_doc_drift, {
   _internals: () => _internals101
 });
 import * as fs111 from "node:fs";
-import * as path171 from "node:path";
+import * as path172 from "node:path";
 function mtimeMsOrNull(absPath) {
   try {
     return fs111.statSync(absPath).mtimeMs;
@@ -107491,35 +107501,35 @@ function mtimeMsOrNull(absPath) {
 function resolveAnchorWithin(directory, anchor) {
   if (!anchor || typeof anchor !== "string")
     return null;
-  const root = path171.resolve(directory);
-  const resolved = path171.resolve(root, anchor);
-  const rel = path171.relative(root, resolved);
-  if (rel.startsWith("..") || path171.isAbsolute(rel))
+  const root = path172.resolve(directory);
+  const resolved = path172.resolve(root, anchor);
+  const rel = path172.relative(root, resolved);
+  if (rel.startsWith("..") || path172.isAbsolute(rel))
     return null;
   return resolved;
 }
 async function runDesignDocDriftCheck(directory, phase, outDir) {
   try {
-    const root = path171.resolve(directory);
-    const outAbs = path171.resolve(root, outDir);
-    const outRel = path171.relative(root, outAbs);
-    if (outRel.startsWith("..") || path171.isAbsolute(outRel)) {
+    const root = path172.resolve(directory);
+    const outAbs = path172.resolve(root, outDir);
+    const outRel = path172.relative(root, outAbs);
+    if (outRel.startsWith("..") || path172.isAbsolute(outRel)) {
       return null;
     }
     const docMtimes = new Map;
     const checkedDocs = [];
     const missingDocs = [];
     for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
-      const abs = path171.join(outAbs, relFile);
+      const abs = path172.join(outAbs, relFile);
       const mtime = mtimeMsOrNull(abs);
       docMtimes.set(docName, mtime);
       if (mtime === null) {
-        missingDocs.push(path171.join(outDir, relFile));
+        missingDocs.push(path172.join(outDir, relFile));
       } else {
-        checkedDocs.push(path171.join(outDir, relFile));
+        checkedDocs.push(path172.join(outDir, relFile));
       }
     }
-    const traceabilityAbs = path171.join(outAbs, TRACEABILITY_REL);
+    const traceabilityAbs = path172.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
       const stat14 = await fs111.promises.stat(traceabilityAbs);
@@ -107589,7 +107599,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     };
     const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
     const filePath = validateSwarmPath(directory, filename);
-    await fs111.promises.mkdir(path171.dirname(filePath), { recursive: true });
+    await fs111.promises.mkdir(path172.dirname(filePath), { recursive: true });
     await fs111.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
     getGlobalEventBus().publish("curator.docdrift.completed", {
       phase,
@@ -107621,10 +107631,10 @@ var init_design_doc_drift = __esm(() => {
     domain: "domain.md",
     "technical-spec": "technical-spec.md",
     "behavior-spec": "behavior-spec.md",
-    "reference-impl": path171.join("reference", "reference-impl.md"),
-    "idiom-notes": path171.join("reference", "idiom-notes.md")
+    "reference-impl": path172.join("reference", "reference-impl.md"),
+    "idiom-notes": path172.join("reference", "idiom-notes.md")
   };
-  TRACEABILITY_REL = path171.join("reference", "traceability.json");
+  TRACEABILITY_REL = path172.join("reference", "traceability.json");
   _internals101 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
@@ -107640,7 +107650,7 @@ __export(exports_project_context, {
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs135 from "node:fs";
-import * as path200 from "node:path";
+import * as path201 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -107652,7 +107662,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs135.accessSync(path200.join(directory, pattern));
+    fs135.accessSync(path201.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -107661,7 +107671,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs135.readFileSync(path200.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs135.readFileSync(path201.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -107779,7 +107789,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path201 from "node:path";
+import * as path202 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/background/index.ts
@@ -110922,8 +110932,18 @@ function shouldMaskToolOutput(msg, index, totalMessages, recentWindowSize, thres
   if (text.includes("[Tool output masked") || text.includes("[Context pruned")) {
     return false;
   }
+  const structuredToolName = msg.info.toolName;
+  const exemptList = [
+    "retrieve_summary",
+    "retrieve_lane_output",
+    "task",
+    "read"
+  ];
+  if (structuredToolName && exemptList.includes(structuredToolName.toLowerCase())) {
+    return false;
+  }
   const toolName = extractToolName(text);
-  if (toolName && ["retrieve_summary", "task", "read"].includes(toolName.toLowerCase())) {
+  if (toolName && exemptList.includes(toolName.toLowerCase())) {
     return false;
   }
   const age = totalMessages - 1 - index;
@@ -113297,7 +113317,25 @@ function safeRealpathSync(targetPath, fallback, realpathResolver = realpathSync1
 // src/tools/repo-graph/types.ts
 import * as path117 from "node:path";
 var REPO_GRAPH_FILENAME = "repo-graph.json";
-var GRAPH_SCHEMA_VERSION = "1.0.0";
+var GRAPH_SCHEMA_VERSION = "1.1.0";
+function isSchemaVersionAtLeast(version5, minimum) {
+  const parse10 = (v) => v.split(".").map((part) => {
+    const n = Number.parseInt(part, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+  const a = parse10(version5 ?? "");
+  const b = parse10(minimum);
+  const len = Math.max(a.length, b.length);
+  for (let i2 = 0;i2 < len; i2++) {
+    const av = a[i2] ?? 0;
+    const bv = b[i2] ?? 0;
+    if (av > bv)
+      return true;
+    if (av < bv)
+      return false;
+  }
+  return true;
+}
 var FILE_ROLE_VALUES = [
   "api_route",
   "middleware",
@@ -113472,6 +113510,19 @@ function validateGraphNode(node) {
       throw new Error(`Invalid node: imports contains control characters (file=${node.filePath}, value="${preview}")`);
     }
   }
+  if (node.exportLines !== undefined) {
+    if (typeof node.exportLines !== "object" || node.exportLines === null || Array.isArray(node.exportLines)) {
+      throw new Error("Invalid node: exportLines must be an object");
+    }
+    for (const [name2, line] of Object.entries(node.exportLines)) {
+      if (containsControlChars(name2)) {
+        throw new Error("Invalid node: exportLines key contains control characters");
+      }
+      if (typeof line !== "number" || !Number.isFinite(line) || line < 0) {
+        throw new Error("Invalid node: exportLines values must be non-negative numbers");
+      }
+    }
+  }
   if (node.ontology !== undefined) {
     validateOntologyStrings(node);
   }
@@ -113589,6 +113640,19 @@ function validateGraphEdge(edge) {
       }
     }
   }
+  if (edge.usedSymbols !== undefined) {
+    if (!Array.isArray(edge.usedSymbols)) {
+      throw new Error("Invalid edge: usedSymbols must be an array");
+    }
+    for (const symbol3 of edge.usedSymbols) {
+      if (typeof symbol3 !== "string") {
+        throw new Error("Invalid edge: usedSymbols must be an array of strings");
+      }
+      if (containsControlChars(symbol3)) {
+        throw new Error("Invalid edge: usedSymbols contains control characters");
+      }
+    }
+  }
 }
 
 // src/tools/repo-graph/builder.ts
@@ -113597,7 +113661,9 @@ var _internals74 = {
   extractTSSymbols,
   extractPythonSymbols,
   parseFileImports,
-  extractFileOntology
+  extractFileOntology,
+  stripComments: stripComments2,
+  computeUsedSymbols
 };
 var SKIP_DIRECTORIES3 = new Set([
   "node_modules",
@@ -113894,11 +113960,89 @@ function parseFileImports(rawContent) {
     imports.push({
       specifier: modulePath,
       importType,
-      importedSymbols: parseImportedSymbols(matchedString, importType)
+      importedSymbols: parseImportedSymbols(matchedString, importType),
+      bindings: parseImportBindings(matchedString, importType),
+      reExport: /^\s*export\b/.test(matchedString)
     });
   }
   return imports;
 }
+function parseImportBindings(matchedString, importType) {
+  if (importType === "namespace")
+    return [];
+  if (importType === "default") {
+    const defaultMatch = matchedString.match(/^import\s+(\w+)\s+from\s+['"`]/);
+    return defaultMatch ? [{ imported: "default", local: defaultMatch[1] }] : [];
+  }
+  if (importType !== "named")
+    return [];
+  const braceMatch = matchedString.match(/\{\s*([\s\S]*?)\s*\}/);
+  if (!braceMatch)
+    return [];
+  const bindings = [];
+  const seen = new Set;
+  for (const rawPart of braceMatch[1].split(",")) {
+    const part = rawPart.trim().replace(/^type\s+/, "");
+    if (!part)
+      continue;
+    const aliasSplit = part.split(/\s+as\s+/i);
+    const imported = aliasSplit[0].trim();
+    const local = (aliasSplit[1] ?? aliasSplit[0]).trim();
+    if (!/^[A-Za-z_$][\w$]*$/.test(imported))
+      continue;
+    if (!/^[A-Za-z_$][\w$]*$/.test(local))
+      continue;
+    if (seen.has(imported))
+      continue;
+    seen.add(imported);
+    bindings.push({ imported, local });
+  }
+  return bindings;
+}
+var SAFE_USAGE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function computeUsedSymbols(strippedContent, bindings) {
+  if (bindings.length === 0)
+    return [];
+  const used = new Set;
+  for (const binding of bindings) {
+    if (!SAFE_USAGE_IDENTIFIER.test(binding.local)) {
+      used.add(binding.imported);
+      continue;
+    }
+    const re = new RegExp(`\\b${binding.local}\\b`, "g");
+    let count = 0;
+    for (const _match of strippedContent.matchAll(re)) {
+      count++;
+      if (count > 1)
+        break;
+    }
+    if (count > 1)
+      used.add(binding.imported);
+  }
+  return [...used].sort((a, b) => a.localeCompare(b));
+}
+function usedSymbolsForImport(parsed, strippedContent) {
+  if (parsed.importType === "namespace" || parsed.importType === "sideeffect" || parsed.importType === "require") {
+    return;
+  }
+  if (parsed.reExport) {
+    return [...new Set(parsed.bindings.map((b) => b.imported))].sort((a, b) => a.localeCompare(b));
+  }
+  return computeUsedSymbols(strippedContent, parsed.bindings);
+}
+function collectExports(symbols2) {
+  const exported = symbols2.filter((s) => s.exported);
+  const exports = exported.map((s) => s.signature === `default ${s.name}` ? "default" : s.name);
+  const exportLines = {};
+  for (let i2 = 0;i2 < exported.length; i2++) {
+    const s = exported[i2];
+    const name2 = exports[i2];
+    if (typeof s.line === "number" && Number.isFinite(s.line) && exportLines[name2] === undefined) {
+      exportLines[name2] = s.line;
+    }
+  }
+  return { exports, exportLines };
+}
 function parseImportedSymbols(matchedString, importType) {
   if (importType === "namespace")
     return ["*"];
@@ -114042,22 +114186,23 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
   }
   const ext = path118.extname(filePath).toLowerCase();
   let exports = [];
+  let exportLines = {};
   try {
     if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
       const relativePath = path118.relative(absoluteRoot, filePath);
-      const symbols2 = _internals74.extractTSSymbols(relativePath, absoluteRoot);
-      exports = symbols2.filter((s) => s.exported).map((s) => s.name);
+      ({ exports, exportLines } = collectExports(_internals74.extractTSSymbols(relativePath, absoluteRoot)));
     } else if (ext === ".py") {
       const relativePath = path118.relative(absoluteRoot, filePath);
-      const symbols2 = _internals74.extractPythonSymbols(relativePath, absoluteRoot);
-      exports = symbols2.filter((s) => s.exported).map((s) => s.name);
+      ({ exports, exportLines } = collectExports(_internals74.extractPythonSymbols(relativePath, absoluteRoot)));
     }
     const parsedImports = _internals74.parseFileImports(content);
+    const strippedForUsage = parsedImports.length > 0 ? _internals74.stripComments(content) : "";
     const moduleName = toModuleName(filePath, absoluteRoot);
     const node = {
       filePath,
       moduleName,
       exports,
+      ...Object.keys(exportLines).length > 0 ? { exportLines } : {},
       imports: parsedImports.map((p) => p.specifier),
       language: getLanguage(filePath),
       mtime: fileStats.mtime.toISOString(),
@@ -114075,12 +114220,14 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
     for (const parsed of sortedImports) {
       const resolvedTarget = resolveModuleSpecifier(absoluteRoot, filePath, parsed.specifier);
       if (resolvedTarget !== null) {
+        const usedSymbols = usedSymbolsForImport(parsed, strippedForUsage);
         edges.push({
           source: filePath,
           target: resolvedTarget,
           importSpecifier: parsed.specifier,
           importType: parsed.importType,
-          importedSymbols: parsed.importedSymbols
+          importedSymbols: parsed.importedSymbols,
+          ...usedSymbols !== undefined ? { usedSymbols } : {}
         });
       }
     }
@@ -114336,6 +114483,113 @@ function getSymbolConsumers(graph, filePath, symbolName) {
   refs.sort((a, b) => a.file.localeCompare(b.file));
   return refs;
 }
+function getCallers(graph, filePath, symbolName) {
+  const node = getGraphNode(graph, filePath);
+  if (!node)
+    return [];
+  const targetKey = normalizeGraphPath(node.filePath);
+  const refs = [];
+  const seen = new Set;
+  for (const edge of graph.edges) {
+    if (normalizeGraphPath(edge.target) !== targetKey)
+      continue;
+    const file3 = moduleNameForEdgePath(graph, edge.source);
+    if (seen.has(file3))
+      continue;
+    if (edge.usedSymbols !== undefined) {
+      if (edge.usedSymbols.includes(symbolName)) {
+        seen.add(file3);
+        refs.push({ file: file3, resolution: "used" });
+      }
+      continue;
+    }
+    const imported = edge.importedSymbols ?? [];
+    if (edge.importType === "namespace" || imported.includes(symbolName)) {
+      seen.add(file3);
+      refs.push({ file: file3, resolution: "imported" });
+    }
+  }
+  refs.sort((a, b) => a.file.localeCompare(b.file));
+  return refs;
+}
+var DEAD_EXPORT_EXCLUDED_ROLES = new Set([
+  "api_route",
+  "cli_command",
+  "test_file",
+  "agent",
+  "hook",
+  "middleware"
+]);
+function getDeadExports(graph, options) {
+  if (!isSchemaVersionAtLeast(graph.schema_version, "1.1.0")) {
+    return {
+      schemaSupported: false,
+      analyzedFiles: 0,
+      skippedUnresolvable: 0,
+      candidates: [],
+      note: 'Graph predates schema 1.1.0 (no usedSymbols data). Run repo_map action="build" to enable dead_exports.'
+    };
+  }
+  const usage = new Map;
+  for (const edge of graph.edges) {
+    const target = normalizeGraphPath(edge.target);
+    let entry = usage.get(target);
+    if (!entry) {
+      entry = { used: new Set, unresolvable: false };
+      usage.set(target, entry);
+    }
+    if (edge.importType === "namespace" || edge.importType === "sideeffect" || edge.importType === "require") {
+      entry.unresolvable = true;
+    } else if (edge.usedSymbols) {
+      for (const symbol3 of edge.usedSymbols)
+        entry.used.add(symbol3);
+    }
+  }
+  const reverse = getReverseIndex(graph);
+  const candidates = [];
+  let analyzedFiles = 0;
+  let skippedUnresolvable = 0;
+  for (const node of Object.values(graph.nodes)) {
+    if (node.exports.length === 0)
+      continue;
+    const key = normalizeGraphPath(node.filePath);
+    const importerCount = reverse.get(key)?.length ?? 0;
+    if (importerCount === 0)
+      continue;
+    const roles = node.ontology?.roles ?? [];
+    if (roles.some((r) => DEAD_EXPORT_EXCLUDED_ROLES.has(r)))
+      continue;
+    const entry = usage.get(key);
+    if (entry?.unresolvable) {
+      skippedUnresolvable++;
+      continue;
+    }
+    analyzedFiles++;
+    const used = entry?.used ?? new Set;
+    for (const symbol3 of node.exports) {
+      if (symbol3 === "default")
+        continue;
+      if (used.has(symbol3))
+        continue;
+      candidates.push({
+        file: node.moduleName,
+        symbol: symbol3,
+        line: node.exportLines?.[symbol3],
+        importerCount
+      });
+    }
+  }
+  candidates.sort((a, b) => a.file.localeCompare(b.file) || a.symbol.localeCompare(b.symbol));
+  const limit = options?.maxCandidates ?? 100;
+  const truncated = candidates.length > limit;
+  return {
+    schemaSupported: true,
+    analyzedFiles,
+    skippedUnresolvable,
+    candidates: candidates.slice(0, limit),
+    note: "Advisory: exported symbols with no detected in-repo reference, limited to files imported by >=1 other file. " + "Regex analysis cannot see dynamic dispatch, string-keyed access, or namespace/barrel re-export usage; verify before removing." + (truncated ? ` Showing ${limit} of ${candidates.length}.` : "")
+  };
+}
 function getBlastRadius(graph, filePaths, maxDepth = 3) {
   const targetNodes = filePaths.map((filePath) => getGraphNode(graph, filePath)).filter((node) => node !== undefined);
   const targets = targetNodes.map((node) => normalizeLookupPath(node.moduleName));
@@ -118187,6 +118441,7 @@ function createToolSummarizerHook(config3, directory) {
     }
     const exemptTools = config3.exempt_tools ?? [
       "retrieve_summary",
+      "retrieve_lane_output",
       "task",
       "read"
     ];
@@ -121352,6 +121607,7 @@ var PROBED_TOOLS = new Set([
   "gitingest",
   "extract_code_blocks",
   "retrieve_summary",
+  "retrieve_lane_output",
   "search",
   "read",
   "view"
@@ -127743,7 +127999,7 @@ var diff_summary = createSwarmTool({
 });
 
 // src/tools/dispatch-lanes.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -127903,6 +128159,231 @@ function validateConcurrency(concurrency) {
 
 // src/tools/dispatch-lanes.ts
 init_zod();
+
+// src/background/lane-output-store.ts
+init_zod();
+init_utils2();
+import { createHash as createHash18 } from "node:crypto";
+import {
+  existsSync as existsSync85,
+  mkdirSync as mkdirSync37,
+  readFileSync as readFileSync60,
+  renameSync as renameSync23,
+  unlinkSync as unlinkSync19,
+  writeFileSync as writeFileSync24
+} from "node:fs";
+import * as path152 from "node:path";
+var LANE_OUTPUT_REF_PREFIX = "L1";
+var MAX_LANE_OUTPUT_STORED_BYTES = 10 * 1024 * 1024;
+var LANE_OUTPUT_SCHEMA_VERSION = 1;
+var REF_RE = /^L1:[a-f0-9]{64}:[a-f0-9]{64}:[a-f0-9]{64}$/;
+var LaneOutputArtifactSchema = exports_external.object({
+  schemaVersion: exports_external.literal(LANE_OUTPUT_SCHEMA_VERSION),
+  ref: exports_external.string().regex(REF_RE),
+  batchId: exports_external.string().min(1),
+  laneId: exports_external.string().min(1),
+  agent: exports_external.string().min(1),
+  role: exports_external.string().min(1),
+  sessionId: exports_external.string().min(1).optional(),
+  parentSessionId: exports_external.string().min(1).optional(),
+  mode: exports_external.string().min(1).optional(),
+  source: exports_external.enum(["dispatch_lanes", "collect_lane_results"]),
+  text: exports_external.string(),
+  chars: exports_external.number().int().nonnegative(),
+  bytes: exports_external.number().int().nonnegative(),
+  digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  messageCount: exports_external.number().int().nonnegative().optional(),
+  transcriptIncomplete: exports_external.boolean().optional(),
+  createdAt: exports_external.string(),
+  updatedAt: exports_external.string()
+}).strict();
+function storeLaneOutput(directory, input, now = Date.now) {
+  const bytes = Buffer.byteLength(input.text, "utf-8");
+  const digest3 = digestText(input.text);
+  if (bytes > MAX_LANE_OUTPUT_STORED_BYTES) {
+    return {
+      digest: digest3,
+      chars: input.text.length,
+      bytes,
+      degraded: true,
+      error: `lane output exceeds ${MAX_LANE_OUTPUT_STORED_BYTES} byte storage limit`
+    };
+  }
+  const batchDigest = digestText(input.batchId);
+  const laneDigest = digestText(input.laneId);
+  const ref = `${LANE_OUTPUT_REF_PREFIX}:${batchDigest}:${laneDigest}:${digest3}`;
+  const relPath = laneOutputRelativePath(ref);
+  const absPath = validateSwarmPath(directory, relPath);
+  const timestamp = new Date(now()).toISOString();
+  try {
+    if (existsSync85(absPath)) {
+      const existing = LaneOutputArtifactSchema.safeParse(JSON.parse(readFileSync60(absPath, "utf-8")));
+      if (existing.success && existing.data.digest === digest3) {
+        return {
+          ref,
+          digest: digest3,
+          chars: existing.data.chars,
+          bytes: existing.data.bytes,
+          degraded: false
+        };
+      }
+    }
+    const artifact = {
+      schemaVersion: LANE_OUTPUT_SCHEMA_VERSION,
+      ref,
+      batchId: input.batchId,
+      laneId: input.laneId,
+      agent: input.agent,
+      role: input.role,
+      ...input.sessionId ? { sessionId: input.sessionId } : {},
+      ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
+      ...input.mode ? { mode: input.mode } : {},
+      source: input.source,
+      text: input.text,
+      chars: input.text.length,
+      bytes,
+      digest: digest3,
+      ...input.messageCount !== undefined ? { messageCount: input.messageCount } : {},
+      ...input.transcriptIncomplete !== undefined ? { transcriptIncomplete: input.transcriptIncomplete } : {},
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    writeAtomicJson(absPath, artifact);
+    return {
+      ref,
+      digest: digest3,
+      chars: artifact.chars,
+      bytes: artifact.bytes,
+      degraded: false
+    };
+  } catch (error93) {
+    return {
+      digest: digest3,
+      chars: input.text.length,
+      bytes,
+      degraded: true,
+      error: error93 instanceof Error ? error93.message : "failed to store lane output artifact"
+    };
+  }
+}
+function readLaneOutput(directory, ref) {
+  if (!REF_RE.test(ref))
+    return null;
+  const absPath = validateSwarmPath(directory, laneOutputRelativePath(ref));
+  if (!existsSync85(absPath))
+    return null;
+  let parsed;
+  try {
+    parsed = LaneOutputArtifactSchema.safeParse(JSON.parse(readFileSync60(absPath, "utf-8")));
+  } catch {
+    return null;
+  }
+  if (!parsed.success || parsed.data.ref !== ref)
+    return null;
+  return { artifact: parsed.data };
+}
+function buildLaneOutputPreview(args2) {
+  const { text, ref, degraded, maxChars } = args2;
+  const needsPreview = text.length > maxChars;
+  if (!needsPreview && !degraded) {
+    return {
+      output: text,
+      output_chars: text.length,
+      output_truncated: false
+    };
+  }
+  const marker = buildPreviewMarker({
+    omittedChars: Math.max(0, text.length - maxChars),
+    ref,
+    degraded: degraded === true
+  });
+  if (text.length <= maxChars && degraded) {
+    return {
+      output: `${text}${marker}`,
+      output_chars: text.length,
+      output_truncated: false
+    };
+  }
+  const budget = Math.max(0, maxChars - marker.length);
+  const headChars = Math.ceil(budget / 2);
+  const tailChars = Math.floor(budget / 2);
+  const head = text.slice(0, headChars);
+  const tail = tailChars > 0 ? text.slice(text.length - tailChars) : "";
+  return {
+    output: `${head}${marker}${tail}`,
+    output_chars: text.length,
+    output_truncated: true
+  };
+}
+function paginateLaneOutput(text, offset, limit) {
+  const lines = text.length === 0 ? [] : text.split(`
+`);
+  const totalLines = lines.length;
+  const startLine = Math.max(0, offset);
+  if (startLine >= totalLines) {
+    return {
+      totalLines,
+      startLine,
+      endLine: totalLines,
+      content: "",
+      exhausted: true
+    };
+  }
+  const endLine = Math.min(startLine + limit, totalLines);
+  return {
+    totalLines,
+    startLine,
+    endLine,
+    content: lines.slice(startLine, endLine).join(`
+`),
+    exhausted: false
+  };
+}
+function buildPreviewMarker(args2) {
+  const retrieval = args2.ref ? ` retrieve_lane_output ref=${args2.ref} for full output.` : " no full output artifact is available; treat this lane as degraded.";
+  const degraded = args2.degraded ? " Artifact storage degraded." : "";
+  return `
+[... lane output preview omitted middle content.${degraded}${retrieval} ...]
+`;
+}
+function laneOutputRelativePath(ref) {
+  const [, batchDigest, laneDigest, outputDigest] = ref.split(":");
+  return path152.join("lane-results", batchDigest, laneDigest, `${outputDigest}.json`);
+}
+var WINDOWS_RENAME_MAX_RETRIES3 = 3;
+function writeAtomicJson(absPath, value) {
+  mkdirSync37(path152.dirname(absPath), { recursive: true });
+  const tempFile = `${absPath}.tmp-${Date.now()}-${process.pid}`;
+  try {
+    writeFileSync24(tempFile, JSON.stringify(value, null, 2), "utf-8");
+    let lastRenameError;
+    for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES3; attempt++) {
+      try {
+        renameSync23(tempFile, absPath);
+        lastRenameError = undefined;
+        break;
+      } catch (err2) {
+        lastRenameError = err2;
+        const code = err2.code;
+        if (code !== "EEXIST" && code !== "EBUSY" && code !== "EPERM")
+          break;
+      }
+    }
+    if (lastRenameError)
+      throw lastRenameError;
+  } finally {
+    if (existsSync85(tempFile)) {
+      try {
+        unlinkSync19(tempFile);
+      } catch {}
+    }
+  }
+}
+function digestText(text) {
+  return createHash18("sha256").update(text).digest("hex");
+}
+
+// src/tools/dispatch-lanes.ts
 init_pending_delegations();
 init_constants();
 init_schema();
@@ -127969,6 +128450,7 @@ var COMMON_PROMPT_SEPARATOR = `
 var DEFAULT_TIMEOUT_MS3 = 300000;
 var MAX_TIMEOUT_MS2 = 1800000;
 var MAX_LANE_OUTPUT_CHARS = 20000;
+var ASYNC_MESSAGE_FETCH_LIMIT = 50;
 var MAX_ERROR_CHARS = 200;
 var ERROR_TRUNCATION_SUFFIX = "...";
 var MAX_BATCH_ID_CHARS = 120;
@@ -128324,7 +128806,7 @@ async function launchAsyncLane(args2) {
           error: message,
           chars: message.length,
           truncated: false,
-          digest: digestText(message)
+          digest: digestText2(message)
         }
       });
       cleanupAsyncLaunchSession(args2.session, sessionId);
@@ -128338,7 +128820,7 @@ async function launchAsyncLane(args2) {
           error: error93,
           chars: error93.length,
           truncated: false,
-          digest: digestText(error93)
+          digest: digestText2(error93)
         }
       });
       cleanupAsyncLaunchSession(args2.session, sessionId);
@@ -128383,38 +128865,63 @@ async function collectOnce(session, directory, records, cancelPending) {
     try {
       messages = await session.messages({
         path: { id: record3.subagentSessionId },
-        query: { directory, limit: 50 }
+        query: { directory, limit: ASYNC_MESSAGE_FETCH_LIMIT }
       });
     } catch {
       continue;
     }
     if (!messages.data)
       continue;
-    const text = extractLastAssistantText(messages.data);
-    if (!text)
+    const transcript = extractAssistantTranscript(messages.data);
+    if (!transcript.text)
       continue;
-    const bounded = boundLaneOutput(text);
+    const output = prepareLaneOutput({
+      directory,
+      batchId: record3.batchId ?? record3.callID,
+      laneId: record3.laneId ?? record3.correlationId,
+      agent: record3.swarmPrefixedAgent,
+      role: record3.normalizedAgent,
+      sessionId: record3.subagentSessionId,
+      parentSessionId: record3.parentSessionId,
+      mode: record3.mode,
+      source: "collect_lane_results",
+      text: transcript.text,
+      messageCount: transcript.messageCount,
+      transcriptIncomplete: transcript.transcriptIncomplete
+    });
     await appendDelegationTransition(directory, record3.correlationId, {
       status: "completed",
       result: {
-        text: bounded.output,
-        chars: bounded.output_chars,
-        truncated: bounded.output_truncated,
-        digest: digestText(text)
+        text: output.output,
+        chars: output.output_chars,
+        truncated: output.output_truncated,
+        digest: output.output_digest,
+        ...output.output_ref ? { outputRef: output.output_ref } : {},
+        outputPreviewChars: output.output.length,
+        ...output.output_degraded !== undefined ? { outputDegraded: output.output_degraded } : {},
+        ...output.output_artifact_error ? { outputArtifactError: output.output_artifact_error } : {},
+        ...output.transcript_incomplete !== undefined ? { transcriptIncomplete: output.transcript_incomplete } : {},
+        messageCount: transcript.messageCount
       }
     });
   }
 }
-function extractLastAssistantText(messages) {
-  for (let i2 = messages.length - 1;i2 >= 0; i2--) {
-    const message = messages[i2];
+function extractAssistantTranscript(messages) {
+  const assistantTexts = [];
+  for (const message of messages) {
     if (message.info?.role !== "assistant")
       continue;
     const text = extractText3(message.parts);
     if (text.trim().length > 0)
-      return text;
+      assistantTexts.push(text);
   }
-  return "";
+  return {
+    text: assistantTexts.join(`
+
+`),
+    messageCount: assistantTexts.length,
+    transcriptIncomplete: messages.length >= ASYNC_MESSAGE_FETCH_LIMIT
+  };
 }
 function nextCollectPollInterval(currentMs) {
   if (currentMs <= 0)
@@ -128483,7 +128990,17 @@ async function runLane(session, dispatcher, lane, directory, timeoutMs, context)
     if (!promptResult.data) {
       return failedLane(lane, role, startedAt, `session.prompt failed: ${formatError3(promptResult.error)}`, decision.slot.slotId, decision.slot.runId, sessionId);
     }
-    const boundedOutput = boundLaneOutput(extractText3(promptResult.data.parts));
+    const laneOutput = prepareLaneOutput({
+      directory,
+      batchId: `blocking:${sessionId}`,
+      laneId: lane.id,
+      agent: lane.agent,
+      role,
+      sessionId,
+      parentSessionId: context.sessionID,
+      source: "dispatch_lanes",
+      text: extractText3(promptResult.data.parts)
+    });
     return {
       id: lane.id,
       agent: lane.agent,
@@ -128494,7 +129011,7 @@ async function runLane(session, dispatcher, lane, directory, timeoutMs, context)
       run_id: decision.slot.runId,
       started_at: startedAt,
       completed_at: isoNow(),
-      ...boundedOutput
+      ...laneOutput
     };
   } catch (error93) {
     return failedLane(lane, role, startedAt, formatError3(error93), decision.slot.slotId, decision.slot.runId, sessionId);
@@ -128556,7 +129073,14 @@ function recordToLaneResult(record3) {
     ...record3.result?.text !== undefined ? {
       output: record3.result.text,
       output_chars: record3.result.chars,
-      output_truncated: record3.result.truncated
+      output_truncated: record3.result.truncated,
+      output_digest: record3.result.digest,
+      ...record3.result.outputRef ? { output_ref: record3.result.outputRef } : {},
+      ...record3.result.outputPreviewChars !== undefined ? { output_preview_chars: record3.result.outputPreviewChars } : {},
+      ...record3.result.outputDegraded !== undefined ? { output_degraded: record3.result.outputDegraded } : {},
+      ...record3.result.outputArtifactError ? { output_artifact_error: record3.result.outputArtifactError } : {},
+      ...record3.result.transcriptIncomplete !== undefined ? { transcript_incomplete: record3.result.transcriptIncomplete } : {},
+      ...record3.result.messageCount !== undefined ? { message_count: record3.result.messageCount } : {}
     } : {},
     ...record3.result?.error !== undefined ? { error: record3.result.error } : {}
   };
@@ -128633,22 +129157,35 @@ function buildReadOnlyTools() {
   tools.patch = false;
   return tools;
 }
-function boundLaneOutput(output) {
-  if (output.length <= MAX_LANE_OUTPUT_CHARS) {
-    return {
-      output,
-      output_chars: output.length,
-      output_truncated: false
-    };
-  }
-  const omitted = output.length - MAX_LANE_OUTPUT_CHARS;
-  const suffix = `
-[... ${omitted} chars truncated by dispatch_lanes ...]`;
-  const maxContent = Math.max(0, MAX_LANE_OUTPUT_CHARS - suffix.length);
+function prepareLaneOutput(args2) {
+  const stored = storeLaneOutput(args2.directory, {
+    batchId: args2.batchId,
+    laneId: args2.laneId,
+    agent: args2.agent,
+    role: args2.role,
+    sessionId: args2.sessionId,
+    parentSessionId: args2.parentSessionId,
+    mode: args2.mode,
+    source: args2.source,
+    text: args2.text,
+    messageCount: args2.messageCount,
+    transcriptIncomplete: args2.transcriptIncomplete
+  });
+  const preview = buildLaneOutputPreview({
+    text: args2.text,
+    ref: stored.ref,
+    degraded: stored.degraded,
+    maxChars: MAX_LANE_OUTPUT_CHARS
+  });
   return {
-    output: `${output.slice(0, maxContent)}${suffix}`,
-    output_chars: output.length,
-    output_truncated: true
+    ...preview,
+    output_ref: stored.ref,
+    output_digest: stored.digest,
+    output_preview_chars: preview.output.length,
+    ...stored.degraded ? { output_degraded: true } : {},
+    ...stored.error ? { output_artifact_error: stored.error } : {},
+    ...args2.transcriptIncomplete !== undefined ? { transcript_incomplete: args2.transcriptIncomplete } : {},
+    ...args2.messageCount !== undefined ? { message_count: args2.messageCount } : {}
   };
 }
 function failureResult(args2) {
@@ -128779,7 +129316,7 @@ function makeBatchId() {
   return `lanes-${_internals85.now().toString(36)}`;
 }
 function promptHash(lane, directory, batchId) {
-  return digestText(JSON.stringify({
+  return digestText2(JSON.stringify({
     batchId,
     laneId: lane.id,
     agent: lane.agent,
@@ -128788,8 +129325,8 @@ function promptHash(lane, directory, batchId) {
 `)
   }));
 }
-function digestText(text) {
-  return createHash18("sha256").update(text).digest("hex");
+function digestText2(text) {
+  return createHash19("sha256").update(text).digest("hex");
 }
 function sleep2(ms) {
   if (ms <= 0)
@@ -129052,7 +129589,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs94 from "node:fs";
-import * as path152 from "node:path";
+import * as path153 from "node:path";
 var MAX_FILE_SIZE_BYTES5 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR3 = ".swarm/evidence";
@@ -129079,9 +129616,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path152.resolve(cwd);
-  const swarmPath = path152.join(normalizedCwd, ".swarm");
-  const normalizedPath = path152.resolve(filePath);
+  const normalizedCwd = path153.resolve(cwd);
+  const swarmPath = path153.join(normalizedCwd, ".swarm");
+  const normalizedPath = path153.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -129111,10 +129648,10 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path152.join(evidenceDir, filename);
+    const filePath = path153.join(evidenceDir, filename);
     try {
-      const resolvedPath = path152.resolve(filePath);
-      const evidenceDirResolved = path152.resolve(evidenceDir);
+      const resolvedPath = path153.resolve(filePath);
+      const evidenceDirResolved = path153.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
@@ -129232,7 +129769,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path152.join(cwd, PLAN_FILE);
+    const planPath = path153.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -129264,7 +129801,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path152.join(cwd, EVIDENCE_DIR3);
+    const evidenceDir = path153.join(cwd, EVIDENCE_DIR3);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -129287,7 +129824,7 @@ init_loader();
 init_task_file();
 import * as crypto11 from "node:crypto";
 import * as fs95 from "node:fs/promises";
-import * as path153 from "node:path";
+import * as path154 from "node:path";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var EVICTABLE_VERDICTS = new Set([
   "pending",
@@ -129300,7 +129837,7 @@ function candidateFilePath(storePath3, id) {
   if (!isValidCandidateId(id)) {
     return null;
   }
-  return path153.join(storePath3, `${id}.json`);
+  return path154.join(storePath3, `${id}.json`);
 }
 var _internals86 = {
   randomUUID: crypto11.randomUUID.bind(crypto11),
@@ -129313,11 +129850,11 @@ var _internals86 = {
   atomicWriteFile
 };
 function createExternalSkillStore(directory, config3) {
-  const storePath3 = path153.join(directory, ".swarm", "skills", "candidates");
+  const storePath3 = path154.join(directory, ".swarm", "skills", "candidates");
   async function add2(candidate) {
     const id = _internals86.randomUUID();
     const full = { ...candidate, id };
-    const filePath = path153.join(storePath3, `${id}.json`);
+    const filePath = path154.join(storePath3, `${id}.json`);
     await _internals86.fs.mkdir(storePath3, { recursive: true });
     await _internals86.atomicWriteFile(filePath, JSON.stringify(full, null, "\t"));
     return full;
@@ -129357,7 +129894,7 @@ function createExternalSkillStore(directory, config3) {
       if (!entry.endsWith(".json")) {
         continue;
       }
-      const filePath = path153.join(storePath3, entry);
+      const filePath = path154.join(storePath3, entry);
       let raw;
       try {
         raw = await _internals86.fs.readFile(filePath, "utf-8");
@@ -129541,11 +130078,11 @@ var external_skill_delete = createSwarmTool({
 // src/tools/external-skill-discover.ts
 init_zod();
 init_loader();
-import { createHash as createHash20, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash21, randomUUID as randomUUID12 } from "node:crypto";
 
 // src/services/external-skill-validator.ts
 init_knowledge_validator();
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 var PROMPT_INJECTION_PATTERNS = [
   {
     pattern: /system\s*:/i,
@@ -130080,7 +130617,7 @@ function evaluateCandidate(candidate, options) {
 }
 var _internals88 = {
   getTimestamp: () => new Date().toISOString(),
-  computeSha256: (content) => createHash19("sha256").update(content).digest("hex"),
+  computeSha256: (content) => createHash20("sha256").update(content).digest("hex"),
   stripMarkdownCodeForUnsafeScan
 };
 
@@ -130102,7 +130639,7 @@ var _internals89 = {
     return { content, finalUrl: response.url };
   },
   getTimestamp: () => new Date().toISOString(),
-  computeSha256: (content) => createHash20("sha256").update(content).digest("hex"),
+  computeSha256: (content) => createHash21("sha256").update(content).digest("hex"),
   uuid: () => randomUUID12()
 };
 var SOURCE_TRUST_LEVELS = {
@@ -130488,9 +131025,9 @@ var external_skill_list = createSwarmTool({
 // src/tools/external-skill-promote.ts
 init_zod();
 init_loader();
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 import * as fs96 from "node:fs/promises";
-import * as path154 from "node:path";
+import * as path155 from "node:path";
 init_create_tool();
 var _internals92 = {
   loadConfig: (directory) => {
@@ -130507,7 +131044,7 @@ var _internals92 = {
     }
   },
   writeSkillFile: async (filePath, content) => {
-    await fs96.mkdir(path154.dirname(filePath), { recursive: true });
+    await fs96.mkdir(path155.dirname(filePath), { recursive: true });
     const handle2 = await fs96.open(filePath, "wx");
     try {
       await handle2.writeFile(content, "utf-8");
@@ -130630,8 +131167,8 @@ var external_skill_promote = createSwarmTool({
           error: "Re-validation failed — candidate no longer passes gates"
         });
       }
-      const targetDir = path154.join(directory, ".opencode", "skills", "generated", sanitizedSlug);
-      const targetPath = path154.join(targetDir, "SKILL.md");
+      const targetDir = path155.join(directory, ".opencode", "skills", "generated", sanitizedSlug);
+      const targetPath = path155.join(targetDir, "SKILL.md");
       const timestamp = _internals92.getTimestamp();
       const alreadyExists = await _internals92.fileExists(targetPath);
       if (alreadyExists) {
@@ -130653,7 +131190,7 @@ var external_skill_promote = createSwarmTool({
         }
         throw writeErr;
       }
-      const promotedContentHash = createHash21("sha256").update(skillMarkdown).digest("hex");
+      const promotedContentHash = createHash22("sha256").update(skillMarkdown).digest("hex");
       const prePromotionHistory = candidate.evaluation_history;
       const lastPrePromotionEntry = prePromotionHistory.length > 0 ? prePromotionHistory[prePromotionHistory.length - 1] : undefined;
       const originalEvaluation = lastPrePromotionEntry ? {
@@ -130805,7 +131342,7 @@ var external_skill_reject = createSwarmTool({
 // src/tools/external-skill-revoke.ts
 init_zod();
 init_loader();
-import * as path155 from "node:path";
+import * as path156 from "node:path";
 init_create_tool();
 var _internals94 = {
   loadConfig: (directory) => {
@@ -130904,7 +131441,7 @@ var external_skill_revoke = createSwarmTool({
           error: "Cannot revoke: unable to determine the skill slug from promotion history. The candidate record may be corrupted. Manually remove the skill file from .opencode/skills/generated/ if needed."
         });
       }
-      const skillPath = path155.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
+      const skillPath = path156.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
       const skillFileRemoved = await _internals94.retireSkillFile(skillPath);
       const timestamp = _internals94.getTimestamp();
       const historyEntry = {
@@ -130937,7 +131474,7 @@ var external_skill_revoke = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs97 from "node:fs";
-import * as path156 from "node:path";
+import * as path157 from "node:path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -131018,12 +131555,12 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path156.join(targetDir, filename);
-      const base = path156.basename(filepath, path156.extname(filepath));
-      const ext = path156.extname(filepath);
+      let filepath = path157.join(targetDir, filename);
+      const base = path157.basename(filepath, path157.extname(filepath));
+      const ext = path157.extname(filepath);
       let counter = 1;
       while (fs97.existsSync(filepath)) {
-        filepath = path156.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path157.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -131377,7 +131914,7 @@ init_path_security();
 init_create_tool();
 import * as child_process12 from "node:child_process";
 import * as fs98 from "node:fs";
-import * as path157 from "node:path";
+import * as path158 from "node:path";
 var BLAME_TIMEOUT_MS = 30000;
 var MAX_OUTPUT_LINES2 = 500;
 var MAX_PATH_LENGTH2 = 500;
@@ -131435,7 +131972,7 @@ function validateFilePath(filePath) {
   if (filePath.length > MAX_PATH_LENGTH2) {
     return `file path exceeds maximum length of ${MAX_PATH_LENGTH2}`;
   }
-  if (path157.isAbsolute(filePath)) {
+  if (path158.isAbsolute(filePath)) {
     return "absolute paths are not allowed; use a relative path from the project root";
   }
   if (containsPathTraversal(filePath)) {
@@ -131464,7 +132001,7 @@ function validateLineNumber(value, name2) {
   return null;
 }
 function isBinaryFile2(filePath) {
-  const ext = path157.extname(filePath).toLowerCase();
+  const ext = path158.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function parsePorcelainBlame(output, linesCap) {
@@ -131611,7 +132148,7 @@ var git_blame = createSwarmTool({
         lines: []
       });
     }
-    const resolvedPath = path157.resolve(directory, file3);
+    const resolvedPath = path158.resolve(directory, file3);
     if (!fs98.existsSync(resolvedPath)) {
       return JSON.stringify({
         error: `file not found: ${file3}`,
@@ -131622,8 +132159,8 @@ var git_blame = createSwarmTool({
     }
     const realDir = fs98.realpathSync(directory);
     const realPath = fs98.realpathSync(resolvedPath);
-    const relative32 = path157.relative(realDir, realPath);
-    if (relative32.startsWith("..") || path157.isAbsolute(relative32)) {
+    const relative32 = path158.relative(realDir, realPath);
+    if (relative32.startsWith("..") || path158.isAbsolute(relative32)) {
       return JSON.stringify({
         error: "file path resolves outside the workspace",
         file: file3,
@@ -131975,7 +132512,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs99 from "node:fs";
-import * as path158 from "node:path";
+import * as path159 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
@@ -132023,7 +132560,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile3(filePath, buffer) {
-  const ext = path158.extname(filePath).toLowerCase();
+  const ext = path159.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -132047,15 +132584,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path158.resolve(targetFile);
+    _resolvedTarget = path159.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path158.basename(targetFile, path158.extname(targetFile));
+  const targetBasename = path159.basename(targetFile, path159.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path158.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path158.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path159.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path159.normalize(targetWithoutExt).replace(/\\/g, "/");
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
   for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
     const modulePath = match[1] || match[2] || match[3];
@@ -132078,9 +132615,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path158.dirname(targetFile);
-    const targetExt = path158.extname(targetFile);
-    const targetBasenameNoExt = path158.basename(targetFile, targetExt);
+    const _targetDir = path159.dirname(targetFile);
+    const targetExt = path159.extname(targetFile);
+    const targetBasenameNoExt = path159.basename(targetFile, targetExt);
     const moduleNormalized = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
     const moduleName = modulePath.split(/[/\\]/).pop() || "";
     const moduleNameNoExt = moduleName.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
@@ -132148,10 +132685,10 @@ function findSourceFiles2(dir, files = [], stats2 = { skippedDirs: [], skippedFi
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES5.has(entry)) {
-      stats2.skippedDirs.push(path158.join(dir, entry));
+      stats2.skippedDirs.push(path159.join(dir, entry));
       continue;
     }
-    const fullPath = path158.join(dir, entry);
+    const fullPath = path159.join(dir, entry);
     let stat14;
     try {
       stat14 = fs99.statSync(fullPath);
@@ -132165,7 +132702,7 @@ function findSourceFiles2(dir, files = [], stats2 = { skippedDirs: [], skippedFi
     if (stat14.isDirectory()) {
       findSourceFiles2(fullPath, files, stats2);
     } else if (stat14.isFile()) {
-      const ext = path158.extname(fullPath).toLowerCase();
+      const ext = path159.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -132222,7 +132759,7 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path158.resolve(file3);
+      const targetFile = path159.resolve(file3);
       if (!fs99.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
@@ -132244,7 +132781,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path158.dirname(targetFile);
+      const baseDir = path159.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -132660,7 +133197,7 @@ init_zod();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync89 } from "node:fs";
+import { existsSync as existsSync90 } from "node:fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -132736,14 +133273,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync89(swarmPath)) {
+  if (!existsSync90(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync89(hivePath)) {
+  if (!existsSync90(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -133193,11 +133730,11 @@ var lean_turbo_acquire_locks = createSwarmTool({
 init_zod();
 init_constants();
 import * as fs101 from "node:fs";
-import * as path160 from "node:path";
+import * as path161 from "node:path";
 
 // src/turbo/lean/conflicts.ts
 import * as fs100 from "node:fs";
-import * as path159 from "node:path";
+import * as path160 from "node:path";
 var DEFAULT_GLOBAL_FILES = [
   "package.json",
   "package-lock.json",
@@ -133324,7 +133861,7 @@ function isProtectedPath3(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path159.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path160.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
     if (!fs100.existsSync(scopePath)) {
       return null;
@@ -133712,7 +134249,7 @@ function createEmptyPlan(phaseNumber, planId) {
 // src/tools/lean-turbo-plan-lanes.ts
 init_create_tool();
 function readPlanJson(directory) {
-  const planPath = path160.join(directory, ".swarm", "plan.json");
+  const planPath = path161.join(directory, ".swarm", "plan.json");
   if (!fs101.existsSync(planPath)) {
     return null;
   }
@@ -134872,12 +135409,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs102 from "node:fs";
-import * as path162 from "node:path";
+import * as path163 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync12 } from "node:child_process";
-import { unlinkSync as unlinkSync19, writeFileSync as writeFileSync25 } from "node:fs";
-import * as path161 from "node:path";
+import { unlinkSync as unlinkSync20, writeFileSync as writeFileSync26 } from "node:fs";
+import * as path162 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -135040,7 +135577,7 @@ function validateTestCommand(testCommand) {
     return "testCommand must not be empty";
   }
   const exe = testCommand[0];
-  const base = path161.basename(exe).replace(/\.(exe|cmd|bat)$/i, "");
+  const base = path162.basename(exe).replace(/\.(exe|cmd|bat)$/i, "");
   if (!ALLOWED_TEST_RUNNERS.has(base)) {
     return `testCommand executable '${exe}' is not in the allowed test runner list. Permitted runners: ${[...ALLOWED_TEST_RUNNERS].join(", ")}`;
   }
@@ -135064,9 +135601,9 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path161.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path162.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
-      writeFileSync25(patchFile, patch.patch);
+      writeFileSync26(patchFile, patch.patch);
     } catch (writeErr) {
       error93 = `Failed to write patch file: ${writeErr}`;
       outcome = "error";
@@ -135164,7 +135701,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
         revertError = new Error(`Failed to revert mutation ${patch.id}: ${revertErr}. Working tree may be dirty.`);
       }
       try {
-        unlinkSync19(patchFile);
+        unlinkSync20(patchFile);
       } catch (_unlinkErr) {}
     }
   }
@@ -135481,7 +136018,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path162.resolve(cwd, filePath);
+          const resolvedPath = path163.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs102.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -135504,22 +136041,22 @@ init_schema();
 init_manager2();
 init_task_file();
 import * as fs112 from "node:fs";
-import * as path172 from "node:path";
+import * as path173 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state2();
 import * as fs103 from "node:fs";
-import * as path163 from "node:path";
+import * as path164 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path163.posix.join("evidence", String(phase)));
+    const dirPath = validateSwarmPath(directory, path164.posix.join("evidence", String(phase)));
     if (!fs103.existsSync(dirPath))
       return [];
     const entries = fs103.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path163.join(dirPath, e));
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path164.join(dirPath, e));
   } catch {
     return [];
   }
@@ -135774,16 +136311,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs104 from "node:fs";
-import * as path164 from "node:path";
+import * as path165 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path164.join(directory, ".swarm");
+    const swarmDir = path165.join(directory, ".swarm");
     fs104.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path164.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path164.join(swarmDir, "SWARM_PLAN.md");
+    const jsonPath = path165.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path165.join(swarmDir, "SWARM_PLAN.md");
     fs104.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs104.writeFileSync(mdPath, md, "utf8");
@@ -135803,7 +136340,7 @@ init_telemetry();
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
 import * as fs105 from "node:fs";
-import * as path165 from "node:path";
+import * as path166 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
   phase_reviewer: true,
@@ -135812,7 +136349,7 @@ var DEFAULT_CONFIG3 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path165.join(dir, ".swarm", "plan.json");
+    const planPath = path166.join(dir, ".swarm", "plan.json");
     if (!fs105.existsSync(planPath))
       return null;
     const raw = fs105.readFileSync(planPath, "utf-8");
@@ -135827,7 +136364,7 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path165.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    const evidencePath = path166.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
     if (!fs105.existsSync(evidencePath)) {
       return null;
     }
@@ -135847,7 +136384,7 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path165.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    const evidencePath = path166.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
     if (!fs105.existsSync(evidencePath)) {
       return null;
     }
@@ -135866,7 +136403,7 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path165.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path166.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
     entries = fs105.readdirSync(evidenceDir);
@@ -135936,7 +136473,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG3,
     ...actualConfig
   };
-  const statePath = path165.join(directory, ".swarm", "turbo-state.json");
+  const statePath = path166.join(directory, ".swarm", "turbo-state.json");
   if (!fs105.existsSync(statePath)) {
     return {
       ok: false,
@@ -136124,7 +136661,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path165.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path166.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
       const content = fs105.readFileSync(evidencePath, "utf-8");
@@ -136290,7 +136827,7 @@ async function runCompletionVerifyGate(ctx) {
 // src/tools/phase-complete/gates/drift-gate.ts
 init_effective_spec();
 import * as fs106 from "node:fs";
-import * as path166 from "node:path";
+import * as path167 from "node:path";
 
 // src/tools/phase-complete/gates/gate-helpers.ts
 init_qa_gate_profile();
@@ -136339,7 +136876,7 @@ async function runDriftGate(ctx) {
   }
   let phaseType;
   try {
-    const planPath = path166.join(dir, ".swarm", "plan.json");
+    const planPath = path167.join(dir, ".swarm", "plan.json");
     if (fs106.existsSync(planPath)) {
       const planRaw = fs106.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
@@ -136358,7 +136895,7 @@ async function runDriftGate(ctx) {
     };
   }
   try {
-    const driftEvidencePath = path166.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+    const driftEvidencePath = path167.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
     let driftVerdictFound = false;
     let driftVerdictApproved = false;
     try {
@@ -136399,7 +136936,7 @@ async function runDriftGate(ctx) {
         let incompleteTaskCount = 0;
         let planParseable = false;
         try {
-          const planPath = path166.join(dir, ".swarm", "plan.json");
+          const planPath = path167.join(dir, ".swarm", "plan.json");
           if (fs106.existsSync(planPath)) {
             const planRaw = fs106.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
@@ -136478,7 +137015,7 @@ async function runDriftGate(ctx) {
 }
 // src/tools/phase-complete/gates/final-council-gate.ts
 import * as fs107 from "node:fs";
-import * as path167 from "node:path";
+import * as path168 from "node:path";
 async function runFinalCouncilGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let finalCouncilEnabled = false;
@@ -136501,7 +137038,7 @@ async function runFinalCouncilGate(ctx) {
       if (lastPhaseId !== undefined && phase === lastPhaseId) {
         if (preamble.effectiveGates?.final_council === true) {
           finalCouncilEnabled = true;
-          const fcPath = path167.join(dir, ".swarm", "evidence", "final-council.json");
+          const fcPath = path168.join(dir, ".swarm", "evidence", "final-council.json");
           let fcVerdictFound = false;
           let _fcVerdict;
           try {
@@ -136655,13 +137192,13 @@ async function runFinalCouncilGate(ctx) {
 }
 // src/tools/phase-complete/gates/hallucination-gate.ts
 import * as fs108 from "node:fs";
-import * as path168 from "node:path";
+import * as path169 from "node:path";
 async function runHallucinationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.hallucination_guard === true) {
-      const hgPath = path168.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+      const hgPath = path169.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
       let hgVerdictFound = false;
       let hgVerdictApproved = false;
       try {
@@ -136719,13 +137256,13 @@ async function runHallucinationGate(ctx) {
 }
 // src/tools/phase-complete/gates/mutation-gate.ts
 import * as fs109 from "node:fs";
-import * as path169 from "node:path";
+import * as path170 from "node:path";
 async function runMutationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.mutation_test === true) {
-      const mgPath = path169.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+      const mgPath = path170.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
       let mgVerdictFound = false;
       let mgVerdict;
       try {
@@ -136783,7 +137320,7 @@ async function runMutationGate(ctx) {
 }
 // src/tools/phase-complete/gates/phase-council-gate.ts
 import * as fs110 from "node:fs";
-import * as path170 from "node:path";
+import * as path171 from "node:path";
 async function runPhaseCouncilGate(ctx) {
   const { phase, dir, sessionID, pluginConfig, agentsDispatched, safeWarn } = ctx;
   const gateWarnings = [];
@@ -136792,7 +137329,7 @@ async function runPhaseCouncilGate(ctx) {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.phase_council === true && pluginConfig.council?.enabled === true) {
       councilModeEnabled = true;
-      const pcPath = path170.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+      const pcPath = path171.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
       let pcVerdictFound = false;
       let _pcVerdict;
       let pcQuorumSize;
@@ -137359,7 +137896,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path172.basename(dir);
+      const projectName = path173.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig, {
         llmDelegate: createCuratorLLMDelegate(dir, "phase", sessionID),
         enrichmentQuota: {
@@ -137921,7 +138458,7 @@ init_utils();
 init_bun_compat();
 init_create_tool();
 import * as fs113 from "node:fs";
-import * as path173 from "node:path";
+import * as path174 from "node:path";
 var MAX_OUTPUT_BYTES7 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -137949,16 +138486,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs113.existsSync(path173.join(cwd, "package.json"))) {
+  if (fs113.existsSync(path174.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs113.existsSync(path173.join(cwd, "pyproject.toml")) || fs113.existsSync(path173.join(cwd, "requirements.txt"))) {
+  if (fs113.existsSync(path174.join(cwd, "pyproject.toml")) || fs113.existsSync(path174.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs113.existsSync(path173.join(cwd, "Cargo.toml"))) {
+  if (fs113.existsSync(path174.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs113.existsSync(path173.join(cwd, "go.mod"))) {
+  if (fs113.existsSync(path174.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -137967,13 +138504,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs113.existsSync(path173.join(cwd, "Gemfile")) || fs113.existsSync(path173.join(cwd, "Gemfile.lock"))) {
+  if (fs113.existsSync(path174.join(cwd, "Gemfile")) || fs113.existsSync(path174.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs113.existsSync(path173.join(cwd, "pubspec.yaml"))) {
+  if (fs113.existsSync(path174.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs113.existsSync(path173.join(cwd, "composer.lock"))) {
+  if (fs113.existsSync(path174.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -139110,7 +139647,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs114 from "node:fs";
-import * as path174 from "node:path";
+import * as path175 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -139233,7 +139770,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path174.basename(filePath);
+  const filename = path175.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -139250,7 +139787,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path174.basename(filePath);
+    const filename = path175.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -139259,7 +139796,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path174.extname(filePath).toLowerCase();
+  const ext = path175.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -139506,9 +140043,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path174.isAbsolute(filePath) ? filePath : path174.resolve(directory, filePath);
-    const resolvedDirectory = path174.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path174.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path175.isAbsolute(filePath) ? filePath : path175.resolve(directory, filePath);
+    const resolvedDirectory = path175.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path175.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs114.existsSync(fullPath)) {
@@ -139517,7 +140054,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path174.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path175.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -139590,7 +140127,7 @@ var placeholder_scan = createSwarmTool({
 
 // src/tools/pre-check-batch.ts
 import * as fs118 from "node:fs";
-import * as path178 from "node:path";
+import * as path179 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -139731,7 +140268,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs117 from "node:fs";
-import * as path177 from "node:path";
+import * as path178 from "node:path";
 import { extname as extname19 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -140441,7 +140978,7 @@ function executeRulesSync(filePath, content, language) {
 // src/sast/semgrep.ts
 import * as child_process13 from "node:child_process";
 import * as fs115 from "node:fs";
-import * as path175 from "node:path";
+import * as path176 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS4 = 30000;
@@ -140728,7 +141265,7 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path175.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path176.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
@@ -140749,24 +141286,24 @@ init_create_tool();
 init_utils2();
 import * as crypto12 from "node:crypto";
 import * as fs116 from "node:fs";
-import * as path176 from "node:path";
+import * as path177 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
 var MAX_BASELINE_BYTES = 2 * 1048576;
 var LOCK_RETRY_DELAYS_MS = [50, 100, 200, 400, 800];
 function normalizeFindingPath(directory, file3) {
-  const resolved = path176.isAbsolute(file3) ? file3 : path176.resolve(directory, file3);
-  const rel = path176.relative(path176.resolve(directory), resolved);
+  const resolved = path177.isAbsolute(file3) ? file3 : path177.resolve(directory, file3);
+  const rel = path177.relative(path177.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path176.join("evidence", String(phase), "sast-baseline.json");
+  return path177.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path176.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path177.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path176.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path177.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -140887,8 +141424,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs116.mkdirSync(path176.dirname(baselinePath), { recursive: true });
-  fs116.mkdirSync(path176.dirname(tempPath), { recursive: true });
+  fs116.mkdirSync(path177.dirname(baselinePath), { recursive: true });
+  fs116.mkdirSync(path177.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
@@ -141161,9 +141698,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path177.isAbsolute(filePath) ? filePath : path177.resolve(directory, filePath);
-    const resolvedDirectory = path177.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path177.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path178.isAbsolute(filePath) ? filePath : path178.resolve(directory, filePath);
+    const resolvedDirectory = path178.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path178.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -141478,18 +142015,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path178.win32.resolve(inputPath);
-  } else if (path178.isAbsolute(inputPath)) {
-    resolved = path178.resolve(inputPath);
+    resolved = path179.win32.resolve(inputPath);
+  } else if (path179.isAbsolute(inputPath)) {
+    resolved = path179.resolve(inputPath);
   } else {
-    resolved = path178.resolve(baseDir, inputPath);
+    resolved = path179.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path178.resolve(workspaceDir);
+  const workspaceResolved = path179.resolve(workspaceDir);
   let relative36;
   if (isWinAbs) {
-    relative36 = path178.win32.relative(workspaceResolved, resolved);
+    relative36 = path179.win32.relative(workspaceResolved, resolved);
   } else {
-    relative36 = path178.relative(workspaceResolved, resolved);
+    relative36 = path179.relative(workspaceResolved, resolved);
   }
   if (relative36.startsWith("..")) {
     return "path traversal detected";
@@ -141554,7 +142091,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path178.resolve(file3);
+    const resolvedPath = path179.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -141711,7 +142248,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path178.resolve(file3);
+      const resolvedPath = path179.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -141729,7 +142266,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path178.extname(file3).toLowerCase();
+      const ext = path179.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -141948,7 +142485,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path178.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path179.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -141999,7 +142536,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path178.resolve(directory, file3));
+    changedFiles.push(path179.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -142200,9 +142737,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path178.resolve(typedArgs.directory);
-    const workspaceAnchor = path178.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path178.sep)) {
+    const resolvedDirectory = path179.resolve(typedArgs.directory);
+    const workspaceAnchor = path179.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path179.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -142256,7 +142793,7 @@ var pre_check_batch = createSwarmTool({
 init_zod();
 init_path_security();
 init_create_tool();
-import * as path179 from "node:path";
+import * as path180 from "node:path";
 var VALID_ACTIONS = [
   "build",
   "importers",
@@ -142266,7 +142803,9 @@ var VALID_ACTIONS = [
   "key_files",
   "ontology",
   "package_boundaries",
-  "preflight_packet"
+  "preflight_packet",
+  "callers",
+  "dead_exports"
 ];
 var MAX_FILE_PATH_LENGTH3 = 500;
 var MAX_SYMBOL_LENGTH2 = 256;
@@ -142282,7 +142821,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path179.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path180.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -142305,8 +142844,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path179.isAbsolute(normalized)) {
-    const rel = path179.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path180.isAbsolute(normalized)) {
+    const rel = path180.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath(rel);
   }
   return normalizeGraphPath(normalized);
@@ -142330,7 +142869,7 @@ async function loadOrError(directory, action) {
   }
 }
 var repo_map = createSwarmTool({
-  description: "Query the repository code graph for structural awareness before editing. " + 'Actions: "build" (build/refresh .swarm/repo-graph.json), "importers" (who imports a file), ' + '"dependencies" (what a file imports), "blast_radius" (transitive dependents + risk), ' + '"localization" (compact context block for a target file), "key_files" (top-N most-imported files), ' + '"ontology" (file roles/routes/data/security/findings), "package_boundaries" (inferred package/layer boundaries), ' + '"preflight_packet" (bounded ontology packet for planning). ' + "Use this before refactoring shared modules to avoid breaking unseen consumers.",
+  description: "Query the repository code graph for structural awareness before editing. " + 'Actions: "build" (build/refresh .swarm/repo-graph.json), "importers" (who imports a file), ' + '"dependencies" (what a file imports), "blast_radius" (transitive dependents + risk), ' + '"localization" (compact context block for a target file), "key_files" (top-N most-imported files), ' + '"ontology" (file roles/routes/data/security/findings), "package_boundaries" (inferred package/layer boundaries), ' + '"preflight_packet" (bounded ontology packet for planning), ' + '"callers" (files that reference an exported symbol, call-site granularity; needs file+symbol), ' + '"dead_exports" (advisory: exported symbols with no detected in-repo reference). ' + "Use this before refactoring shared modules to avoid breaking unseen consumers. " + 'Note: "callers"/"dead_exports" use conservative regex analysis (TS/JS/Python) and cannot see ' + 'dynamic dispatch or namespace/barrel re-export usage; "dead_exports" results are review candidates, not delete directives.',
   args: {
     action: exports_external.enum([
       "build",
@@ -142341,12 +142880,14 @@ var repo_map = createSwarmTool({
       "key_files",
       "ontology",
       "package_boundaries",
-      "preflight_packet"
-    ]).describe('Query action: "build" | "importers" | "dependencies" | "blast_radius" | "localization" | "key_files" | "ontology" | "package_boundaries" | "preflight_packet"'),
+      "preflight_packet",
+      "callers",
+      "dead_exports"
+    ]).describe('Query action: "build" | "importers" | "dependencies" | "blast_radius" | "localization" | "key_files" | "ontology" | "package_boundaries" | "preflight_packet" | "callers" | "dead_exports"'),
     file: exports_external.string().optional().describe("Target file (workspace-relative or absolute). Required for importers/dependencies/localization/ontology. Optional for preflight_packet."),
     files: exports_external.array(exports_external.string()).optional().describe("Multiple target files for blast_radius/preflight_packet. If omitted, falls back to `file`."),
-    symbol: exports_external.string().optional().describe('When provided alongside `file` on action="importers", restrict to consumers of this exported symbol.'),
-    top_n: exports_external.number().int().min(1).max(100).optional().describe('For action="key_files" or "package_boundaries": number of entries to return (default 10).'),
+    symbol: exports_external.string().optional().describe('Exported symbol name. Restricts consumers on action="importers"; required for action="callers".'),
+    top_n: exports_external.number().int().min(1).max(100).optional().describe('For action="key_files"/"package_boundaries": entries to return (default 10). For action="dead_exports": max candidates (default 100).'),
     max_depth: exports_external.number().int().min(1).max(10).optional().describe('For action="blast_radius": max BFS depth (default 3).')
   },
   async execute(args2, directory, _ctx) {
@@ -142408,6 +142949,10 @@ var repo_map = createSwarmTool({
         stale
       });
     }
+    if (action === "dead_exports") {
+      const result = getDeadExports(graph, { maxCandidates: a.top_n ?? 100 });
+      return ok(action, { ...result, stale });
+    }
     if (action === "preflight_packet") {
       const inputs = a.files && a.files.length > 0 ? a.files : a.file ? [a.file] : [];
       for (const f of inputs) {
@@ -142467,6 +143012,22 @@ var repo_map = createSwarmTool({
         stale
       });
     }
+    if (action === "callers") {
+      if (a.symbol === undefined) {
+        return err2(action, "callers requires `symbol` (the exported name)");
+      }
+      const sErr = validateSymbol(a.symbol);
+      if (sErr)
+        return err2(action, `invalid symbol: ${sErr}`);
+      const callers = getCallers(graph, target, a.symbol);
+      return ok(action, {
+        target,
+        symbol: a.symbol,
+        count: callers.length,
+        callers,
+        stale
+      });
+    }
     if (action === "dependencies") {
       const deps = getDependencies(graph, target);
       return ok(action, {
@@ -142498,7 +143059,7 @@ init_zod();
 init_effective_spec();
 init_create_tool();
 import * as fs119 from "node:fs";
-import * as path180 from "node:path";
+import * as path181 from "node:path";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHOULD", "SHALL"];
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
@@ -142566,7 +143127,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path180.join(evidenceDir, entry);
+    const entryPath = path181.join(evidenceDir, entry);
     try {
       const stat14 = fs119.statSync(entryPath);
       if (!stat14.isDirectory()) {
@@ -142582,11 +143143,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path180.join(entryPath, "evidence.json");
+    const evidenceFilePath = path181.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path180.resolve(evidenceFilePath);
-      const evidenceDirResolved = path180.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path180.sep)) {
+      const resolvedPath = path181.resolve(evidenceFilePath);
+      const evidenceDirResolved = path181.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path181.sep)) {
         continue;
       }
       const stat14 = fs119.lstatSync(evidenceFilePath);
@@ -142620,7 +143181,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
             if (Array.isArray(diffEntry.files_changed)) {
               for (const file3 of diffEntry.files_changed) {
                 if (typeof file3 === "string") {
-                  touchedFiles.add(path180.resolve(cwd, file3));
+                  touchedFiles.add(path181.resolve(cwd, file3));
                 }
               }
             }
@@ -142633,8 +143194,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path180.resolve(filePath);
-    const cwdResolved = path180.resolve(cwd);
+    const resolvedPath = path181.resolve(filePath);
+    const cwdResolved = path181.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -142793,7 +143354,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path180.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path181.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -142819,7 +143380,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path180.join(evidenceDir, reportFilename);
+    const reportPath = path181.join(evidenceDir, reportFilename);
     try {
       if (!fs119.existsSync(evidenceDir)) {
         fs119.mkdirSync(evidenceDir, { recursive: true });
@@ -142832,6 +143393,72 @@ var req_coverage = createSwarmTool({
   }
 });
 
+// src/tools/retrieve-lane-output.ts
+init_zod();
+init_create_tool();
+var RetrieveLaneOutputArgsSchema = exports_external.object({
+  ref: exports_external.string().min(1).describe("Opaque lane output ref returned as output_ref by dispatch tools."),
+  offset: exports_external.number().int().min(0).default(0).describe("Line offset to start from."),
+  limit: exports_external.number().int().min(1).max(500).default(100).describe("Number of lines to return, max 500.")
+});
+var retrieve_lane_output = createSwarmTool({
+  description: "Retrieve paged full output for a dispatch_lanes or collect_lane_results lane by output_ref. Use when a lane preview is truncated, degraded, or needs candidate routing from full text.",
+  args: {
+    ref: RetrieveLaneOutputArgsSchema.shape.ref,
+    offset: RetrieveLaneOutputArgsSchema.shape.offset,
+    limit: RetrieveLaneOutputArgsSchema.shape.limit
+  },
+  async execute(args2, directory) {
+    const parsed = RetrieveLaneOutputArgsSchema.safeParse(args2);
+    if (!parsed.success) {
+      return JSON.stringify({
+        success: false,
+        failure_class: "invalid_args",
+        message: "Invalid retrieve_lane_output arguments",
+        errors: parsed.error.issues.map((issue3) => `${issue3.path.join(".")}: ${issue3.message}`)
+      }, null, 2);
+    }
+    let loaded;
+    try {
+      loaded = readLaneOutput(directory, parsed.data.ref);
+    } catch {
+      loaded = null;
+    }
+    if (!loaded) {
+      return JSON.stringify({
+        success: false,
+        failure_class: "not_found",
+        message: `No lane output artifact found for ${parsed.data.ref}`
+      }, null, 2);
+    }
+    const page = paginateLaneOutput(loaded.artifact.text, parsed.data.offset, Math.min(parsed.data.limit, 500));
+    if (page.exhausted) {
+      return `--- Lane output ${loaded.artifact.ref} offset beyond range ---
+` + `Lane: ${loaded.artifact.laneId} (${loaded.artifact.agent})
+` + `Digest: ${loaded.artifact.digest}
+` + `Content has ${page.totalLines} line${page.totalLines === 1 ? "" : "s"}.`;
+    }
+    const header = `--- Lane output ${loaded.artifact.ref} lines ${page.startLine + 1}-${page.endLine} of ${page.totalLines} ---
+` + `Batch: ${loaded.artifact.batchId}
+` + `Lane: ${loaded.artifact.laneId}
+` + `Agent: ${loaded.artifact.agent}
+` + `Source: ${loaded.artifact.source}
+` + `Digest: ${loaded.artifact.digest}
+` + `Chars: ${loaded.artifact.chars}
+` + (loaded.artifact.transcriptIncomplete ? `Warning: transcript may be incomplete because the session message fetch hit its limit.
+` : "");
+    let response = `${header}
+${page.content}`;
+    if (page.endLine < page.totalLines) {
+      const remaining = page.totalLines - page.endLine;
+      response += `
+
+... ${remaining} more line${remaining === 1 ? "" : "s"}. Use offset=${page.endLine} to retrieve more.`;
+    }
+    return response;
+  }
+});
+
 // src/tools/retrieve-summary.ts
 init_zod();
 init_manager4();
@@ -142908,7 +143535,7 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as fs120 from "node:fs";
-import * as path181 from "node:path";
+import * as path182 from "node:path";
 init_ledger();
 init_manager();
 init_effective_spec();
@@ -142990,8 +143617,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path181.resolve(args2.working_directory);
-    const resolvedRoot = path181.resolve(fallbackDir);
+    const resolvedTarget = path182.resolve(args2.working_directory);
+    const resolvedRoot = path182.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs120.accessSync(resolvedRoot, fs120.constants.F_OK);
@@ -143000,7 +143627,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path181.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path182.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -143031,7 +143658,7 @@ async function executeSavePlan(args2, fallbackDir) {
     specHash = spec.hash;
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path181.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path182.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs120.promises.readFile(contextPath, "utf8");
@@ -143321,7 +143948,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path181.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path182.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -143344,7 +143971,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path181.join(dir, ".swarm", "plan.json"),
+        plan_path: path182.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -143412,7 +144039,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs121 from "node:fs";
-import * as path182 from "node:path";
+import * as path183 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -144262,7 +144889,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs121.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path182.join(dir, entry.name);
+        const fullPath = path183.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -144271,7 +144898,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path182.relative(rootDir, fullPath));
+              manifestFiles.push(path183.relative(rootDir, fullPath));
               break;
             }
           }
@@ -144289,11 +144916,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs121.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path182.join(dir, entry.name);
+        const fullPath = path183.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path182.relative(workingDir, fullPath));
+              found.push(path183.relative(workingDir, fullPath));
               break;
             }
           }
@@ -144306,11 +144933,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path182.dirname(file3);
+    let currentDir = path183.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path182.sep) {
-        dirs.add(path182.join(workingDir, currentDir));
-        const parent = path182.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path183.sep) {
+        dirs.add(path183.join(workingDir, currentDir));
+        const parent = path183.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -144394,7 +145021,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path182.isAbsolute(relativeOutputDir) ? relativeOutputDir : path182.join(workingDir, relativeOutputDir);
+    const outputDir = path183.isAbsolute(relativeOutputDir) ? relativeOutputDir : path183.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -144417,7 +145044,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path182.isAbsolute(manifestFile) ? manifestFile : path182.join(workingDir, manifestFile);
+        const fullPath = path183.isAbsolute(manifestFile) ? manifestFile : path183.join(workingDir, manifestFile);
         if (!fs121.existsSync(fullPath)) {
           continue;
         }
@@ -144434,7 +145061,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path182.join(outputDir, filename);
+    const outputPath = path183.join(outputDir, filename);
     fs121.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -144479,7 +145106,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs122 from "node:fs";
-import * as path183 from "node:path";
+import * as path184 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -144511,12 +145138,12 @@ function normalizePath5(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path183.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path183.sep) ? cwd : cwd + path183.sep;
+    const resolvedPath = path184.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path184.sep) ? cwd : cwd + path184.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path183.extname(resolvedPath).toLowerCase();
+    const ext = path184.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -144530,7 +145157,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path183.resolve(cwd, candidate);
+    const candidatePath = path184.resolve(cwd, candidate);
     if (fs122.existsSync(candidatePath)) {
       const stats2 = fs122.statSync(candidatePath);
       if (stats2.size <= MAX_SPEC_SIZE) {
@@ -144542,7 +145169,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs122.readFileSync(specFile, "utf-8");
-  const ext = path183.extname(specFile).toLowerCase();
+  const ext = path184.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -144618,7 +145245,7 @@ function extractRoutes2(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path183.join(dir, entry.name);
+      const fullPath = path184.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -144628,7 +145255,7 @@ function extractRoutes2(cwd) {
         }
         walkDir2(fullPath);
       } else if (entry.isFile()) {
-        const ext = path183.extname(entry.name).toLowerCase();
+        const ext = path184.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -144797,7 +145424,7 @@ init_bun_compat();
 init_path_security();
 init_create_tool();
 import * as fs123 from "node:fs";
-import * as path184 from "node:path";
+import * as path185 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -144833,11 +145460,11 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path184.resolve(workspace, filePath);
+    const resolvedPath = path185.resolve(workspace, filePath);
     const realWorkspace = fs123.realpathSync(workspace);
     const realResolvedPath = fs123.realpathSync(resolvedPath);
-    const relativePath = path184.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path184.isAbsolute(relativePath)) {
+    const relativePath = path185.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path185.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -144850,11 +145477,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path184.delimiter)) {
+  for (const dir of searchPath.split(path185.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path184.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path185.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs123.existsSync(candidate))
       return candidate;
   }
@@ -144984,8 +145611,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs123.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path184.join(dir, entry.name);
-      const relativePath = path184.relative(workspace, fullPath);
+      const fullPath = path185.join(dir, entry.name);
+      const relativePath = path185.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -145026,7 +145653,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path184.join(opts.workspace, file3);
+    const fullPath = path185.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -145458,7 +146085,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir33, rename as rename14, writeFile as writeFile23 } from "node:fs/promises";
-import * as path185 from "node:path";
+import * as path186 from "node:path";
 var MAX_SPEC_BYTES2 = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -145499,8 +146126,8 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path185.join(directory, ".swarm", "spec.md");
-    await mkdir33(path185.dirname(target), { recursive: true });
+    const target = path186.join(directory, ".swarm", "spec.md");
+    await mkdir33(path186.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -145529,14 +146156,14 @@ ${content}
 init_zod();
 init_loader();
 import {
-  existsSync as existsSync104,
-  mkdirSync as mkdirSync42,
-  readFileSync as readFileSync82,
-  renameSync as renameSync24,
-  unlinkSync as unlinkSync21,
-  writeFileSync as writeFileSync31
+  existsSync as existsSync105,
+  mkdirSync as mkdirSync43,
+  readFileSync as readFileSync83,
+  renameSync as renameSync25,
+  unlinkSync as unlinkSync22,
+  writeFileSync as writeFileSync32
 } from "node:fs";
-import path186 from "node:path";
+import path187 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -145703,9 +146330,9 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path186.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path187.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
-    const raw = readFileSync82(mutationGatePath, "utf-8");
+    const raw = readFileSync83(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
     const gateEntry = (parsed.entries ?? []).find((entry) => entry?.type === "mutation-gate");
     if (!gateEntry) {
@@ -145765,9 +146392,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
-  const evidenceDir = path186.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
-  mkdirSync42(evidenceDir, { recursive: true });
-  const evidenceFile = path186.join(evidenceDir, "phase-council.json");
+  const evidenceDir = path187.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  mkdirSync43(evidenceDir, { recursive: true });
+  const evidenceFile = path187.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -145801,11 +146428,11 @@ function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
   };
   const tempFile = `${evidenceFile}.tmp-${Date.now()}`;
   try {
-    writeFileSync31(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
-    renameSync24(tempFile, evidenceFile);
+    writeFileSync32(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
+    renameSync25(tempFile, evidenceFile);
   } finally {
-    if (existsSync104(tempFile)) {
-      unlinkSync21(tempFile);
+    if (existsSync105(tempFile)) {
+      unlinkSync22(tempFile);
     }
   }
 }
@@ -145830,7 +146457,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs124 from "node:fs";
-import * as path187 from "node:path";
+import * as path188 from "node:path";
 var BINARY_EXTENSIONS2 = new Set([
   ".png",
   ".jpg",
@@ -145866,14 +146493,14 @@ function containsWindowsAttacks5(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path187.resolve(workspace, filePath);
+    const resolvedPath = path188.resolve(workspace, filePath);
     if (!fs124.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs124.realpathSync(workspace);
     const realResolvedPath = fs124.realpathSync(resolvedPath);
-    const relativePath = path187.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path187.isAbsolute(relativePath)) {
+    const relativePath = path188.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path188.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -145988,7 +146615,7 @@ function arraysEqual2(a, b) {
   return true;
 }
 function isBinaryFile4(filePath) {
-  const ext = path187.extname(filePath).toLowerCase();
+  const ext = path188.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS2.has(ext);
 }
 function splitDiffLines(content) {
@@ -146193,7 +146820,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path187.resolve(directory, change.file);
+      const fullPath = path188.resolve(directory, change.file);
       if (!fs124.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -146288,7 +146915,7 @@ var suggestPatch = createSwarmTool({
         const unifiedParts = [];
         for (const [file3, entries] of fileGroups) {
           entries.sort((a, b) => a.contextMatch.startLineIndex - b.contextMatch.startLineIndex);
-          const entryFullPath = path187.resolve(directory, file3);
+          const entryFullPath = path188.resolve(directory, file3);
           let entryContent;
           try {
             entryContent = fs124.readFileSync(entryFullPath, "utf-8");
@@ -146630,7 +147257,7 @@ function getContextAgent4(ctx) {
 
 // src/tools/syntax-check.ts
 import * as fs125 from "node:fs";
-import * as path188 from "node:path";
+import * as path189 from "node:path";
 init_zod();
 init_manager2();
 init_detector();
@@ -146702,7 +147329,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path188.extname(file3.path).toLowerCase();
+      const ext = path189.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -146712,7 +147339,7 @@ async function syntaxCheck(input, directory, config3) {
   const { loadGrammar: loadGrammar2 } = await Promise.resolve().then(() => (init_runtime(), exports_runtime));
   async function checkOneFile(fileInfo) {
     const { path: filePath } = fileInfo;
-    const fullPath = path188.isAbsolute(filePath) ? filePath : path188.join(directory, filePath);
+    const fullPath = path189.isAbsolute(filePath) ? filePath : path189.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -146759,7 +147386,7 @@ async function syntaxCheck(input, directory, config3) {
         result.skipped_reason = "binary_file";
         return { result, counted: false, failed: false, skipped: true };
       }
-      const ext = path188.extname(filePath).toLowerCase();
+      const ext = path189.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -146871,7 +147498,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs126 from "node:fs";
-import * as path189 from "node:path";
+import * as path190 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES10 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -146937,9 +147564,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path189.resolve(paths);
-    const normalizedCwd = path189.resolve(cwd);
-    const normalizedResolved = path189.resolve(resolvedPath);
+    const resolvedPath = path190.resolve(paths);
+    const normalizedCwd = path190.resolve(cwd);
+    const normalizedResolved = path190.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -146955,7 +147582,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path189.extname(filePath).toLowerCase();
+  const ext = path190.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
@@ -146970,7 +147597,7 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES6.has(entry)) {
       continue;
     }
-    const fullPath = path189.join(dir, entry);
+    const fullPath = path190.join(dir, entry);
     let stat14;
     try {
       stat14 = fs126.statSync(fullPath);
@@ -147082,7 +147709,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path189.extname(scanPath)}`,
+          error: `unsupported file extension: ${path190.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -147132,17 +147759,17 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs130 from "node:fs";
-import * as path193 from "node:path";
+import * as path194 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
 import * as fs128 from "node:fs";
-import * as path191 from "node:path";
+import * as path192 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs127 from "node:fs";
-import * as path190 from "node:path";
+import * as path191 from "node:path";
 var _internals108 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
@@ -147216,10 +147843,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path190.isAbsolute(excludeRelPath) ? excludeRelPath : path190.join(directory, excludeRelPath);
+    const excludePath = path191.isAbsolute(excludeRelPath) ? excludeRelPath : path191.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs127.mkdirSync(path190.dirname(excludePath), { recursive: true });
+        fs127.mkdirSync(path191.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
           existing = fs127.readFileSync(excludePath, "utf8");
@@ -147263,7 +147890,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 var _internals109 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path191.join(directory, ".swarm", "plan.json");
+    const planPath = path192.join(directory, ".swarm", "plan.json");
     if (!fs128.existsSync(planPath))
       return null;
     const raw = fs128.readFileSync(planPath, "utf-8");
@@ -147369,7 +147996,7 @@ init_telemetry();
 // src/turbo/lean/task-completion.ts
 init_file_locks();
 import * as fs129 from "node:fs";
-import * as path192 from "node:path";
+import * as path193 from "node:path";
 var _internals110 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
@@ -147388,7 +148015,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path192.basename(file3);
+    const fileName = path193.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -147400,7 +148027,7 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path192.join(directory, ".swarm", "turbo-state.json");
+    const statePath = path193.join(directory, ".swarm", "turbo-state.json");
     if (!fs129.existsSync(statePath)) {
       return {
         ok: false,
@@ -147484,11 +148111,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path192.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path192.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path192.resolve(evidencePath);
-  const resolvedDir = path192.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path192.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path193.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path193.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path193.resolve(evidencePath);
+  const resolvedDir = path193.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path193.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -147528,7 +148155,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path192.join(directory, ".swarm", "plan.json");
+    const planPath = path193.join(directory, ".swarm", "plan.json");
     const planRaw = fs129.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
@@ -147617,7 +148244,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path193.basename(file3);
+    const fileName = path194.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -147656,7 +148283,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path193.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path194.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs130.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -147734,7 +148361,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path193.join(resolvedDir, ".swarm", "plan.json");
+        const planPath = path194.join(resolvedDir, ".swarm", "plan.json");
         const planRaw = fs130.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -147945,7 +148572,7 @@ function checkCouncilGate(workingDirectory, taskId) {
     return { blocked: false, reason: "", active: false };
   }
   try {
-    const planPath = path193.join(workingDirectory, ".swarm", "plan.json");
+    const planPath = path194.join(workingDirectory, ".swarm", "plan.json");
     const planRaw = fs130.readFileSync(planPath, "utf-8");
     const planObj = JSON.parse(planRaw);
     if (planObj.swarm && planObj.title) {
@@ -148032,7 +148659,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   directory = resolveResult.directory;
-  const planPath = path193.join(directory, ".swarm", "plan.json");
+  const planPath = path194.join(directory, ".swarm", "plan.json");
   if (!fs130.existsSync(planPath)) {
     return {
       success: false,
@@ -148041,9 +148668,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs130.realpathSync(path193.resolve(directory));
-    const canonicalRoot = fs130.realpathSync(path193.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path193.sep)) {
+    const canonicalDir = fs130.realpathSync(path194.resolve(directory));
+    const canonicalRoot = fs130.realpathSync(path194.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path194.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -148055,8 +148682,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path193.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs130.mkdirSync(path193.dirname(evidencePath), { recursive: true });
+      const evidencePath = path194.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs130.mkdirSync(path194.dirname(evidencePath), { recursive: true });
       const fd = fs130.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -148080,7 +148707,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath2 = path193.join(directory, ".swarm", "plan.json");
+      const planPath2 = path194.join(directory, ".swarm", "plan.json");
       const planRaw = fs130.readFileSync(planPath2, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -148197,9 +148824,9 @@ import * as zlib from "node:zlib";
 // src/evidence/documents.ts
 init_utils2();
 init_redaction();
-import { createHash as createHash23 } from "node:crypto";
+import { createHash as createHash24 } from "node:crypto";
 import { appendFile as appendFile17, mkdir as mkdir34 } from "node:fs/promises";
-import * as path194 from "node:path";
+import * as path195 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
 async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
@@ -148207,7 +148834,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir34(path194.dirname(filePath), { recursive: true });
+    await mkdir34(path195.dirname(filePath), { recursive: true });
     await appendFile17(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -148241,7 +148868,7 @@ function createEvidenceDocumentRecord(input, defaultCapturedAt) {
   };
 }
 function createEvidenceDocumentId(input) {
-  const hash4 = createHash23("sha256").update([
+  const hash4 = createHash24("sha256").update([
     input.sourceType,
     input.query ?? "",
     input.title ?? "",
@@ -149224,7 +149851,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path195 from "node:path";
+import * as path196 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -149300,7 +149927,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
       if (config3.architectural_supervision?.persist_knowledge_recommendations && args2.knowledge_recommendations.length > 0) {
         const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
         const lessons = args2.knowledge_recommendations.map((r) => r.lesson);
-        const result = await curateAndStoreSwarm(lessons, path195.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
+        const result = await curateAndStoreSwarm(lessons, path196.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
           skipAutoPromotion: true,
           llmDelegate: createCuratorLLMDelegate(dirResult.directory, "phase"),
           enrichmentQuota: {
@@ -149347,7 +149974,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs131 from "node:fs";
-import path196 from "node:path";
+import path197 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -149401,7 +150028,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path196.join("evidence", String(phase), filename);
+  const relativePath = path197.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -149412,10 +150039,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path196.dirname(validatedPath);
+  const evidenceDir = path197.dirname(validatedPath);
   try {
     await fs131.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path196.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path197.join(evidenceDir, `.${filename}.tmp`);
     await fs131.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs131.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -149516,7 +150143,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs132 from "node:fs";
-import path197 from "node:path";
+import path198 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -149630,7 +150257,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path197.join("evidence", filename);
+  const relativePath = path198.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -149644,10 +150271,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path197.dirname(validatedPath);
+  const evidenceDir = path198.dirname(validatedPath);
   try {
     await fs132.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path197.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path198.join(evidenceDir, `.${filename}.tmp`);
     await fs132.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs132.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -149707,7 +150334,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs133 from "node:fs";
-import path198 from "node:path";
+import path199 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -149755,7 +150382,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path198.join("evidence", String(phase), filename);
+  const relativePath = path199.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -149766,10 +150393,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path198.dirname(validatedPath);
+  const evidenceDir = path199.dirname(validatedPath);
   try {
     await fs133.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path198.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path199.join(evidenceDir, `.${filename}.tmp`);
     await fs133.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs133.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -149819,7 +150446,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs134 from "node:fs";
-import path199 from "node:path";
+import path200 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -149893,7 +150520,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path199.join("evidence", String(phase), filename);
+  const relativePath = path200.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -149904,10 +150531,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path199.dirname(validatedPath);
+  const evidenceDir = path200.dirname(validatedPath);
   try {
     await fs134.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path199.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path200.join(evidenceDir, `.${filename}.tmp`);
     await fs134.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs134.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -149994,6 +150621,7 @@ var TOOL_MANIFEST = defineHandlers({
   git_blame: () => git_blame,
   gitingest: () => gitingest,
   retrieve_summary: () => retrieve_summary,
+  retrieve_lane_output: () => retrieve_lane_output,
   extract_code_blocks: () => extract_code_blocks,
   phase_complete: () => phase_complete,
   save_plan: () => save_plan,
@@ -150117,7 +150745,7 @@ ${footerLines.join(`
 init_warning_buffer();
 var _heartbeatTimers = new Map;
 var SWARM_COMMAND_SYSTEM_RULE_TAG = "[opencode-swarm:swarm-command-rule]";
-var PACKAGE_ROOT2 = path201.resolve(path201.dirname(fileURLToPath5(import.meta.url)), "..");
+var PACKAGE_ROOT2 = path202.resolve(path202.dirname(fileURLToPath5(import.meta.url)), "..");
 var SYNC_BUNDLED_SKILLS_TIMEOUT_MS = 2000;
 function createSwarmCommandSystemRuleHook(agentDefinitions, registeredAgents) {
   return async (input, output) => {
@@ -150438,7 +151066,7 @@ async function initializeOpenCodeSwarm(ctx) {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path201.resolve(ctx.directory, ".swarm");
+    const swarmDir = path202.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -151102,7 +151730,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path201.basename(path201.dirname(s.skillPath));
+                    desc = path202.basename(path202.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -151112,7 +151740,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path201.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path202.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {