opencode-swarm 7.87.3 → 7.88.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.87.3",
+    version: "7.88.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",
@@ -359,6 +359,10 @@ var init_tool_metadata = __esm(() => {
         "test_engineer"
       ]
     },
+    parse_lane_candidates: {
+      description: "Parse [CANDIDATE] rows from a dispatch_lanes or collect_lane_results artifact (by output_ref), produce structured records with provenance, optionally persist to a per-batch sidecar JSONL. Pure-parser variant exists as internal module.",
+      agents: ["architect"]
+    },
     test_runner: {
       description: "auto-detect and run tests",
       agents: ["architect", "reviewer", "test_engineer"]
@@ -109870,7 +109874,7 @@ __export(exports_design_doc_drift, {
   _internals: () => _internals111
 });
 import * as fs118 from "node:fs";
-import * as path179 from "node:path";
+import * as path181 from "node:path";
 function mtimeMsOrNull(absPath) {
   try {
     return fs118.statSync(absPath).mtimeMs;
@@ -109881,35 +109885,35 @@ function mtimeMsOrNull(absPath) {
 function resolveAnchorWithin(directory, anchor) {
   if (!anchor || typeof anchor !== "string")
     return null;
-  const root = path179.resolve(directory);
-  const resolved = path179.resolve(root, anchor);
-  const rel = path179.relative(root, resolved);
-  if (rel.startsWith("..") || path179.isAbsolute(rel))
+  const root = path181.resolve(directory);
+  const resolved = path181.resolve(root, anchor);
+  const rel = path181.relative(root, resolved);
+  if (rel.startsWith("..") || path181.isAbsolute(rel))
     return null;
   return resolved;
 }
 async function runDesignDocDriftCheck(directory, phase, outDir) {
   try {
-    const root = path179.resolve(directory);
-    const outAbs = path179.resolve(root, outDir);
-    const outRel = path179.relative(root, outAbs);
-    if (outRel.startsWith("..") || path179.isAbsolute(outRel)) {
+    const root = path181.resolve(directory);
+    const outAbs = path181.resolve(root, outDir);
+    const outRel = path181.relative(root, outAbs);
+    if (outRel.startsWith("..") || path181.isAbsolute(outRel)) {
       return null;
     }
     const docMtimes = new Map;
     const checkedDocs = [];
     const missingDocs = [];
     for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
-      const abs = path179.join(outAbs, relFile);
+      const abs = path181.join(outAbs, relFile);
       const mtime = mtimeMsOrNull(abs);
       docMtimes.set(docName, mtime);
       if (mtime === null) {
-        missingDocs.push(path179.join(outDir, relFile));
+        missingDocs.push(path181.join(outDir, relFile));
       } else {
-        checkedDocs.push(path179.join(outDir, relFile));
+        checkedDocs.push(path181.join(outDir, relFile));
       }
     }
-    const traceabilityAbs = path179.join(outAbs, TRACEABILITY_REL);
+    const traceabilityAbs = path181.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
       const stat14 = await fs118.promises.stat(traceabilityAbs);
@@ -109979,7 +109983,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     };
     const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
     const filePath = validateSwarmPath(directory, filename);
-    await fs118.promises.mkdir(path179.dirname(filePath), { recursive: true });
+    await fs118.promises.mkdir(path181.dirname(filePath), { recursive: true });
     await fs118.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
     getGlobalEventBus().publish("curator.docdrift.completed", {
       phase,
@@ -110011,10 +110015,10 @@ var init_design_doc_drift = __esm(() => {
     domain: "domain.md",
     "technical-spec": "technical-spec.md",
     "behavior-spec": "behavior-spec.md",
-    "reference-impl": path179.join("reference", "reference-impl.md"),
-    "idiom-notes": path179.join("reference", "idiom-notes.md")
+    "reference-impl": path181.join("reference", "reference-impl.md"),
+    "idiom-notes": path181.join("reference", "idiom-notes.md")
   };
-  TRACEABILITY_REL = path179.join("reference", "traceability.json");
+  TRACEABILITY_REL = path181.join("reference", "traceability.json");
   _internals111 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
@@ -110030,7 +110034,7 @@ __export(exports_project_context, {
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs142 from "node:fs";
-import * as path208 from "node:path";
+import * as path210 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -110042,7 +110046,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs142.accessSync(path208.join(directory, pattern));
+    fs142.accessSync(path210.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -110051,7 +110055,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs142.readFileSync(path208.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs142.readFileSync(path210.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -110169,7 +110173,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path209 from "node:path";
+import * as path211 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/background/index.ts
@@ -139179,6 +139183,772 @@ var mutation_test = createSwarmTool({
   }
 });
 
+// src/tools/parse-lane-candidates.ts
+init_zod();
+import { existsSync as existsSync100 } from "node:fs";
+import * as path172 from "node:path";
+
+// src/background/candidate-parser.ts
+init_zod();
+
+// src/background/candidate-sidecar-store.ts
+init_zod();
+init_utils2();
+var import_proper_lockfile10 = __toESM(require_proper_lockfile(), 1);
+import { createHash as createHash23 } from "node:crypto";
+import { appendFileSync as appendFileSync19, mkdirSync as mkdirSync45 } from "node:fs";
+import * as path171 from "node:path";
+var BATCH_DIGEST_ALGORITHM = "sha256";
+var SidecarEnvelopeSchema = exports_external.object({
+  record_type: exports_external.literal("invocation"),
+  source_output_ref: exports_external.string().min(1),
+  source_batch_id: exports_external.string().min(1),
+  source_lane_id: exports_external.string().min(1),
+  source_agent: exports_external.string().min(1),
+  source_digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  row_format_version: exports_external.number().int().nonnegative(),
+  producer: exports_external.string().optional(),
+  produced_at: exports_external.string().min(1),
+  record_version: exports_external.object({
+    major: exports_external.number().int().nonnegative(),
+    minor: exports_external.number().int().nonnegative()
+  }),
+  sessionId: exports_external.string().min(1).optional(),
+  parentSessionId: exports_external.string().min(1).optional(),
+  format_families_detected: exports_external.array(exports_external.string()),
+  candidate_count: exports_external.number().int().nonnegative(),
+  parse_errors: exports_external.number().int().nonnegative(),
+  malformed_rows: exports_external.number().int().nonnegative()
+}).strict();
+var SidecarCandidateSchema = exports_external.object({
+  record_type: exports_external.literal("candidate"),
+  row_format_family: exports_external.enum(["base_explorer", "micro_lane"]),
+  row_format_version: exports_external.number().int().nonnegative(),
+  record_version: exports_external.object({
+    major: exports_external.number().int().nonnegative(),
+    minor: exports_external.number().int().nonnegative()
+  }),
+  source_output_ref: exports_external.string().min(1),
+  source_batch_id: exports_external.string().min(1),
+  source_lane_id: exports_external.string().min(1),
+  source_agent: exports_external.string().min(1),
+  source_digest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  sessionId: exports_external.string().min(1).optional(),
+  parentSessionId: exports_external.string().min(1).optional(),
+  producer: exports_external.string().optional(),
+  extracted_from_partial_source: exports_external.boolean(),
+  candidate_id: exports_external.string().min(1),
+  lane: exports_external.string().nullable(),
+  micro_lane: exports_external.string().nullable(),
+  severity: exports_external.string().nullable(),
+  category: exports_external.string().nullable(),
+  file_line: exports_external.string().nullable(),
+  claim: exports_external.string().nullable(),
+  evidence_summary: exports_external.string().nullable(),
+  impact_context: exports_external.string().nullable(),
+  invariant_violated: exports_external.string().nullable(),
+  confidence: exports_external.string().nullable()
+}).strict();
+var BIDI_RANGES = [
+  [8234, 8238],
+  [8294, 8297]
+];
+function isBidiCodePoint(code) {
+  for (let i2 = 0;i2 < BIDI_RANGES.length; i2++) {
+    const [lo, hi] = BIDI_RANGES[i2];
+    if (code >= lo && code <= hi)
+      return true;
+  }
+  return false;
+}
+function sanitizeString3(value) {
+  let result = "";
+  for (let i2 = 0;i2 < value.length; i2++) {
+    const code = value.codePointAt(i2) ?? 0;
+    if (code > 65535) {
+      result += value[i2];
+      i2++;
+      result += value[i2];
+    } else if (code === 0) {
+      result += "\\u0000";
+    } else if (code === 27) {
+      if (i2 + 1 < value.length && value[i2 + 1] === "[") {
+        i2++;
+        while (i2 + 1 < value.length) {
+          const next = value.charCodeAt(i2 + 1);
+          if (next >= 48 && next <= 63) {
+            i2++;
+          } else if (next >= 32 && next <= 47) {
+            i2++;
+          } else if (next >= 64 && next <= 126) {
+            i2++;
+            break;
+          } else {
+            break;
+          }
+        }
+      } else if (i2 + 1 < value.length && value[i2 + 1] === "]") {
+        i2++;
+        while (i2 + 1 < value.length) {
+          const next = value.charCodeAt(i2 + 1);
+          if (next === 7) {
+            i2++;
+            break;
+          } else if (next === 27 && i2 + 2 < value.length && value[i2 + 2] === "\\") {
+            i2 += 2;
+            break;
+          } else {
+            i2++;
+          }
+        }
+      } else if (i2 + 1 < value.length) {
+        const next = value.charCodeAt(i2 + 1);
+        if (next >= 32 && next <= 47) {
+          i2++;
+          while (i2 + 1 < value.length) {
+            const b = value.charCodeAt(i2 + 1);
+            if (b >= 48 && b <= 126) {
+              i2++;
+              break;
+            } else if (b >= 32 && b <= 47) {
+              i2++;
+            } else {
+              break;
+            }
+          }
+        } else if (next >= 48 && next <= 126) {
+          i2++;
+        }
+      }
+    } else if (isBidiCodePoint(code)) {} else {
+      result += value[i2];
+    }
+  }
+  return result;
+}
+function sanitizeRecord(record3) {
+  for (const key of Object.keys(record3)) {
+    const value = record3[key];
+    if (typeof value === "string") {
+      record3[key] = sanitizeString3(value);
+    } else if (value !== null && typeof value === "object") {
+      if (Array.isArray(value)) {
+        for (let i2 = 0;i2 < value.length; i2++) {
+          const element = value[i2];
+          if (typeof element === "string") {
+            value[i2] = sanitizeString3(element);
+          } else if (element !== null && typeof element === "object") {
+            sanitizeRecord(element);
+          }
+        }
+      } else {
+        sanitizeRecord(value);
+      }
+    }
+  }
+  return record3;
+}
+function computeBatchDigest(batchId) {
+  return createHash23(BATCH_DIGEST_ALGORITHM).update(batchId).digest("hex");
+}
+function sidecarRelativePath(batchDigest) {
+  return path171.join("lane-results", batchDigest, "candidates.jsonl");
+}
+function validateRecord(record3, schema, label) {
+  const result = schema.safeParse(record3);
+  if (!result.success) {
+    throw new Error(`Sidecar ${label} schema validation failed: ${result.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`).join("; ")}`);
+  }
+}
+function withLockfile(lockDir, write) {
+  const lockPath = path171.join(lockDir, ".lock");
+  const lf = import_proper_lockfile10.default;
+  const release = lf.lockSync(lockPath, {
+    realpath: false
+  });
+  try {
+    return write();
+  } finally {
+    release();
+  }
+}
+function appendToSidecar(options, batchId, envelope, candidates) {
+  const batchDigest = options.batchDigest ?? computeBatchDigest(batchId);
+  const relPath = sidecarRelativePath(batchDigest);
+  const absPath = validateSwarmPath(options.projectRoot, relPath);
+  validateRecord(envelope, SidecarEnvelopeSchema, "envelope");
+  for (let i2 = 0;i2 < candidates.length; i2++) {
+    validateRecord(candidates[i2], SidecarCandidateSchema, `candidate[${i2}]`);
+  }
+  mkdirSync45(path171.dirname(absPath), { recursive: true });
+  const sanitizedEnvelope = sanitizeRecord(structuredClone(envelope));
+  const sanitizedCandidates = candidates.map((c) => sanitizeRecord(structuredClone(c)));
+  const lines = [JSON.stringify(sanitizedEnvelope)];
+  for (const candidate of sanitizedCandidates) {
+    lines.push(JSON.stringify(candidate));
+  }
+  const payload = `${lines.join(`
+`)}
+`;
+  const doWrite = () => {
+    appendFileSync19(absPath, payload, "utf-8");
+  };
+  if (options.useLockfile) {
+    withLockfile(path171.dirname(absPath), doWrite);
+  } else {
+    doWrite();
+  }
+}
+
+// src/background/candidate-parser.ts
+var ArtifactInputSchema = exports_external.object({
+  output_ref: exports_external.string().min(1, "output_ref must be a non-empty string"),
+  batchId: exports_external.string().min(1, "batchId must be a non-empty string"),
+  laneId: exports_external.string().min(1, "laneId must be a non-empty string"),
+  agent: exports_external.string().min(1, "agent must be a non-empty string"),
+  role: exports_external.string().min(1, "role must be a non-empty string"),
+  sessionId: exports_external.string().min(1).optional(),
+  parentSessionId: exports_external.string().min(1).optional(),
+  digest: exports_external.string().regex(/^[a-f0-9]{64}$/, "digest must be a SHA-256 hex string"),
+  text: exports_external.string(),
+  transcriptIncomplete: exports_external.boolean().optional(),
+  artifact_status: exports_external.enum(["ok", "ref-not-found", "artifact-corrupted"]),
+  source: exports_external.enum(["dispatch_lanes", "collect_lane_results"]),
+  produced_at: exports_external.string().min(1, "produced_at must be a non-empty string")
+}).strict();
+var ParseFlagsSchema = exports_external.object({
+  accept_partial: exports_external.boolean(),
+  accept_degraded: exports_external.boolean(),
+  degraded: exports_external.boolean(),
+  row_format_version: exports_external.number().int().nonnegative(),
+  producer: exports_external.string().optional()
+}).strict();
+var BASE_EXPLORER_FIELDS = [
+  "candidate_id",
+  "lane",
+  "severity",
+  "category",
+  "file_line",
+  "claim",
+  "evidence_summary",
+  "impact_context",
+  "confidence"
+];
+var MICRO_LANE_FIELDS = [
+  "candidate_id",
+  "micro_lane",
+  "severity",
+  "category",
+  "file_line",
+  "claim",
+  "invariant_violated",
+  "evidence_summary",
+  "confidence"
+];
+var BASE_EXPLORER_DISCRIMINATOR = "impact_context";
+var MICRO_LANE_DISCRIMINATOR = "invariant_violated";
+var EXPECTED_FIELD_COUNT = 9;
+var RECORD_VERSION = { major: 1, minor: 0 };
+function splitRow(line) {
+  const fields = [];
+  let current = "";
+  let i2 = 0;
+  while (i2 < line.length) {
+    if (line[i2] === "\\" && i2 + 1 < line.length && line[i2 + 1] === "|") {
+      current += "|";
+      i2 += 2;
+    } else if (line[i2] === "|") {
+      fields.push(current);
+      current = "";
+      i2++;
+    } else {
+      current += line[i2];
+      i2++;
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+function removeCodeFences(text) {
+  const lines = [];
+  let inFence = false;
+  for (const rawLine of text.split(`
+`)) {
+    const trimmedStart = rawLine.trimStart();
+    if (trimmedStart.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence) {
+      lines.push(rawLine);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+class UnknownFormatFamilyError extends Error {
+  constructor() {
+    super("Unknown format family: neither impact_context nor invariant_violated present");
+    this.name = "UnknownFormatFamilyError";
+  }
+}
+function detectFormatFamily(headerFields) {
+  const trimmed = headerFields.map((f) => f.trim());
+  const hasImpactContext = trimmed.includes(BASE_EXPLORER_DISCRIMINATOR);
+  const hasInvariantViolated = trimmed.includes(MICRO_LANE_DISCRIMINATOR);
+  if (hasImpactContext) {
+    return "base_explorer";
+  }
+  if (hasInvariantViolated) {
+    return "micro_lane";
+  }
+  throw new UnknownFormatFamilyError;
+}
+function detectRowFormatFamily(rowFields) {
+  const trimmed = rowFields.map((f) => f.trim());
+  const hasImpactContext = trimmed.length > 7 && trimmed[7] !== "";
+  const hasInvariantViolated = trimmed.length > 6 && trimmed[6] !== "";
+  if (hasImpactContext && !hasInvariantViolated)
+    return "base_explorer";
+  if (hasInvariantViolated && !hasImpactContext)
+    return "micro_lane";
+  if (hasImpactContext && hasInvariantViolated)
+    return "base_explorer";
+  throw new UnknownFormatFamilyError;
+}
+function mapFields(fields, family) {
+  const trimmed = fields.map((f) => f.trim());
+  const names = family === "base_explorer" ? BASE_EXPLORER_FIELDS : MICRO_LANE_FIELDS;
+  const result = {};
+  for (let i2 = 0;i2 < names.length; i2++) {
+    result[names[i2]] = i2 < trimmed.length && trimmed[i2] !== "" ? trimmed[i2] : null;
+  }
+  if (family === "base_explorer") {
+    result.micro_lane = null;
+    result.invariant_violated = null;
+  } else {
+    result.lane = null;
+    result.impact_context = null;
+  }
+  return result;
+}
+function getRequiredFields(family) {
+  return family === "base_explorer" ? BASE_EXPLORER_FIELDS : MICRO_LANE_FIELDS;
+}
+function assertNonNullCandidateId(value) {
+  if (value === null || value === "") {
+    throw new Error("Invariant violation: null/empty candidate_id reached candidate builder");
+  }
+}
+function buildInvocationEnvelope(input, flags2, formatFamiliesDetected, candidateCount, parseErrors, malformedRows) {
+  return {
+    record_type: "invocation",
+    source_output_ref: input.output_ref,
+    source_batch_id: input.batchId,
+    source_lane_id: input.laneId,
+    source_agent: input.agent,
+    source_digest: input.digest,
+    row_format_version: flags2.row_format_version,
+    sessionId: input.sessionId,
+    parentSessionId: input.parentSessionId,
+    ...flags2.producer ? { producer: flags2.producer } : {},
+    produced_at: input.produced_at,
+    record_version: RECORD_VERSION,
+    format_families_detected: formatFamiliesDetected,
+    candidate_count: candidateCount,
+    parse_errors: parseErrors,
+    malformed_rows: malformedRows
+  };
+}
+function buildEmptyDiagnostics(input, flags2) {
+  return {
+    candidate_count: 0,
+    parse_errors: 0,
+    parse_error_details: [],
+    malformed_rows: 0,
+    duplicate_id_count: 0,
+    duplicate_id_warnings: [],
+    degraded_source_count: flags2.degraded ? 1 : 0,
+    incomplete_source_count: input.transcriptIncomplete ? 1 : 0,
+    format_families_detected: []
+  };
+}
+function refusalResult(errorCode, errorMessage3, input, flags2) {
+  const envelope = buildInvocationEnvelope(input, flags2, [], 0, 0, 0);
+  return {
+    error: errorMessage3,
+    error_code: errorCode,
+    candidates: [],
+    invocation_envelope: envelope,
+    diagnostics: buildEmptyDiagnostics(input, flags2)
+  };
+}
+function emptyTextResult(input, flags2) {
+  const envelope = buildInvocationEnvelope(input, flags2, [], 0, 0, 0);
+  return {
+    candidates: [],
+    invocation_envelope: envelope,
+    diagnostics: buildEmptyDiagnostics(input, flags2)
+  };
+}
+function parseCandidates(input, flags2) {
+  const inputParse = ArtifactInputSchema.safeParse(input);
+  if (!inputParse.success) {
+    throw new Error(`Invalid ArtifactInput: ${inputParse.error.issues.map((issue3) => issue3.message).join(", ")}`);
+  }
+  const flagsParse = ParseFlagsSchema.safeParse(flags2);
+  if (!flagsParse.success) {
+    throw new Error(`Invalid ParseFlags: ${flagsParse.error.issues.map((issue3) => issue3.message).join(", ")}`);
+  }
+  const validatedInput = inputParse.data;
+  const validatedFlags = flagsParse.data;
+  if (validatedInput.artifact_status === "ref-not-found") {
+    return refusalResult("ref-not-found", "Artifact reference not found in store", validatedInput, validatedFlags);
+  }
+  if (validatedInput.artifact_status === "artifact-corrupted") {
+    return refusalResult("artifact-corrupted", "Artifact data is corrupted", validatedInput, validatedFlags);
+  }
+  if (validatedFlags.degraded && !validatedFlags.accept_degraded) {
+    return refusalResult("degraded-source-refused", "Degraded source refused by caller", validatedInput, validatedFlags);
+  }
+  if (validatedInput.transcriptIncomplete === true && !validatedFlags.accept_partial) {
+    return refusalResult("partial-source-refused", "Partial transcript refused by caller", validatedInput, validatedFlags);
+  }
+  if (validatedInput.text.trim() === "") {
+    return emptyTextResult(validatedInput, validatedFlags);
+  }
+  return parseText(validatedInput, validatedFlags);
+}
+function parseText(input, flags2) {
+  const cleanedText = removeCodeFences(input.text);
+  const lines = cleanedText.split(`
+`);
+  let headerIndex = -1;
+  let headerFields = [];
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const trimmed = lines[i2].trim();
+    if (trimmed === "")
+      continue;
+    const fields = splitRow(trimmed);
+    if (fields.length >= 2 && fields.some((f) => f.trim() !== "")) {
+      headerIndex = i2;
+      headerFields = fields.map((f) => f.trim());
+      break;
+    }
+  }
+  if (headerIndex === -1) {
+    return emptyTextResult(input, flags2);
+  }
+  let headerFamily;
+  try {
+    headerFamily = detectFormatFamily(headerFields);
+  } catch (e) {
+    if (e instanceof UnknownFormatFamilyError) {} else {
+      throw e;
+    }
+  }
+  const bothDiscriminators = headerFields.includes(BASE_EXPLORER_DISCRIMINATOR) && headerFields.includes(MICRO_LANE_DISCRIMINATOR);
+  const parseErrorDetails = [];
+  if (bothDiscriminators && headerFamily === "base_explorer") {
+    parseErrorDetails.push({
+      row_index: headerIndex,
+      field: "header",
+      message: "Both format-family discriminators present; defaulting to base_explorer"
+    });
+  }
+  const candidates = [];
+  const idCounts = new Map;
+  const idFirstRows = new Map;
+  const formatFamiliesDetected = new Set;
+  let malformedRows = 0;
+  let currentCandidate = null;
+  for (let i2 = headerIndex + 1;i2 < lines.length; i2++) {
+    const rawLine = lines[i2];
+    const trimmed = rawLine.trim();
+    if (trimmed === "")
+      continue;
+    const fields = splitRow(trimmed);
+    if (fields.length < EXPECTED_FIELD_COUNT) {
+      if (currentCandidate) {
+        const prev = currentCandidate.evidence_summary ?? "";
+        currentCandidate.evidence_summary = `${prev}
+${trimmed}`;
+      } else {
+        malformedRows++;
+      }
+      continue;
+    }
+    const rowFields = fields.slice(0, EXPECTED_FIELD_COUNT);
+    let rowFamily;
+    try {
+      rowFamily = detectRowFormatFamily(rowFields);
+    } catch (e) {
+      if (e instanceof UnknownFormatFamilyError) {
+        malformedRows++;
+        continue;
+      }
+      throw e;
+    }
+    const rowHasImpact = rowFields[7].trim() !== "";
+    const rowHasInvariant = rowFields[6].trim() !== "";
+    if (rowHasImpact && rowHasInvariant && rowFamily === "base_explorer") {
+      parseErrorDetails.push({
+        row_index: i2,
+        field: "row",
+        message: "Both format-family discriminators present; defaulting to base_explorer"
+      });
+    }
+    const mapped = mapFields(rowFields, rowFamily);
+    const requiredFields = rowFamily === "base_explorer" ? getRequiredFields("base_explorer") : getRequiredFields("micro_lane");
+    let rowMalformed = false;
+    for (const field of requiredFields) {
+      const value = mapped[field];
+      if (field === "candidate_id") {
+        if (value === null || value === "") {
+          rowMalformed = true;
+          break;
+        }
+      } else if (value === null) {
+        parseErrorDetails.push({
+          row_index: i2,
+          field,
+          message: `Missing required field: ${field}`
+        });
+      }
+    }
+    if (rowMalformed) {
+      malformedRows++;
+      continue;
+    }
+    assertNonNullCandidateId(mapped.candidate_id);
+    const candidateId = mapped.candidate_id;
+    const candidate = {
+      record_type: "candidate",
+      row_format_family: rowFamily,
+      row_format_version: flags2.row_format_version,
+      record_version: RECORD_VERSION,
+      source_output_ref: input.output_ref,
+      source_batch_id: input.batchId,
+      source_lane_id: input.laneId,
+      source_agent: input.agent,
+      source_digest: input.digest,
+      sessionId: input.sessionId,
+      parentSessionId: input.parentSessionId,
+      producer: flags2.producer,
+      extracted_from_partial_source: !!(input.transcriptIncomplete || flags2.degraded),
+      candidate_id: candidateId,
+      lane: mapped.lane,
+      micro_lane: mapped.micro_lane,
+      severity: mapped.severity,
+      category: mapped.category,
+      file_line: mapped.file_line,
+      claim: mapped.claim,
+      evidence_summary: mapped.evidence_summary,
+      impact_context: mapped.impact_context,
+      invariant_violated: mapped.invariant_violated,
+      confidence: mapped.confidence
+    };
+    const cid = candidate.candidate_id;
+    idCounts.set(cid, (idCounts.get(cid) ?? 0) + 1);
+    if (!idFirstRows.has(cid)) {
+      idFirstRows.set(cid, i2);
+    }
+    formatFamiliesDetected.add(rowFamily);
+    candidates.push(candidate);
+    currentCandidate = candidate;
+  }
+  const duplicateIdWarnings = [];
+  let duplicateIdCount = 0;
+  for (const [id, count] of idCounts) {
+    if (count > 1) {
+      duplicateIdCount++;
+      duplicateIdWarnings.push({
+        candidate_id: id,
+        occurrences: count
+      });
+      parseErrorDetails.push({
+        row_index: idFirstRows.get(id) ?? -1,
+        field: "candidate_id",
+        message: `Duplicate candidate_id: "${id}" appears ${count} times`
+      });
+    }
+  }
+  const parseErrors = parseErrorDetails.length;
+  const envelope = buildInvocationEnvelope(input, flags2, Array.from(formatFamiliesDetected), candidates.length, parseErrors, malformedRows);
+  return {
+    candidates,
+    invocation_envelope: envelope,
+    diagnostics: {
+      candidate_count: candidates.length,
+      parse_errors: parseErrors,
+      parse_error_details: parseErrorDetails,
+      malformed_rows: malformedRows,
+      duplicate_id_count: duplicateIdCount,
+      duplicate_id_warnings: duplicateIdWarnings,
+      degraded_source_count: flags2.degraded ? 1 : 0,
+      incomplete_source_count: input.transcriptIncomplete ? 1 : 0,
+      format_families_detected: Array.from(formatFamiliesDetected)
+    }
+  };
+}
+function parseAndPersist(input, flags2, options) {
+  const result = parseCandidates(input, flags2);
+  try {
+    appendToSidecar(options, input.batchId, result.invocation_envelope, result.candidates);
+  } catch (error93) {
+    const message = error93 instanceof Error ? error93.message : String(error93);
+    return {
+      ...result,
+      sidecar_write_error: message
+    };
+  }
+  return result;
+}
+
+// src/tools/parse-lane-candidates.ts
+init_utils2();
+init_create_tool();
+var ParseLaneCandidatesArgsSchema = exports_external.object({
+  output_ref: exports_external.string().min(1).describe("Opaque lane output ref returned as output_ref by dispatch_lanes or collect_lane_results."),
+  accept_partial: exports_external.boolean().default(false).describe("Accept sources where transcriptIncomplete is true (partial transcripts)."),
+  accept_degraded: exports_external.boolean().default(false).describe("Accept sources where the artifact storage was degraded (output_degraded)."),
+  degraded: exports_external.boolean().default(false).describe("Passed through from DispatchLaneResult.output_degraded by the orchestrator."),
+  row_format_version: exports_external.number().int().nonnegative().default(1).describe("Row format version; currently only version 1 is supported."),
+  producer: exports_external.string().optional().default("swarm-pr-review").describe("Producer label for cross-skill filtering in the sidecar."),
+  use_lockfile: exports_external.boolean().default(false).describe("When true, use proper-lockfile for concurrency-safe sidecar writes."),
+  project_root: exports_external.string().optional().describe("Project root directory where .swarm/ lives. Defaults to the injected working directory.")
+}).strict();
+var REF_RE2 = /^L1:[a-f0-9]{64}:[a-f0-9]{64}:[a-f0-9]{64}$/;
+function laneOutputRelativePath2(ref) {
+  const parts2 = ref.split(":");
+  if (parts2.length !== 4)
+    return "";
+  const [, batchDigest, laneDigest, outputDigest] = parts2;
+  return path172.join("lane-results", batchDigest, laneDigest, `${outputDigest}.json`);
+}
+var parse_lane_candidates = createSwarmTool({
+  description: "Parse [CANDIDATE] rows from a dispatch_lanes or collect_lane_results artifact (by output_ref), produce structured records with provenance, optionally persist to a per-batch sidecar JSONL. Pure-parser variant exists as internal module.",
+  args: {
+    output_ref: ParseLaneCandidatesArgsSchema.shape.output_ref,
+    accept_partial: ParseLaneCandidatesArgsSchema.shape.accept_partial,
+    accept_degraded: ParseLaneCandidatesArgsSchema.shape.accept_degraded,
+    degraded: ParseLaneCandidatesArgsSchema.shape.degraded,
+    row_format_version: ParseLaneCandidatesArgsSchema.shape.row_format_version,
+    producer: ParseLaneCandidatesArgsSchema.shape.producer,
+    use_lockfile: ParseLaneCandidatesArgsSchema.shape.use_lockfile,
+    project_root: ParseLaneCandidatesArgsSchema.shape.project_root
+  },
+  async execute(args2, directory) {
+    const parsed = ParseLaneCandidatesArgsSchema.safeParse(args2);
+    if (!parsed.success) {
+      return JSON.stringify({
+        success: false,
+        failure_class: "invalid_args",
+        message: "Invalid parse_lane_candidates arguments",
+        errors: parsed.error.issues.map((issue3) => `${issue3.path.join(".")}: ${issue3.message}`)
+      }, null, 2);
+    }
+    const {
+      output_ref,
+      accept_partial,
+      accept_degraded,
+      degraded,
+      row_format_version,
+      producer,
+      use_lockfile,
+      project_root
+    } = parsed.data;
+    if (project_root !== undefined) {
+      const absRoot = path172.resolve(project_root);
+      const absDir = path172.resolve(directory);
+      const rel = path172.relative(absDir, absRoot);
+      if (rel === ".." || rel.startsWith(`..${path172.sep}`) || path172.isAbsolute(rel)) {
+        return JSON.stringify({
+          success: false,
+          failure_class: "invalid_args",
+          message: "project_root must resolve within the injected working directory",
+          errors: [
+            `project_root: ${project_root} is outside the project root ${directory}`
+          ]
+        }, null, 2);
+      }
+    }
+    let loaded;
+    try {
+      loaded = readLaneOutput(directory, output_ref);
+    } catch {
+      loaded = null;
+    }
+    if (!loaded) {
+      const relPath = REF_RE2.test(output_ref) ? laneOutputRelativePath2(output_ref) : "";
+      const absPath = relPath ? validateSwarmPath(directory, relPath) : "";
+      const fileExists = absPath ? existsSync100(absPath) : false;
+      const artifactStatus = fileExists ? "artifact-corrupted" : "ref-not-found";
+      const refParts = output_ref.split(":");
+      const hasValidRef = REF_RE2.test(output_ref) && refParts.length === 4;
+      const syntheticBatchId = hasValidRef ? refParts[1] : "unknown";
+      const syntheticLaneId = hasValidRef ? refParts[2] : "unknown";
+      const syntheticDigest = "0".repeat(64);
+      const artifactInput2 = {
+        output_ref,
+        batchId: syntheticBatchId,
+        laneId: syntheticLaneId,
+        agent: "unknown",
+        role: "unknown",
+        digest: syntheticDigest,
+        text: "",
+        artifact_status: artifactStatus,
+        source: "dispatch_lanes",
+        produced_at: new Date().toISOString()
+      };
+      const flags3 = {
+        accept_partial,
+        accept_degraded,
+        degraded,
+        row_format_version,
+        ...producer ? { producer } : {}
+      };
+      const options2 = {
+        projectRoot: project_root ?? directory,
+        useLockfile: use_lockfile,
+        batchDigest: syntheticBatchId
+      };
+      const result2 = parseAndPersist(artifactInput2, flags3, options2);
+      return JSON.stringify(result2, null, 2);
+    }
+    const artifact = loaded.artifact;
+    const artifactInput = {
+      output_ref: artifact.ref,
+      batchId: artifact.batchId,
+      laneId: artifact.laneId,
+      agent: artifact.agent,
+      role: artifact.role,
+      ...artifact.sessionId !== undefined ? { sessionId: artifact.sessionId } : {},
+      ...artifact.parentSessionId !== undefined ? { parentSessionId: artifact.parentSessionId } : {},
+      digest: artifact.digest,
+      text: artifact.text,
+      transcriptIncomplete: artifact.transcriptIncomplete,
+      artifact_status: "ok",
+      source: artifact.source,
+      produced_at: artifact.createdAt ?? artifact.updatedAt
+    };
+    const flags2 = {
+      accept_partial,
+      accept_degraded,
+      degraded,
+      row_format_version,
+      ...producer ? { producer } : {}
+    };
+    const options = {
+      projectRoot: project_root ?? directory,
+      useLockfile: use_lockfile
+    };
+    const result = parseAndPersist(artifactInput, flags2, options);
+    return JSON.stringify(result, null, 2);
+  }
+});
+
 // src/tools/phase-complete.ts
 init_zod();
 init_config();
@@ -139186,22 +139956,22 @@ init_schema();
 init_manager2();
 init_task_file();
 import * as fs119 from "node:fs";
-import * as path180 from "node:path";
+import * as path182 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state3();
 import * as fs110 from "node:fs";
-import * as path171 from "node:path";
+import * as path173 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path171.posix.join("evidence", String(phase)));
+    const dirPath = validateSwarmPath(directory, path173.posix.join("evidence", String(phase)));
     if (!fs110.existsSync(dirPath))
       return [];
     const entries = fs110.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path171.join(dirPath, e));
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path173.join(dirPath, e));
   } catch {
     return [];
   }
@@ -139456,16 +140226,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs111 from "node:fs";
-import * as path172 from "node:path";
+import * as path174 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path172.join(directory, ".swarm");
+    const swarmDir = path174.join(directory, ".swarm");
     fs111.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path172.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path172.join(swarmDir, "SWARM_PLAN.md");
+    const jsonPath = path174.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path174.join(swarmDir, "SWARM_PLAN.md");
     fs111.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs111.writeFileSync(mdPath, md, "utf8");
@@ -139486,7 +140256,7 @@ init_state();
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
 import * as fs112 from "node:fs";
-import * as path173 from "node:path";
+import * as path175 from "node:path";
 init_state4();
 var DEFAULT_CONFIG3 = {
   phase_reviewer: true,
@@ -139495,7 +140265,7 @@ var DEFAULT_CONFIG3 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path173.join(dir, ".swarm", "plan.json");
+    const planPath = path175.join(dir, ".swarm", "plan.json");
     if (!fs112.existsSync(planPath))
       return null;
     const raw = fs112.readFileSync(planPath, "utf-8");
@@ -139510,7 +140280,7 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path173.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    const evidencePath = path175.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
     if (!fs112.existsSync(evidencePath)) {
       return null;
     }
@@ -139530,7 +140300,7 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path173.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    const evidencePath = path175.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
     if (!fs112.existsSync(evidencePath)) {
       return null;
     }
@@ -139549,7 +140319,7 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path173.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path175.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
     entries = fs112.readdirSync(evidenceDir);
@@ -139619,7 +140389,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG3,
     ...actualConfig
   };
-  const statePath = path173.join(directory, ".swarm", "turbo-state.json");
+  const statePath = path175.join(directory, ".swarm", "turbo-state.json");
   if (!fs112.existsSync(statePath)) {
     return {
       ok: false,
@@ -139807,7 +140577,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path173.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path175.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
       const content = fs112.readFileSync(evidencePath, "utf-8");
@@ -139973,7 +140743,7 @@ async function runCompletionVerifyGate(ctx) {
 // src/tools/phase-complete/gates/drift-gate.ts
 init_effective_spec();
 import * as fs113 from "node:fs";
-import * as path174 from "node:path";
+import * as path176 from "node:path";
 
 // src/tools/phase-complete/gates/gate-helpers.ts
 init_qa_gate_profile();
@@ -140022,7 +140792,7 @@ async function runDriftGate(ctx) {
   }
   let phaseType;
   try {
-    const planPath = path174.join(dir, ".swarm", "plan.json");
+    const planPath = path176.join(dir, ".swarm", "plan.json");
     if (fs113.existsSync(planPath)) {
       const planRaw = fs113.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
@@ -140041,7 +140811,7 @@ async function runDriftGate(ctx) {
     };
   }
   try {
-    const driftEvidencePath = path174.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+    const driftEvidencePath = path176.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
     let driftVerdictFound = false;
     let driftVerdictApproved = false;
     try {
@@ -140082,7 +140852,7 @@ async function runDriftGate(ctx) {
         let incompleteTaskCount = 0;
         let planParseable = false;
         try {
-          const planPath = path174.join(dir, ".swarm", "plan.json");
+          const planPath = path176.join(dir, ".swarm", "plan.json");
           if (fs113.existsSync(planPath)) {
             const planRaw = fs113.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
@@ -140161,7 +140931,7 @@ async function runDriftGate(ctx) {
 }
 // src/tools/phase-complete/gates/final-council-gate.ts
 import * as fs114 from "node:fs";
-import * as path175 from "node:path";
+import * as path177 from "node:path";
 async function runFinalCouncilGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let finalCouncilEnabled = false;
@@ -140184,7 +140954,7 @@ async function runFinalCouncilGate(ctx) {
       if (lastPhaseId !== undefined && phase === lastPhaseId) {
         if (preamble.effectiveGates?.final_council === true) {
           finalCouncilEnabled = true;
-          const fcPath = path175.join(dir, ".swarm", "evidence", "final-council.json");
+          const fcPath = path177.join(dir, ".swarm", "evidence", "final-council.json");
           let fcVerdictFound = false;
           let _fcVerdict;
           try {
@@ -140338,13 +141108,13 @@ async function runFinalCouncilGate(ctx) {
 }
 // src/tools/phase-complete/gates/hallucination-gate.ts
 import * as fs115 from "node:fs";
-import * as path176 from "node:path";
+import * as path178 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 = path176.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+      const hgPath = path178.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
       let hgVerdictFound = false;
       let hgVerdictApproved = false;
       try {
@@ -140402,13 +141172,13 @@ async function runHallucinationGate(ctx) {
 }
 // src/tools/phase-complete/gates/mutation-gate.ts
 import * as fs116 from "node:fs";
-import * as path177 from "node:path";
+import * as path179 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 = path177.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+      const mgPath = path179.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
       let mgVerdictFound = false;
       let mgVerdict;
       try {
@@ -140466,7 +141236,7 @@ async function runMutationGate(ctx) {
 }
 // src/tools/phase-complete/gates/phase-council-gate.ts
 import * as fs117 from "node:fs";
-import * as path178 from "node:path";
+import * as path180 from "node:path";
 async function runPhaseCouncilGate(ctx) {
   const { phase, dir, sessionID, pluginConfig, agentsDispatched, safeWarn } = ctx;
   const gateWarnings = [];
@@ -140475,7 +141245,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 = path178.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+      const pcPath = path180.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
       let pcVerdictFound = false;
       let _pcVerdict;
       let pcQuorumSize;
@@ -141043,7 +141813,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path180.basename(dir);
+      const projectName = path182.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig, {
         llmDelegate: createCuratorLLMDelegate(dir, "phase", sessionID),
         enrichmentQuota: {
@@ -141605,7 +142375,7 @@ init_utils();
 init_bun_compat();
 init_create_tool();
 import * as fs120 from "node:fs";
-import * as path181 from "node:path";
+import * as path183 from "node:path";
 var MAX_OUTPUT_BYTES7 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -141633,16 +142403,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs120.existsSync(path181.join(cwd, "package.json"))) {
+  if (fs120.existsSync(path183.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs120.existsSync(path181.join(cwd, "pyproject.toml")) || fs120.existsSync(path181.join(cwd, "requirements.txt"))) {
+  if (fs120.existsSync(path183.join(cwd, "pyproject.toml")) || fs120.existsSync(path183.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs120.existsSync(path181.join(cwd, "Cargo.toml"))) {
+  if (fs120.existsSync(path183.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs120.existsSync(path181.join(cwd, "go.mod"))) {
+  if (fs120.existsSync(path183.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -141651,13 +142421,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs120.existsSync(path181.join(cwd, "Gemfile")) || fs120.existsSync(path181.join(cwd, "Gemfile.lock"))) {
+  if (fs120.existsSync(path183.join(cwd, "Gemfile")) || fs120.existsSync(path183.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs120.existsSync(path181.join(cwd, "pubspec.yaml"))) {
+  if (fs120.existsSync(path183.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs120.existsSync(path181.join(cwd, "composer.lock"))) {
+  if (fs120.existsSync(path183.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -141670,7 +142440,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve65) => setTimeout(() => resolve65("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve66) => setTimeout(() => resolve66("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr2]) => ({ stdout: stdout2, stderr: stderr2 })),
       timeoutPromise
@@ -141790,7 +142560,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve65) => setTimeout(() => resolve65("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve66) => setTimeout(() => resolve66("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr2]) => ({ stdout: stdout2, stderr: stderr2 })),
       timeoutPromise
@@ -141918,7 +142688,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve65) => setTimeout(() => resolve65("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve66) => setTimeout(() => resolve66("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -142042,7 +142812,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve65) => setTimeout(() => resolve65("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve66) => setTimeout(() => resolve66("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -142175,7 +142945,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve65) => setTimeout(() => resolve65("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve66) => setTimeout(() => resolve66("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -142291,7 +143061,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve65) => setTimeout(() => resolve65("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve66) => setTimeout(() => resolve66("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -142436,7 +143206,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve65) => setTimeout(() => resolve65("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve66) => setTimeout(() => resolve66("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -142551,7 +143321,7 @@ async function runComposerAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve65) => setTimeout(() => resolve65("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve66) => setTimeout(() => resolve66("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -142794,7 +143564,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs121 from "node:fs";
-import * as path182 from "node:path";
+import * as path184 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -142917,7 +143687,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path182.basename(filePath);
+  const filename = path184.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -142934,7 +143704,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path182.basename(filePath);
+    const filename = path184.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -142943,7 +143713,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path182.extname(filePath).toLowerCase();
+  const ext = path184.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -143190,9 +143960,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path182.isAbsolute(filePath) ? filePath : path182.resolve(directory, filePath);
-    const resolvedDirectory = path182.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path182.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path184.isAbsolute(filePath) ? filePath : path184.resolve(directory, filePath);
+    const resolvedDirectory = path184.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path184.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs121.existsSync(fullPath)) {
@@ -143201,7 +143971,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path182.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path184.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -143274,7 +144044,7 @@ var placeholder_scan = createSwarmTool({
 
 // src/tools/pre-check-batch.ts
 import * as fs125 from "node:fs";
-import * as path186 from "node:path";
+import * as path188 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -143415,7 +144185,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs124 from "node:fs";
-import * as path185 from "node:path";
+import * as path187 from "node:path";
 import { extname as extname19 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -144125,7 +144895,7 @@ function executeRulesSync(filePath, content, language) {
 // src/sast/semgrep.ts
 import * as child_process14 from "node:child_process";
 import * as fs122 from "node:fs";
-import * as path183 from "node:path";
+import * as path185 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS4 = 30000;
@@ -144210,7 +144980,7 @@ function mapSemgrepSeverity(severity) {
 }
 async function executeWithTimeout(command, args2, options) {
   const maxOutputBytes = options.maxOutputBytes ?? MAX_OUTPUT_BYTES8;
-  return new Promise((resolve67) => {
+  return new Promise((resolve68) => {
     const child = child_process14.spawn(command, args2, {
       shell: false,
       cwd: options.cwd,
@@ -144255,7 +145025,7 @@ async function executeWithTimeout(command, args2, options) {
           escalation.unref();
         }
       }
-      resolve67({ ...result, truncated });
+      resolve68({ ...result, truncated });
     };
     timeout = setTimeout(() => {
       settle({
@@ -144412,7 +145182,7 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path183.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path185.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
@@ -144433,24 +145203,24 @@ init_create_tool();
 init_utils2();
 import * as crypto13 from "node:crypto";
 import * as fs123 from "node:fs";
-import * as path184 from "node:path";
+import * as path186 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 = path184.isAbsolute(file3) ? file3 : path184.resolve(directory, file3);
-  const rel = path184.relative(path184.resolve(directory), resolved);
+  const resolved = path186.isAbsolute(file3) ? file3 : path186.resolve(directory, file3);
+  const rel = path186.relative(path186.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path184.join("evidence", String(phase), "sast-baseline.json");
+  return path186.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path184.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path186.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path184.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path186.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -144536,7 +145306,7 @@ async function acquireLock2(lockPath) {
       };
     } catch {
       if (attempt < LOCK_RETRY_DELAYS_MS.length) {
-        await new Promise((resolve68) => setTimeout(resolve68, LOCK_RETRY_DELAYS_MS[attempt]));
+        await new Promise((resolve69) => setTimeout(resolve69, LOCK_RETRY_DELAYS_MS[attempt]));
       }
     }
   }
@@ -144571,8 +145341,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs123.mkdirSync(path184.dirname(baselinePath), { recursive: true });
-  fs123.mkdirSync(path184.dirname(tempPath), { recursive: true });
+  fs123.mkdirSync(path186.dirname(baselinePath), { recursive: true });
+  fs123.mkdirSync(path186.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
@@ -144845,9 +145615,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path185.isAbsolute(filePath) ? filePath : path185.resolve(directory, filePath);
-    const resolvedDirectory = path185.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path185.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path187.isAbsolute(filePath) ? filePath : path187.resolve(directory, filePath);
+    const resolvedDirectory = path187.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path187.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -145162,20 +145932,20 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path186.win32.resolve(inputPath);
-  } else if (path186.isAbsolute(inputPath)) {
-    resolved = path186.resolve(inputPath);
+    resolved = path188.win32.resolve(inputPath);
+  } else if (path188.isAbsolute(inputPath)) {
+    resolved = path188.resolve(inputPath);
   } else {
-    resolved = path186.resolve(baseDir, inputPath);
+    resolved = path188.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path186.resolve(workspaceDir);
-  let relative37;
+  const workspaceResolved = path188.resolve(workspaceDir);
+  let relative38;
   if (isWinAbs) {
-    relative37 = path186.win32.relative(workspaceResolved, resolved);
+    relative38 = path188.win32.relative(workspaceResolved, resolved);
   } else {
-    relative37 = path186.relative(workspaceResolved, resolved);
+    relative38 = path188.relative(workspaceResolved, resolved);
   }
-  if (relative37.startsWith("..")) {
+  if (relative38.startsWith("..")) {
     return "path traversal detected";
   }
   return null;
@@ -145238,7 +146008,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path186.resolve(file3);
+    const resolvedPath = path188.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -145395,7 +146165,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path186.resolve(file3);
+      const resolvedPath = path188.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -145413,7 +146183,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path186.extname(file3).toLowerCase();
+      const ext = path188.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -145632,7 +146402,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path186.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path188.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -145683,7 +146453,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path186.resolve(directory, file3));
+    changedFiles.push(path188.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -145884,9 +146654,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path186.resolve(typedArgs.directory);
-    const workspaceAnchor = path186.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path186.sep)) {
+    const resolvedDirectory = path188.resolve(typedArgs.directory);
+    const workspaceAnchor = path188.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path188.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,
@@ -145940,7 +146710,7 @@ var pre_check_batch = createSwarmTool({
 init_zod();
 init_path_security();
 init_create_tool();
-import * as path187 from "node:path";
+import * as path189 from "node:path";
 var VALID_ACTIONS = [
   "build",
   "importers",
@@ -145968,7 +146738,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path187.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path189.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -145991,8 +146761,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path187.isAbsolute(normalized)) {
-    const rel = path187.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path189.isAbsolute(normalized)) {
+    const rel = path189.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath(rel);
   }
   return normalizeGraphPath(normalized);
@@ -146206,7 +146976,7 @@ init_zod();
 init_effective_spec();
 init_create_tool();
 import * as fs126 from "node:fs";
-import * as path188 from "node:path";
+import * as path190 from "node:path";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHOULD", "SHALL"];
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
@@ -146274,7 +147044,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path188.join(evidenceDir, entry);
+    const entryPath = path190.join(evidenceDir, entry);
     try {
       const stat14 = fs126.statSync(entryPath);
       if (!stat14.isDirectory()) {
@@ -146290,11 +147060,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path188.join(entryPath, "evidence.json");
+    const evidenceFilePath = path190.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path188.resolve(evidenceFilePath);
-      const evidenceDirResolved = path188.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path188.sep)) {
+      const resolvedPath = path190.resolve(evidenceFilePath);
+      const evidenceDirResolved = path190.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path190.sep)) {
         continue;
       }
       const stat14 = fs126.lstatSync(evidenceFilePath);
@@ -146328,7 +147098,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(path188.resolve(cwd, file3));
+                  touchedFiles.add(path190.resolve(cwd, file3));
                 }
               }
             }
@@ -146341,8 +147111,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path188.resolve(filePath);
-    const cwdResolved = path188.resolve(cwd);
+    const resolvedPath = path190.resolve(filePath);
+    const cwdResolved = path190.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -146501,7 +147271,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path188.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path190.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -146527,7 +147297,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path188.join(evidenceDir, reportFilename);
+    const reportPath = path190.join(evidenceDir, reportFilename);
     try {
       if (!fs126.existsSync(evidenceDir)) {
         fs126.mkdirSync(evidenceDir, { recursive: true });
@@ -146682,7 +147452,7 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as fs127 from "node:fs";
-import * as path189 from "node:path";
+import * as path191 from "node:path";
 init_ledger();
 init_manager();
 init_effective_spec();
@@ -146764,8 +147534,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path189.resolve(args2.working_directory);
-    const resolvedRoot = path189.resolve(fallbackDir);
+    const resolvedTarget = path191.resolve(args2.working_directory);
+    const resolvedRoot = path191.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs127.accessSync(resolvedRoot, fs127.constants.F_OK);
@@ -146774,7 +147544,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path189.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path191.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -146805,7 +147575,7 @@ async function executeSavePlan(args2, fallbackDir) {
     specHash = spec.hash;
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path189.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path191.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs127.promises.readFile(contextPath, "utf8");
@@ -147095,7 +147865,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path189.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path191.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -147118,7 +147888,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path189.join(dir, ".swarm", "plan.json"),
+        plan_path: path191.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -147186,7 +147956,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs128 from "node:fs";
-import * as path190 from "node:path";
+import * as path192 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -148036,7 +148806,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs128.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path190.join(dir, entry.name);
+        const fullPath = path192.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -148045,7 +148815,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path190.relative(rootDir, fullPath));
+              manifestFiles.push(path192.relative(rootDir, fullPath));
               break;
             }
           }
@@ -148063,11 +148833,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs128.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path190.join(dir, entry.name);
+        const fullPath = path192.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path190.relative(workingDir, fullPath));
+              found.push(path192.relative(workingDir, fullPath));
               break;
             }
           }
@@ -148080,11 +148850,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path190.dirname(file3);
+    let currentDir = path192.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path190.sep) {
-        dirs.add(path190.join(workingDir, currentDir));
-        const parent = path190.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path192.sep) {
+        dirs.add(path192.join(workingDir, currentDir));
+        const parent = path192.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -148168,7 +148938,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path190.isAbsolute(relativeOutputDir) ? relativeOutputDir : path190.join(workingDir, relativeOutputDir);
+    const outputDir = path192.isAbsolute(relativeOutputDir) ? relativeOutputDir : path192.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -148191,7 +148961,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path190.isAbsolute(manifestFile) ? manifestFile : path190.join(workingDir, manifestFile);
+        const fullPath = path192.isAbsolute(manifestFile) ? manifestFile : path192.join(workingDir, manifestFile);
         if (!fs128.existsSync(fullPath)) {
           continue;
         }
@@ -148208,7 +148978,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path190.join(outputDir, filename);
+    const outputPath = path192.join(outputDir, filename);
     fs128.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -148253,7 +149023,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs129 from "node:fs";
-import * as path191 from "node:path";
+import * as path193 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -148285,12 +149055,12 @@ function normalizePath5(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path191.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path191.sep) ? cwd : cwd + path191.sep;
+    const resolvedPath = path193.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path193.sep) ? cwd : cwd + path193.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path191.extname(resolvedPath).toLowerCase();
+    const ext = path193.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -148304,7 +149074,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path191.resolve(cwd, candidate);
+    const candidatePath = path193.resolve(cwd, candidate);
     if (fs129.existsSync(candidatePath)) {
       const stats2 = fs129.statSync(candidatePath);
       if (stats2.size <= MAX_SPEC_SIZE) {
@@ -148316,7 +149086,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs129.readFileSync(specFile, "utf-8");
-  const ext = path191.extname(specFile).toLowerCase();
+  const ext = path193.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -148392,7 +149162,7 @@ function extractRoutes2(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path191.join(dir, entry.name);
+      const fullPath = path193.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -148402,7 +149172,7 @@ function extractRoutes2(cwd) {
         }
         walkDir2(fullPath);
       } else if (entry.isFile()) {
-        const ext = path191.extname(entry.name).toLowerCase();
+        const ext = path193.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -148571,7 +149341,7 @@ init_bun_compat();
 init_path_security();
 init_create_tool();
 import * as fs130 from "node:fs";
-import * as path192 from "node:path";
+import * as path194 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -148607,11 +149377,11 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path192.resolve(workspace, filePath);
+    const resolvedPath = path194.resolve(workspace, filePath);
     const realWorkspace = fs130.realpathSync(workspace);
     const realResolvedPath = fs130.realpathSync(resolvedPath);
-    const relativePath = path192.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path192.isAbsolute(relativePath)) {
+    const relativePath = path194.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path194.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -148624,11 +149394,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path192.delimiter)) {
+  for (const dir of searchPath.split(path194.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path192.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path194.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs130.existsSync(candidate))
       return candidate;
   }
@@ -148683,7 +149453,7 @@ async function ripgrepSearch(opts) {
       stderr: "pipe",
       cwd: opts.workspace
     });
-    const timeout = new Promise((resolve74) => setTimeout(() => resolve74("timeout"), REGEX_TIMEOUT_MS));
+    const timeout = new Promise((resolve75) => setTimeout(() => resolve75("timeout"), REGEX_TIMEOUT_MS));
     const exitPromise = proc.exited;
     const result = await Promise.race([exitPromise, timeout]);
     if (result === "timeout") {
@@ -148758,8 +149528,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs130.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path192.join(dir, entry.name);
-      const relativePath = path192.relative(workspace, fullPath);
+      const fullPath = path194.join(dir, entry.name);
+      const relativePath = path194.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -148800,7 +149570,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path192.join(opts.workspace, file3);
+    const fullPath = path194.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -149232,7 +150002,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir33, rename as rename14, writeFile as writeFile23 } from "node:fs/promises";
-import * as path193 from "node:path";
+import * as path195 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.",
@@ -149273,8 +150043,8 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path193.join(directory, ".swarm", "spec.md");
-    await mkdir33(path193.dirname(target), { recursive: true });
+    const target = path195.join(directory, ".swarm", "spec.md");
+    await mkdir33(path195.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -149303,14 +150073,14 @@ ${content}
 init_zod();
 init_loader();
 import {
-  existsSync as existsSync112,
-  mkdirSync as mkdirSync49,
+  existsSync as existsSync113,
+  mkdirSync as mkdirSync50,
   readFileSync as readFileSync89,
   renameSync as renameSync32,
   unlinkSync as unlinkSync29,
   writeFileSync as writeFileSync36
 } from "node:fs";
-import path194 from "node:path";
+import path196 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -149477,7 +150247,7 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path194.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path196.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
     const raw = readFileSync89(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -149539,9 +150309,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
-  const evidenceDir = path194.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
-  mkdirSync49(evidenceDir, { recursive: true });
-  const evidenceFile = path194.join(evidenceDir, "phase-council.json");
+  const evidenceDir = path196.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  mkdirSync50(evidenceDir, { recursive: true });
+  const evidenceFile = path196.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -149578,7 +150348,7 @@ function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
     writeFileSync36(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
     renameSync32(tempFile, evidenceFile);
   } finally {
-    if (existsSync112(tempFile)) {
+    if (existsSync113(tempFile)) {
       unlinkSync29(tempFile);
     }
   }
@@ -149604,7 +150374,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs131 from "node:fs";
-import * as path195 from "node:path";
+import * as path197 from "node:path";
 var BINARY_EXTENSIONS2 = new Set([
   ".png",
   ".jpg",
@@ -149640,14 +150410,14 @@ function containsWindowsAttacks5(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path195.resolve(workspace, filePath);
+    const resolvedPath = path197.resolve(workspace, filePath);
     if (!fs131.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs131.realpathSync(workspace);
     const realResolvedPath = fs131.realpathSync(resolvedPath);
-    const relativePath = path195.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path195.isAbsolute(relativePath)) {
+    const relativePath = path197.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path197.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -149762,7 +150532,7 @@ function arraysEqual2(a, b) {
   return true;
 }
 function isBinaryFile4(filePath) {
-  const ext = path195.extname(filePath).toLowerCase();
+  const ext = path197.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS2.has(ext);
 }
 function splitDiffLines(content) {
@@ -149967,7 +150737,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path195.resolve(directory, change.file);
+      const fullPath = path197.resolve(directory, change.file);
       if (!fs131.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -150062,7 +150832,7 @@ var suggestPatch = createSwarmTool({
         const unifiedParts = [];
         for (const [file3, entries] of fileGroups) {
           entries.sort((a, b) => a.contextMatch.startLineIndex - b.contextMatch.startLineIndex);
-          const entryFullPath = path195.resolve(directory, file3);
+          const entryFullPath = path197.resolve(directory, file3);
           let entryContent;
           try {
             entryContent = fs131.readFileSync(entryFullPath, "utf-8");
@@ -150404,7 +151174,7 @@ function getContextAgent4(ctx) {
 
 // src/tools/syntax-check.ts
 import * as fs132 from "node:fs";
-import * as path196 from "node:path";
+import * as path198 from "node:path";
 init_zod();
 init_manager2();
 init_detector();
@@ -150476,7 +151246,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path196.extname(file3.path).toLowerCase();
+      const ext = path198.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -150486,7 +151256,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 = path196.isAbsolute(filePath) ? filePath : path196.join(directory, filePath);
+    const fullPath = path198.isAbsolute(filePath) ? filePath : path198.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -150533,7 +151303,7 @@ async function syntaxCheck(input, directory, config3) {
         result.skipped_reason = "binary_file";
         return { result, counted: false, failed: false, skipped: true };
       }
-      const ext = path196.extname(filePath).toLowerCase();
+      const ext = path198.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -150645,7 +151415,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs133 from "node:fs";
-import * as path197 from "node:path";
+import * as path199 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES10 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -150711,9 +151481,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path197.resolve(paths);
-    const normalizedCwd = path197.resolve(cwd);
-    const normalizedResolved = path197.resolve(resolvedPath);
+    const resolvedPath = path199.resolve(paths);
+    const normalizedCwd = path199.resolve(cwd);
+    const normalizedResolved = path199.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -150729,7 +151499,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path197.extname(filePath).toLowerCase();
+  const ext = path199.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
@@ -150744,7 +151514,7 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES6.has(entry)) {
       continue;
     }
-    const fullPath = path197.join(dir, entry);
+    const fullPath = path199.join(dir, entry);
     let stat14;
     try {
       stat14 = fs133.statSync(fullPath);
@@ -150856,7 +151626,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path197.extname(scanPath)}`,
+          error: `unsupported file extension: ${path199.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -150906,17 +151676,17 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs137 from "node:fs";
-import * as path201 from "node:path";
+import * as path203 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
 import * as fs135 from "node:fs";
-import * as path199 from "node:path";
+import * as path201 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs134 from "node:fs";
-import * as path198 from "node:path";
+import * as path200 from "node:path";
 var _internals118 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
@@ -150990,10 +151760,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path198.isAbsolute(excludeRelPath) ? excludeRelPath : path198.join(directory, excludeRelPath);
+    const excludePath = path200.isAbsolute(excludeRelPath) ? excludeRelPath : path200.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs134.mkdirSync(path198.dirname(excludePath), { recursive: true });
+        fs134.mkdirSync(path200.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
           existing = fs134.readFileSync(excludePath, "utf8");
@@ -151037,7 +151807,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 var _internals119 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path199.join(directory, ".swarm", "plan.json");
+    const planPath = path201.join(directory, ".swarm", "plan.json");
     if (!fs135.existsSync(planPath))
       return null;
     const raw = fs135.readFileSync(planPath, "utf-8");
@@ -151143,7 +151913,7 @@ init_telemetry();
 // src/turbo/lean/task-completion.ts
 init_file_locks();
 import * as fs136 from "node:fs";
-import * as path200 from "node:path";
+import * as path202 from "node:path";
 var _internals120 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
@@ -151162,7 +151932,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path200.basename(file3);
+    const fileName = path202.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -151174,7 +151944,7 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path200.join(directory, ".swarm", "turbo-state.json");
+    const statePath = path202.join(directory, ".swarm", "turbo-state.json");
     if (!fs136.existsSync(statePath)) {
       return {
         ok: false,
@@ -151258,11 +152028,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path200.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path200.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path200.resolve(evidencePath);
-  const resolvedDir = path200.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path200.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path202.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path202.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path202.resolve(evidencePath);
+  const resolvedDir = path202.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path202.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -151302,7 +152072,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path200.join(directory, ".swarm", "plan.json");
+    const planPath = path202.join(directory, ".swarm", "plan.json");
     const planRaw = fs136.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
@@ -151391,7 +152161,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path201.basename(file3);
+    const fileName = path203.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -151430,7 +152200,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path201.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path203.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs137.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -151508,7 +152278,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path201.join(resolvedDir, ".swarm", "plan.json");
+        const planPath = path203.join(resolvedDir, ".swarm", "plan.json");
         const planRaw = fs137.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -151719,7 +152489,7 @@ function checkCouncilGate(workingDirectory, taskId) {
     return { blocked: false, reason: "", active: false };
   }
   try {
-    const planPath = path201.join(workingDirectory, ".swarm", "plan.json");
+    const planPath = path203.join(workingDirectory, ".swarm", "plan.json");
     const planRaw = fs137.readFileSync(planPath, "utf-8");
     const planObj = JSON.parse(planRaw);
     if (planObj.swarm && planObj.title) {
@@ -151806,7 +152576,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   directory = resolveResult.directory;
-  const planPath = path201.join(directory, ".swarm", "plan.json");
+  const planPath = path203.join(directory, ".swarm", "plan.json");
   if (!fs137.existsSync(planPath)) {
     return {
       success: false,
@@ -151815,9 +152585,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs137.realpathSync(path201.resolve(directory));
-    const canonicalRoot = fs137.realpathSync(path201.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path201.sep)) {
+    const canonicalDir = fs137.realpathSync(path203.resolve(directory));
+    const canonicalRoot = fs137.realpathSync(path203.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path203.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.`,
@@ -151829,8 +152599,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path201.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs137.mkdirSync(path201.dirname(evidencePath), { recursive: true });
+      const evidencePath = path203.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs137.mkdirSync(path203.dirname(evidencePath), { recursive: true });
       const fd = fs137.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -151854,7 +152624,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath2 = path201.join(directory, ".swarm", "plan.json");
+      const planPath2 = path203.join(directory, ".swarm", "plan.json");
       const planRaw = fs137.readFileSync(planPath2, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -151971,9 +152741,9 @@ import * as zlib from "node:zlib";
 // src/evidence/documents.ts
 init_utils2();
 init_redaction();
-import { createHash as createHash24 } from "node:crypto";
+import { createHash as createHash25 } from "node:crypto";
 import { appendFile as appendFile17, mkdir as mkdir34 } from "node:fs/promises";
-import * as path202 from "node:path";
+import * as path204 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) {
@@ -151981,7 +152751,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(path202.dirname(filePath), { recursive: true });
+    await mkdir34(path204.dirname(filePath), { recursive: true });
     await appendFile17(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -152015,7 +152785,7 @@ function createEvidenceDocumentRecord(input, defaultCapturedAt) {
   };
 }
 function createEvidenceDocumentId(input) {
-  const hash4 = createHash24("sha256").update([
+  const hash4 = createHash25("sha256").update([
     input.sourceType,
     input.query ?? "",
     input.title ?? "",
@@ -152351,7 +153121,7 @@ function performHttpRequest(args2) {
   };
   if (useSni)
     options.servername = url3.hostname;
-  return new Promise((resolve78, reject) => {
+  return new Promise((resolve79, reject) => {
     let req;
     const onResponse = (res) => {
       const normHeaders = {};
@@ -152359,7 +153129,7 @@ function performHttpRequest(args2) {
         normHeaders[key] = Array.isArray(value) ? value[0] : value;
       }
       res.on("error", () => {});
-      resolve78({
+      resolve79({
         status: res.statusCode ?? 0,
         headers: normHeaders,
         body: res,
@@ -152998,7 +153768,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path203 from "node:path";
+import * as path205 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -153074,7 +153844,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, path203.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
+        const result = await curateAndStoreSwarm(lessons, path205.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
           skipAutoPromotion: true,
           llmDelegate: createCuratorLLMDelegate(dirResult.directory, "phase"),
           enrichmentQuota: {
@@ -153121,7 +153891,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs138 from "node:fs";
-import path204 from "node:path";
+import path206 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -153175,7 +153945,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path204.join("evidence", String(phase), filename);
+  const relativePath = path206.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -153186,10 +153956,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path204.dirname(validatedPath);
+  const evidenceDir = path206.dirname(validatedPath);
   try {
     await fs138.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path204.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path206.join(evidenceDir, `.${filename}.tmp`);
     await fs138.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs138.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -153290,7 +154060,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs139 from "node:fs";
-import path205 from "node:path";
+import path207 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -153404,7 +154174,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path205.join("evidence", filename);
+  const relativePath = path207.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -153418,10 +154188,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path205.dirname(validatedPath);
+  const evidenceDir = path207.dirname(validatedPath);
   try {
     await fs139.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path205.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path207.join(evidenceDir, `.${filename}.tmp`);
     await fs139.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs139.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -153481,7 +154251,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs140 from "node:fs";
-import path206 from "node:path";
+import path208 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -153529,7 +154299,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path206.join("evidence", String(phase), filename);
+  const relativePath = path208.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -153540,10 +154310,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path206.dirname(validatedPath);
+  const evidenceDir = path208.dirname(validatedPath);
   try {
     await fs140.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path206.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path208.join(evidenceDir, `.${filename}.tmp`);
     await fs140.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs140.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -153593,7 +154363,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs141 from "node:fs";
-import path207 from "node:path";
+import path209 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -153667,7 +154437,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path207.join("evidence", String(phase), filename);
+  const relativePath = path209.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -153678,10 +154448,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path207.dirname(validatedPath);
+  const evidenceDir = path209.dirname(validatedPath);
   try {
     await fs141.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path207.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path209.join(evidenceDir, `.${filename}.tmp`);
     await fs141.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs141.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -153760,6 +154530,7 @@ var TOOL_MANIFEST = defineHandlers({
   sbom_generate: () => sbom_generate,
   checkpoint: () => checkpoint,
   pkg_audit: () => pkg_audit,
+  parse_lane_candidates: () => parse_lane_candidates,
   test_runner: () => test_runner,
   test_impact: () => test_impact,
   mutation_test: () => mutation_test,
@@ -153895,7 +154666,7 @@ ${footerLines.join(`
 init_warning_buffer();
 var _heartbeatTimers = new Map;
 var SWARM_COMMAND_SYSTEM_RULE_TAG = "[opencode-swarm:swarm-command-rule]";
-var PACKAGE_ROOT2 = path209.resolve(path209.dirname(fileURLToPath5(import.meta.url)), "..");
+var PACKAGE_ROOT2 = path211.resolve(path211.dirname(fileURLToPath5(import.meta.url)), "..");
 var SYNC_BUNDLED_SKILLS_TIMEOUT_MS = 2000;
 function createSwarmCommandSystemRuleHook(agentDefinitions, registeredAgents) {
   return async (input, output) => {
@@ -154216,7 +154987,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 = path209.resolve(ctx.directory, ".swarm");
+    const swarmDir = path211.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -154880,7 +155651,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path209.basename(path209.dirname(s.skillPath));
+                    desc = path211.basename(path211.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -154890,7 +155661,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path209.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path211.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {