opencode-swarm 6.33.1 → 6.33.3

package/dist/index.js

@@ -14146,7 +14146,7 @@ var init_zod = __esm(() => {
 });
 
 // src/config/evidence-schema.ts
-var EVIDENCE_MAX_JSON_BYTES, EVIDENCE_MAX_PATCH_BYTES, EVIDENCE_MAX_TASK_BYTES, EvidenceTypeSchema, EvidenceVerdictSchema, BaseEvidenceSchema, ReviewEvidenceSchema, TestEvidenceSchema, DiffEvidenceSchema, ApprovalEvidenceSchema, NoteEvidenceSchema, RetrospectiveEvidenceSchema, SyntaxEvidenceSchema, PlaceholderEvidenceSchema, SastEvidenceSchema, SbomEvidenceSchema, BuildEvidenceSchema, QualityBudgetEvidenceSchema, EvidenceSchema, EvidenceBundleSchema;
+var EVIDENCE_MAX_JSON_BYTES, EVIDENCE_MAX_PATCH_BYTES, EVIDENCE_MAX_TASK_BYTES, EvidenceTypeSchema, EvidenceVerdictSchema, BaseEvidenceSchema, ReviewEvidenceSchema, TestEvidenceSchema, DiffEvidenceSchema, ApprovalEvidenceSchema, NoteEvidenceSchema, RetrospectiveEvidenceSchema, SyntaxEvidenceSchema, PlaceholderEvidenceSchema, SastEvidenceSchema, SbomEvidenceSchema, BuildEvidenceSchema, QualityBudgetEvidenceSchema, SecretscanEvidenceSchema, EvidenceSchema, EvidenceBundleSchema;
 var init_evidence_schema = __esm(() => {
   init_zod();
   EVIDENCE_MAX_JSON_BYTES = 500 * 1024;
@@ -14164,7 +14164,8 @@ var init_evidence_schema = __esm(() => {
     "sast",
     "sbom",
     "build",
-    "quality_budget"
+    "quality_budget",
+    "secretscan"
   ]);
   EvidenceVerdictSchema = exports_external.enum([
     "pass",
@@ -14245,7 +14246,14 @@ var init_evidence_schema = __esm(() => {
       approach: exports_external.string().min(1),
       result: exports_external.enum(["success", "failure", "partial"]),
       abandoned_reason: exports_external.string().optional()
-    })).max(10).default([])
+    })).max(10).default([]),
+    error_taxonomy: exports_external.array(exports_external.enum([
+      "planning_error",
+      "interface_mismatch",
+      "logic_error",
+      "scope_creep",
+      "gate_evasion"
+    ])).default([])
   });
   SyntaxEvidenceSchema = BaseEvidenceSchema.extend({
     type: exports_external.literal("syntax"),
@@ -14356,6 +14364,13 @@ var init_evidence_schema = __esm(() => {
     })).default([]),
     files_analyzed: exports_external.array(exports_external.string())
   });
+  SecretscanEvidenceSchema = BaseEvidenceSchema.extend({
+    type: exports_external.literal("secretscan"),
+    findings_count: exports_external.number().int().min(0).default(0),
+    scan_directory: exports_external.string().optional(),
+    files_scanned: exports_external.number().int().min(0).default(0),
+    skipped_files: exports_external.number().int().min(0).default(0)
+  });
   EvidenceSchema = exports_external.discriminatedUnion("type", [
     ReviewEvidenceSchema,
     TestEvidenceSchema,
@@ -14368,7 +14383,8 @@ var init_evidence_schema = __esm(() => {
     SastEvidenceSchema,
     SbomEvidenceSchema,
     BuildEvidenceSchema,
-    QualityBudgetEvidenceSchema
+    QualityBudgetEvidenceSchema,
+    SecretscanEvidenceSchema
   ]);
   EvidenceBundleSchema = exports_external.object({
     schema_version: exports_external.literal("1.0.0"),
@@ -14458,7 +14474,8 @@ var init_schema = __esm(() => {
   AgentOverrideConfigSchema = exports_external.object({
     model: exports_external.string().optional(),
     temperature: exports_external.number().min(0).max(2).optional(),
-    disabled: exports_external.boolean().optional()
+    disabled: exports_external.boolean().optional(),
+    fallback_models: exports_external.array(exports_external.string()).max(3).optional()
   });
   SwarmConfigSchema = exports_external.object({
     name: exports_external.string().optional(),
@@ -14799,6 +14816,7 @@ var init_schema = __esm(() => {
     warning_threshold: exports_external.number().min(0.1).max(0.9).default(0.75),
     idle_timeout_minutes: exports_external.number().min(5).max(240).default(60),
     no_op_warning_threshold: exports_external.number().min(1).max(100).default(15),
+    max_coder_revisions: exports_external.number().int().min(1).max(20).default(5),
     qa_gates: exports_external.object({
       required_tools: exports_external.array(exports_external.string().min(1)).default([
         "diff",
@@ -15400,6 +15418,9 @@ import * as path4 from "path";
 function isValidEvidenceType(type) {
   return VALID_EVIDENCE_TYPES.includes(type);
 }
+function isSecretscanEvidence(evidence) {
+  return evidence.type === "secretscan";
+}
 function sanitizeTaskId(taskId) {
   if (!taskId || taskId.length === 0) {
     throw new Error("Invalid task ID: empty string");
@@ -15652,11 +15673,12 @@ var init_manager = __esm(() => {
     "sast",
     "sbom",
     "build",
-    "quality_budget"
+    "quality_budget",
+    "secretscan"
   ];
   TASK_ID_REGEX = /^\d+\.\d+(\.\d+)*$/;
   RETRO_TASK_ID_REGEX = /^retro-\d+$/;
-  INTERNAL_TOOL_ID_REGEX = /^(?:sast_scan|quality_budget|syntax_check|placeholder_scan|sbom_generate|build)$/;
+  INTERNAL_TOOL_ID_REGEX = /^(?:sast_scan|quality_budget|syntax_check|placeholder_scan|sbom_generate|build|secretscan)$/;
   LEGACY_TASK_COMPLEXITY_MAP = {
     low: "simple",
     medium: "moderate",
@@ -36250,7 +36272,7 @@ __export(exports_gate_evidence, {
   deriveRequiredGates: () => deriveRequiredGates,
   DEFAULT_REQUIRED_GATES: () => DEFAULT_REQUIRED_GATES
 });
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync8, unlinkSync as unlinkSync5 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync9, unlinkSync as unlinkSync5 } from "fs";
 import * as path30 from "path";
 function isValidTaskId2(taskId) {
   if (!taskId)
@@ -36315,7 +36337,7 @@ async function atomicWrite(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await Bun.write(tempPath, content);
-    renameSync8(tempPath, targetPath);
+    renameSync9(tempPath, targetPath);
   } finally {
     try {
       unlinkSync5(tempPath);
@@ -37910,11 +37932,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path47) {
+      function locateFile(path48) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path47, scriptDirectory);
+          return Module["locateFile"](path48, scriptDirectory);
         }
-        return scriptDirectory + path47;
+        return scriptDirectory + path48;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -39662,7 +39684,7 @@ var init_runtime = __esm(() => {
 });
 
 // src/index.ts
-import * as path57 from "path";
+import * as path58 from "path";
 
 // src/agents/index.ts
 init_config();
@@ -39729,6 +39751,10 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
     scopeViolationDetected: false,
     modifiedFilesThisCoderTask: [],
     turboMode: false,
+    model_fallback_index: 0,
+    modelFallbackExhausted: false,
+    coderRevisions: 0,
+    revisionLimitHit: false,
     loopDetectionWindow: [],
     pendingAdvisoryMessages: []
   };
@@ -39837,12 +39863,24 @@ function ensureAgentSession(sessionId, agentName, directory) {
     if (session.turboMode === undefined) {
       session.turboMode = false;
     }
+    if (session.model_fallback_index === undefined) {
+      session.model_fallback_index = 0;
+    }
+    if (session.modelFallbackExhausted === undefined) {
+      session.modelFallbackExhausted = false;
+    }
     if (session.loopDetectionWindow === undefined) {
       session.loopDetectionWindow = [];
     }
     if (session.pendingAdvisoryMessages === undefined) {
       session.pendingAdvisoryMessages = [];
     }
+    if (session.coderRevisions === undefined) {
+      session.coderRevisions = 0;
+    }
+    if (session.revisionLimitHit === undefined) {
+      session.revisionLimitHit = false;
+    }
     session.lastToolCallTime = now;
     return session;
   }
@@ -44112,14 +44150,18 @@ async function readCuratorSummary(directory) {
     }
     return parsed;
   } catch {
-    console.warn("Failed to parse curator-summary.json: invalid JSON");
+    if (process.env.DEBUG_SWARM) {
+      console.warn("Failed to parse curator-summary.json: invalid JSON");
+    }
     return null;
   }
 }
 async function writeCuratorSummary(directory, summary) {
   const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
   fs7.mkdirSync(path12.dirname(resolvedPath), { recursive: true });
-  await Bun.write(resolvedPath, JSON.stringify(summary, null, 2));
+  const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+  await Bun.write(tempPath, JSON.stringify(summary, null, 2));
+  fs7.renameSync(tempPath, resolvedPath);
 }
 function normalizeAgentName(name2) {
   return name2.toLowerCase().replace(/^(mega|paid|local|lowtier|modelrelay)_/, "");
@@ -44143,7 +44185,9 @@ function filterPhaseEvents(eventsJsonl, phase, sinceTimestamp) {
         }
       }
     } catch {
-      console.warn("filterPhaseEvents: skipping malformed line");
+      if (process.env.DEBUG_SWARM) {
+        console.warn("filterPhaseEvents: skipping malformed line");
+      }
     }
   }
   return filtered;
@@ -46473,7 +46517,7 @@ async function handleExportCommand(directory, _args) {
 // src/commands/handoff.ts
 init_utils2();
 import crypto3 from "crypto";
-import { renameSync as renameSync5 } from "fs";
+import { renameSync as renameSync6 } from "fs";
 
 // src/services/handoff-service.ts
 init_utils2();
@@ -46774,7 +46818,7 @@ function formatHandoffMarkdown(data) {
 
 // src/session/snapshot-writer.ts
 init_utils2();
-import { mkdirSync as mkdirSync7, renameSync as renameSync4 } from "fs";
+import { mkdirSync as mkdirSync7, renameSync as renameSync5 } from "fs";
 import * as path19 from "path";
 var pendingWrite = null;
 var lastWritePromise = Promise.resolve();
@@ -46839,13 +46883,17 @@ function serializeAgentSession(s) {
     taskWorkflowStates: Object.fromEntries(s.taskWorkflowStates ?? new Map),
     ...s.scopeViolationDetected !== undefined && {
       scopeViolationDetected: s.scopeViolationDetected
-    }
+    },
+    model_fallback_index: s.model_fallback_index ?? 0,
+    modelFallbackExhausted: s.modelFallbackExhausted ?? false,
+    coderRevisions: s.coderRevisions ?? 0,
+    revisionLimitHit: s.revisionLimitHit ?? false
   };
 }
 async function writeSnapshot(directory, state) {
   try {
     const snapshot = {
-      version: 1,
+      version: 2,
       writtenAt: Date.now(),
       toolAggregates: Object.fromEntries(state.toolAggregates),
       activeAgent: Object.fromEntries(state.activeAgent),
@@ -46861,9 +46909,11 @@ async function writeSnapshot(directory, state) {
     mkdirSync7(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await Bun.write(tempPath, content);
-    renameSync4(tempPath, resolvedPath);
+    renameSync5(tempPath, resolvedPath);
   } catch (error93) {
-    console.warn("[snapshot-writer] write failed:", error93 instanceof Error ? error93.message : String(error93));
+    if (process.env.DEBUG_SWARM) {
+      console.warn("[snapshot-writer] write failed:", error93 instanceof Error ? error93.message : String(error93));
+    }
   }
 }
 function createSnapshotWriterHook(directory) {
@@ -46893,7 +46943,7 @@ async function handleHandoffCommand(directory, _args) {
   const resolvedPath = validateSwarmPath(directory, "handoff.md");
   const tempPath = `${resolvedPath}.tmp.${crypto3.randomUUID()}`;
   await Bun.write(tempPath, markdown);
-  renameSync5(tempPath, resolvedPath);
+  renameSync6(tempPath, resolvedPath);
   await writeSnapshot(directory, swarmState);
   await flushPendingSnapshot(directory);
   return `## Handoff Brief Written
@@ -47639,7 +47689,7 @@ async function handleResetSessionCommand(directory, _args) {
 // src/summaries/manager.ts
 init_utils2();
 init_utils();
-import { mkdirSync as mkdirSync8, readdirSync as readdirSync7, renameSync as renameSync6, rmSync as rmSync3, statSync as statSync7 } from "fs";
+import { mkdirSync as mkdirSync8, readdirSync as readdirSync7, renameSync as renameSync7, rmSync as rmSync3, statSync as statSync7 } from "fs";
 import * as path26 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
@@ -47683,7 +47733,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   const tempPath = path26.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await Bun.write(tempPath, entryJson);
-    renameSync6(tempPath, summaryPath);
+    renameSync7(tempPath, summaryPath);
   } catch (error93) {
     try {
       rmSync3(tempPath, { force: true });
@@ -48863,8 +48913,46 @@ async function executeWriteRetro(args2, directory) {
     top_rejection_reasons: args2.top_rejection_reasons ?? [],
     lessons_learned: (args2.lessons_learned ?? []).slice(0, 5),
     user_directives: [],
-    approaches_tried: []
+    approaches_tried: [],
+    error_taxonomy: []
   };
+  const taxonomy = [];
+  try {
+    for (const taskSuffix of ["1", "2", "3", "4", "5"]) {
+      const phaseTaskId = `${phase}.${taskSuffix}`;
+      const result = await loadEvidence(directory, phaseTaskId);
+      if (result.status !== "found")
+        continue;
+      const bundle = result.bundle;
+      for (const entry of bundle.entries) {
+        const e = entry;
+        if (e.type === "review" && e.verdict === "fail") {
+          const reasonParts = [];
+          if (typeof e.summary === "string")
+            reasonParts.push(e.summary);
+          if (Array.isArray(e.issues)) {
+            for (const iss of e.issues) {
+              if (typeof iss.message === "string")
+                reasonParts.push(iss.message);
+            }
+          }
+          const reason = reasonParts.join(" ");
+          if (/signature|type|contract|interface/i.test(reason)) {
+            taxonomy.push("interface_mismatch");
+          } else {
+            taxonomy.push("logic_error");
+          }
+        } else if (e.type === "test" && e.verdict === "fail") {
+          taxonomy.push("logic_error");
+        } else if (e.agent === "scope_guard" && e.verdict === "fail") {
+          taxonomy.push("scope_creep");
+        } else if (e.agent === "loop_detector" && e.verdict === "fail") {
+          taxonomy.push("gate_evasion");
+        }
+      }
+    }
+  } catch {}
+  retroEntry.error_taxonomy = [...new Set(taxonomy)];
   try {
     await saveEvidence(directory, taskId, retroEntry);
     return JSON.stringify({
@@ -49187,7 +49275,7 @@ init_constants();
 init_schema();
 
 // src/hooks/agent-activity.ts
-import { renameSync as renameSync7, unlinkSync as unlinkSync4 } from "fs";
+import { renameSync as renameSync8, unlinkSync as unlinkSync4 } from "fs";
 init_utils();
 init_utils2();
 function createAgentActivityHooks(config3, directory) {
@@ -49261,7 +49349,7 @@ async function doFlush(directory) {
     const tempPath = `${path29}.tmp`;
     try {
       await Bun.write(tempPath, updated);
-      renameSync7(tempPath, path29);
+      renameSync8(tempPath, path29);
     } catch (writeError) {
       try {
         unlinkSync4(tempPath);
@@ -49895,6 +49983,7 @@ function detectLoop(sessionId, toolName, args2) {
 
 // src/hooks/guardrails.ts
 var storedInputArgs = new Map;
+var TRANSIENT_MODEL_ERROR_PATTERN = /rate.?limit|429|503|timeout|overloaded|model.?not.?found|temporarily unavailable|server error/i;
 function getStoredInputArgs(callID) {
   return storedInputArgs.get(callID);
 }
@@ -50072,6 +50161,9 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
           const coderSession = swarmState.agentSessions.get(input.sessionID);
           if (coderSession) {
             coderSession.modifiedFilesThisCoderTask = [];
+            if (!coderSession.revisionLimitHit) {
+              coderSession.coderRevisions = 0;
+            }
           }
         }
       }
@@ -50080,7 +50172,7 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
         const loopResult = detectLoop(input.sessionID, input.tool, loopArgs);
         if (loopResult.count >= 5) {
           throw new Error(`CIRCUIT BREAKER: Delegation loop detected (${loopResult.count} identical patterns). Session paused. Ask the user for guidance.`);
-        } else if (loopResult.count === 3) {
+        } else if (loopResult.count >= 3 && loopResult.count < 5) {
           const agentName2 = typeof loopArgs?.subagent_type === "string" ? loopArgs.subagent_type : "agent";
           const loopSession = swarmState.agentSessions.get(input.sessionID);
           if (loopSession) {
@@ -50411,6 +50503,16 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
         }
         if (delegation.isDelegation && delegation.targetAgent === "coder" && session.lastCoderDelegationTaskId) {
           session.currentTaskId = session.lastCoderDelegationTaskId;
+          if (!session.revisionLimitHit) {
+            session.coderRevisions++;
+            const maxRevisions = cfg.max_coder_revisions ?? 5;
+            if (session.coderRevisions >= maxRevisions) {
+              session.revisionLimitHit = true;
+              session.pendingAdvisoryMessages ??= [];
+              session.pendingAdvisoryMessages.push(`CODER REVISION LIMIT: Agent has been revised ${session.coderRevisions} times ` + `(max: ${maxRevisions}) for task ${session.currentTaskId ?? "unknown"}. ` + `Escalate to user or consider a fundamentally different approach.`);
+              swarmState.pendingEvents++;
+            }
+          }
           session.partialGateWarningsIssuedForTask?.delete(session.currentTaskId);
           if (session.declaredCoderScope !== null) {
             const undeclaredFiles = session.modifiedFilesThisCoderTask.map((f) => f.replace(/[\r\n\t]/g, "_")).filter((f) => !isInDeclaredScope(f, session.declaredCoderScope));
@@ -50442,9 +50544,26 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
       const hasError = output.output === null || output.output === undefined;
       if (hasError) {
         window2.consecutiveErrors++;
+        if (session) {
+          const outputStr = typeof output.output === "string" ? output.output : "";
+          const errorContent = output.error ?? outputStr;
+          if (typeof errorContent === "string" && TRANSIENT_MODEL_ERROR_PATTERN.test(errorContent) && !session.modelFallbackExhausted) {
+            session.model_fallback_index++;
+            session.modelFallbackExhausted = true;
+            session.pendingAdvisoryMessages ??= [];
+            session.pendingAdvisoryMessages.push(`MODEL FALLBACK: Transient model error detected (attempt ${session.model_fallback_index}). ` + `The agent model may be rate-limited, overloaded, or temporarily unavailable. ` + `Consider retrying with a fallback model or waiting before retrying.`);
+            swarmState.pendingEvents++;
+          }
+        }
       } else {
         window2.consecutiveErrors = 0;
         window2.lastSuccessTimeMs = Date.now();
+        if (session) {
+          if (session.model_fallback_index > 0) {
+            session.model_fallback_index = 0;
+            session.modelFallbackExhausted = false;
+          }
+        }
       }
     },
     messagesTransform: async (_input, output) => {
@@ -50740,7 +50859,7 @@ function extractPlanTaskId(text) {
 function getSeedTaskId(session) {
   return session.currentTaskId ?? session.lastCoderDelegationTaskId;
 }
-function getEvidenceTaskId(session, directory) {
+async function getEvidenceTaskId(session, directory) {
   const primary = session.currentTaskId ?? session.lastCoderDelegationTaskId;
   if (primary)
     return primary;
@@ -50757,7 +50876,7 @@ function getEvidenceTaskId(session, directory) {
     if (!resolvedPlanPath.startsWith(resolvedDirectory + path31.sep) && resolvedPlanPath !== resolvedDirectory) {
       return null;
     }
-    const planContent = fs19.readFileSync(resolvedPlanPath, "utf-8");
+    const planContent = await fs19.promises.readFile(resolvedPlanPath, "utf-8");
     const plan = JSON.parse(planContent);
     if (!plan || !Array.isArray(plan.phases)) {
       return null;
@@ -50877,7 +50996,7 @@ function createDelegationGateHook(config3, directory) {
       }
       if (typeof subagentType === "string") {
         const rawTaskId = directArgs?.task_id;
-        const evidenceTaskId = typeof rawTaskId === "string" && rawTaskId.length <= 20 && /^\d+\.\d+$/.test(rawTaskId.trim()) ? rawTaskId.trim() : getEvidenceTaskId(session, directory);
+        const evidenceTaskId = typeof rawTaskId === "string" && rawTaskId.length <= 20 && /^\d+\.\d+$/.test(rawTaskId.trim()) ? rawTaskId.trim() : await getEvidenceTaskId(session, directory);
         if (evidenceTaskId) {
           try {
             const turbo = hasActiveTurboMode();
@@ -50997,7 +51116,7 @@ function createDelegationGateHook(config3, directory) {
         }
         {
           const rawTaskId = directArgs?.task_id;
-          const evidenceTaskId = typeof rawTaskId === "string" && rawTaskId.length <= 20 && /^\d+\.\d+$/.test(rawTaskId.trim()) ? rawTaskId.trim() : getEvidenceTaskId(session, directory);
+          const evidenceTaskId = typeof rawTaskId === "string" && rawTaskId.length <= 20 && /^\d+\.\d+$/.test(rawTaskId.trim()) ? rawTaskId.trim() : await getEvidenceTaskId(session, directory);
           if (evidenceTaskId) {
             try {
               const turbo = hasActiveTurboMode();
@@ -51094,7 +51213,7 @@ ${trimComment}${after}`;
       const currentTaskId = planTaskId ?? taskIdFromLine;
       const coderDelegationPattern = /(?:^|\n)\s*(?:\w+_)?coder\s*\n\s*TASK:/i;
       const isCoderDelegation = coderDelegationPattern.test(text);
-      const priorCoderTaskId = sessionID ? ensureAgentSession(sessionID).lastCoderDelegationTaskId ?? null : null;
+      const priorCoderTaskId = sessionID ? swarmState.agentSessions.get(sessionID)?.lastCoderDelegationTaskId ?? null : null;
       if (sessionID && isCoderDelegation && currentTaskId) {
         const session = ensureAgentSession(sessionID);
         session.lastCoderDelegationTaskId = currentTaskId;
@@ -54872,7 +54991,11 @@ function deserializeAgentSession(s) {
     lastScopeViolation: null,
     scopeViolationDetected: s.scopeViolationDetected,
     modifiedFilesThisCoderTask: [],
-    pendingAdvisoryMessages: s.pendingAdvisoryMessages ?? []
+    pendingAdvisoryMessages: s.pendingAdvisoryMessages ?? [],
+    model_fallback_index: s.model_fallback_index ?? 0,
+    modelFallbackExhausted: s.modelFallbackExhausted ?? false,
+    coderRevisions: s.coderRevisions ?? 0,
+    revisionLimitHit: s.revisionLimitHit ?? false
   };
 }
 async function readSnapshot(directory) {
@@ -54888,7 +55011,7 @@ async function readSnapshot(directory) {
         return;
       return value;
     });
-    if (parsed.version !== 1) {
+    if (parsed.version !== 1 && parsed.version !== 2) {
       return null;
     }
     return parsed;
@@ -55115,6 +55238,7 @@ var build_check = createSwarmTool({
 });
 // src/tools/check-gate-status.ts
 init_dist();
+init_manager();
 init_create_tool();
 import * as fs27 from "fs";
 import * as path39 from "path";
@@ -55238,13 +55362,37 @@ var check_gate_status = createSwarmTool({
         missingGates.push(requiredGate);
       }
     }
-    const status = missingGates.length === 0 ? "all_passed" : "incomplete";
+    let status = missingGates.length === 0 ? "all_passed" : "incomplete";
     let message;
     if (status === "all_passed") {
       message = `All required gates have passed for task "${taskIdInput}".`;
     } else {
       message = `Task "${taskIdInput}" is incomplete. Missing gates: ${missingGates.join(", ")}.`;
     }
+    let secretscanVerdict = "not_run";
+    try {
+      const evidenceResult = await loadEvidence(directory, taskIdInput);
+      if (evidenceResult.status === "found") {
+        const secretscanEntries = evidenceResult.bundle.entries.filter((entry) => entry.type === "secretscan");
+        if (secretscanEntries.length > 0) {
+          const lastSecretscan = secretscanEntries[secretscanEntries.length - 1];
+          if (isSecretscanEvidence(lastSecretscan)) {
+            if (lastSecretscan.verdict === "fail" || lastSecretscan.verdict === "rejected") {
+              secretscanVerdict = "fail";
+              missingGates.push("secretscan (BLOCKED \u2014 secrets detected)");
+              if (status === "all_passed") {
+                status = "incomplete";
+              }
+              message = `BLOCKED: Secretscan found secrets in prior scan. ${message}`;
+            } else if (lastSecretscan.verdict === "pass" || lastSecretscan.verdict === "approved" || lastSecretscan.verdict === "info") {
+              secretscanVerdict = "pass";
+            }
+          }
+        } else {
+          message += " Advisory: No secretscan evidence found for this task. Consider running secretscan.";
+        }
+      }
+    } catch {}
     const todoScan = evidenceData.todo_scan;
     const result = {
       taskId: taskIdInput,
@@ -55254,7 +55402,8 @@ var check_gate_status = createSwarmTool({
       missing_gates: missingGates,
       gates: gatesMap,
       message,
-      todo_scan: todoScan ?? null
+      todo_scan: todoScan ?? null,
+      secretscan_verdict: secretscanVerdict
     };
     return JSON.stringify(result, null, 2);
   }
@@ -55980,6 +56129,391 @@ var diff = createSwarmTool({
     }
   }
 });
+// src/tools/doc-scan.ts
+init_dist();
+init_schema();
+import * as crypto4 from "crypto";
+import * as fs30 from "fs";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import * as path42 from "path";
+init_create_tool();
+var SKIP_DIRECTORIES2 = new Set([
+  "node_modules",
+  ".git",
+  ".swarm",
+  "dist",
+  "build",
+  ".next",
+  "vendor"
+]);
+var SKIP_PATTERNS = [/\.test\./, /\.spec\./, /\.d\.ts$/];
+var MAX_SUMMARY_LENGTH = 200;
+var MAX_INDEXED_FILES = 100;
+var READ_LINES_LIMIT = 30;
+var MIN_LESSON_LENGTH = 15;
+var MAX_CONSTRAINTS_PER_DOC = 5;
+var MAX_CONSTRAINT_LENGTH = 200;
+var RELEVANCE_THRESHOLD = 0.1;
+var DEDUP_THRESHOLD = 0.6;
+function normalizeSeparators(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function matchesDocPattern(filePath, patterns) {
+  const normalizedPath = normalizeSeparators(filePath);
+  const basename5 = path42.basename(filePath);
+  for (const pattern of patterns) {
+    if (!pattern.includes("/") && !pattern.includes("\\")) {
+      if (basename5 === pattern) {
+        return true;
+      }
+      continue;
+    }
+    if (pattern.startsWith("**/")) {
+      const filenamePattern = pattern.slice(3);
+      if (basename5 === filenamePattern) {
+        return true;
+      }
+      continue;
+    }
+    const patternNormalized = normalizeSeparators(pattern);
+    const dirPrefix = patternNormalized.replace(/\/\*\*.*$/, "").replace(/\/\*.*$/, "");
+    if (normalizedPath.startsWith(dirPrefix + "/") || normalizedPath === dirPrefix) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractTitleAndSummary(content, filename) {
+  const lines = content.split(`
+`);
+  let title = filename;
+  let summary = "";
+  let foundTitle = false;
+  const potentialSummaryLines = [];
+  for (let i2 = 0;i2 < lines.length && i2 < READ_LINES_LIMIT; i2++) {
+    const line = lines[i2].trim();
+    if (!foundTitle && line.startsWith("# ")) {
+      title = line.slice(2).trim();
+      foundTitle = true;
+      continue;
+    }
+    if (line && !line.startsWith("#")) {
+      potentialSummaryLines.push(line);
+    }
+  }
+  for (const line of potentialSummaryLines) {
+    summary += (summary ? " " : "") + line;
+    if (summary.length >= MAX_SUMMARY_LENGTH) {
+      break;
+    }
+  }
+  if (summary.length > MAX_SUMMARY_LENGTH) {
+    summary = summary.slice(0, MAX_SUMMARY_LENGTH - 3) + "...";
+  }
+  return { title, summary };
+}
+function stripMarkdown(text) {
+  return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s*[-*\u2022]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "").trim();
+}
+async function scanDocIndex(directory) {
+  const manifestPath = path42.join(directory, ".swarm", "doc-manifest.json");
+  const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
+  const extraPatterns = [
+    "ARCHITECTURE.md",
+    "CLAUDE.md",
+    "AGENTS.md",
+    ".github/*.md",
+    "doc/**/*.md"
+  ];
+  const allPatterns = [...defaultPatterns, ...extraPatterns];
+  try {
+    const manifestContent = await readFile6(manifestPath, "utf-8");
+    const existingManifest = JSON.parse(manifestContent);
+    if (existingManifest.schema_version === 1 && existingManifest.files) {
+      let cacheValid = true;
+      for (const file3 of existingManifest.files) {
+        try {
+          const fullPath = path42.join(directory, file3.path);
+          const stat2 = fs30.statSync(fullPath);
+          if (stat2.mtimeMs > new Date(existingManifest.scanned_at).getTime()) {
+            cacheValid = false;
+            break;
+          }
+        } catch {
+          cacheValid = false;
+          break;
+        }
+      }
+      if (cacheValid) {
+        return { manifest: existingManifest, cached: true };
+      }
+    }
+  } catch {}
+  const discoveredFiles = [];
+  let rawEntries;
+  try {
+    rawEntries = fs30.readdirSync(directory, { recursive: true });
+  } catch {
+    const manifest2 = {
+      schema_version: 1,
+      scanned_at: new Date().toISOString(),
+      files: []
+    };
+    return { manifest: manifest2, cached: false };
+  }
+  const entries = rawEntries.filter((e) => typeof e === "string");
+  for (const entry of entries) {
+    const fullPath = path42.join(directory, entry);
+    let stat2;
+    try {
+      stat2 = fs30.statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (!stat2.isFile())
+      continue;
+    const pathParts = normalizeSeparators(entry).split("/");
+    let skipThisFile = false;
+    for (const part of pathParts) {
+      if (SKIP_DIRECTORIES2.has(part)) {
+        skipThisFile = true;
+        break;
+      }
+    }
+    if (skipThisFile)
+      continue;
+    for (const pattern of SKIP_PATTERNS) {
+      if (pattern.test(entry)) {
+        skipThisFile = true;
+        break;
+      }
+    }
+    if (skipThisFile)
+      continue;
+    if (!matchesDocPattern(entry, allPatterns)) {
+      continue;
+    }
+    let content;
+    try {
+      content = fs30.readFileSync(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const { title, summary } = extractTitleAndSummary(content, path42.basename(entry));
+    const lineCount = content.split(`
+`).length;
+    discoveredFiles.push({
+      path: entry,
+      title,
+      summary,
+      lines: lineCount,
+      mtime: stat2.mtimeMs
+    });
+  }
+  discoveredFiles.sort((a, b) => a.path.toLowerCase().localeCompare(b.path.toLowerCase()));
+  let truncated = false;
+  if (discoveredFiles.length > MAX_INDEXED_FILES) {
+    discoveredFiles.splice(MAX_INDEXED_FILES);
+    truncated = true;
+  }
+  if (truncated && discoveredFiles.length > 0) {
+    discoveredFiles[0].summary = `[Warning: ${MAX_INDEXED_FILES}+ docs found, listing first ${MAX_INDEXED_FILES}] ` + discoveredFiles[0].summary;
+  }
+  const manifest = {
+    schema_version: 1,
+    scanned_at: new Date().toISOString(),
+    files: discoveredFiles
+  };
+  try {
+    await mkdir5(path42.dirname(manifestPath), { recursive: true });
+    await writeFile5(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  } catch {}
+  return { manifest, cached: false };
+}
+var CONSTRAINT_PATTERNS = [
+  /\bMUST\b/,
+  /\bMUST NOT\b/,
+  /\bSHOULD\b/,
+  /\bSHOULD NOT\b/,
+  /\bDO NOT\b/,
+  /\bALWAYS\b/,
+  /\bNEVER\b/,
+  /\bREQUIRED\b/
+];
+var ACTION_WORDS = /\b(must|should|don't|avoid|ensure|use|follow)\b/i;
+function isConstraintLine(line) {
+  const upperLine = line.toUpperCase();
+  for (const pattern of CONSTRAINT_PATTERNS) {
+    if (pattern.test(upperLine)) {
+      return true;
+    }
+  }
+  if (/^\s*[-*\u2022]/.test(line) && ACTION_WORDS.test(line)) {
+    return true;
+  }
+  return false;
+}
+function extractConstraintsFromContent(content) {
+  const lines = content.split(`
+`);
+  const constraints = [];
+  for (const line of lines) {
+    if (constraints.length >= MAX_CONSTRAINTS_PER_DOC) {
+      break;
+    }
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    if (isConstraintLine(trimmed)) {
+      const cleaned = stripMarkdown(trimmed);
+      const len = cleaned.length;
+      if (len >= MIN_LESSON_LENGTH && len <= MAX_CONSTRAINT_LENGTH) {
+        constraints.push(cleaned);
+      }
+    }
+  }
+  return constraints;
+}
+async function extractDocConstraints(directory, taskFiles, taskDescription) {
+  const manifestPath = path42.join(directory, ".swarm", "doc-manifest.json");
+  let manifest;
+  try {
+    const content = await readFile6(manifestPath, "utf-8");
+    manifest = JSON.parse(content);
+  } catch {
+    const result = await scanDocIndex(directory);
+    manifest = result.manifest;
+  }
+  const knowledgePath = resolveSwarmKnowledgePath(directory);
+  const existingEntries = await readKnowledge(knowledgePath);
+  const taskContext = [...taskFiles, taskDescription].join(" ");
+  const taskBigrams = wordBigrams(normalize2(taskContext));
+  let extractedCount = 0;
+  let skippedCount = 0;
+  const details = [];
+  for (const docFile of manifest.files) {
+    const docContext = `${docFile.path} ${docFile.title} ${docFile.summary}`;
+    const docBigrams = wordBigrams(normalize2(docContext));
+    const score = jaccardBigram(taskBigrams, docBigrams);
+    if (score <= RELEVANCE_THRESHOLD) {
+      skippedCount++;
+      continue;
+    }
+    let fullContent;
+    try {
+      fullContent = await readFile6(path42.join(directory, docFile.path), "utf-8");
+    } catch {
+      skippedCount++;
+      continue;
+    }
+    const constraints = extractConstraintsFromContent(fullContent);
+    if (constraints.length === 0) {
+      skippedCount++;
+      continue;
+    }
+    const docDetails = {
+      path: docFile.path,
+      score,
+      constraints: []
+    };
+    for (const constraint of constraints) {
+      const duplicate = findNearDuplicate(constraint, existingEntries, DEDUP_THRESHOLD);
+      if (!duplicate) {
+        const entry = {
+          id: crypto4.randomUUID(),
+          tier: "swarm",
+          lesson: constraint,
+          category: "architecture",
+          tags: ["doc-scan", path42.basename(docFile.path)],
+          scope: "global",
+          confidence: 0.5,
+          status: "candidate",
+          confirmed_by: [],
+          project_name: "",
+          retrieval_outcomes: {
+            applied_count: 0,
+            succeeded_after_count: 0,
+            failed_after_count: 0
+          },
+          schema_version: 1,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+          auto_generated: true,
+          hive_eligible: false
+        };
+        await appendKnowledge(knowledgePath, entry);
+        existingEntries.push(entry);
+        extractedCount++;
+        docDetails.constraints.push(constraint);
+      }
+    }
+    if (docDetails.constraints.length > 0) {
+      details.push(docDetails);
+    } else {
+      skippedCount++;
+    }
+  }
+  return { extracted: extractedCount, skipped: skippedCount, details };
+}
+var doc_scan = createSwarmTool({
+  description: "Scan project documentation files and build an index manifest. Caches results in .swarm/doc-manifest.json for fast subsequent scans.",
+  args: {
+    force: tool.schema.boolean().optional().describe("Force re-scan even if cache is valid")
+  },
+  execute: async (args2, directory) => {
+    let force = false;
+    try {
+      if (args2 && typeof args2 === "object") {
+        const obj = args2;
+        if (obj.force === true)
+          force = true;
+      }
+    } catch {}
+    if (force) {
+      const manifestPath = path42.join(directory, ".swarm", "doc-manifest.json");
+      try {
+        fs30.unlinkSync(manifestPath);
+      } catch {}
+    }
+    const { manifest, cached: cached3 } = await scanDocIndex(directory);
+    return JSON.stringify({
+      success: true,
+      files_count: manifest.files.length,
+      cached: cached3,
+      manifest
+    }, null, 2);
+  }
+});
+var doc_extract = createSwarmTool({
+  description: "Extract actionable constraints from project documentation relevant to the current task. Scans docs via doc-manifest, scores relevance via Jaccard bigram similarity, and stores non-duplicate constraints in .swarm/knowledge.jsonl.",
+  args: {
+    task_files: tool.schema.array(tool.schema.string()).describe("List of file paths involved in the current task"),
+    task_description: tool.schema.string().describe("Description of the current task")
+  },
+  execute: async (args2, directory) => {
+    let taskFiles = [];
+    let taskDescription = "";
+    try {
+      if (args2 && typeof args2 === "object") {
+        const obj = args2;
+        if (Array.isArray(obj.task_files)) {
+          taskFiles = obj.task_files.filter((f) => typeof f === "string");
+        }
+        if (typeof obj.task_description === "string") {
+          taskDescription = obj.task_description;
+        }
+      }
+    } catch {}
+    if (taskFiles.length === 0 && !taskDescription) {
+      return JSON.stringify({
+        success: false,
+        error: "task_files or task_description is required"
+      });
+    }
+    const result = await extractDocConstraints(directory, taskFiles, taskDescription);
+    return JSON.stringify({ success: true, ...result }, null, 2);
+  }
+});
 // src/tools/domain-detector.ts
 init_tool();
 var DOMAIN_PATTERNS = {
@@ -56163,8 +56697,8 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs30 from "fs";
-import * as path42 from "path";
+import * as fs31 from "fs";
+import * as path43 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR2 = ".swarm/evidence";
@@ -56194,9 +56728,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path42.resolve(cwd);
-  const swarmPath = path42.join(normalizedCwd, ".swarm");
-  const normalizedPath = path42.resolve(filePath);
+  const normalizedCwd = path43.resolve(cwd);
+  const swarmPath = path43.join(normalizedCwd, ".swarm");
+  const normalizedPath = path43.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -56212,12 +56746,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs30.existsSync(evidenceDir) || !fs30.statSync(evidenceDir).isDirectory()) {
+  if (!fs31.existsSync(evidenceDir) || !fs31.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs30.readdirSync(evidenceDir);
+    files = fs31.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -56226,14 +56760,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path42.join(evidenceDir, filename);
+    const filePath = path43.join(evidenceDir, filename);
     try {
-      const resolvedPath = path42.resolve(filePath);
-      const evidenceDirResolved = path42.resolve(evidenceDir);
+      const resolvedPath = path43.resolve(filePath);
+      const evidenceDirResolved = path43.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs30.lstatSync(filePath);
+      const stat2 = fs31.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -56242,7 +56776,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs30.statSync(filePath);
+      fileStat = fs31.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -56251,7 +56785,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs30.readFileSync(filePath, "utf-8");
+      content = fs31.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -56347,7 +56881,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path42.join(cwd, PLAN_FILE);
+    const planPath = path43.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -56361,7 +56895,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs30.readFileSync(planPath, "utf-8");
+      planContent = fs31.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -56379,7 +56913,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path42.join(cwd, EVIDENCE_DIR2);
+    const evidenceDir = path43.join(cwd, EVIDENCE_DIR2);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -56396,8 +56930,8 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs31 from "fs";
-import * as path43 from "path";
+import * as fs32 from "fs";
+import * as path44 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -56459,8 +56993,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs31.existsSync(targetDir)) {
-      fs31.mkdirSync(targetDir, { recursive: true });
+    if (!fs32.existsSync(targetDir)) {
+      fs32.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -56478,16 +57012,16 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path43.join(targetDir, filename);
-      const base = path43.basename(filepath, path43.extname(filepath));
-      const ext = path43.extname(filepath);
+      let filepath = path44.join(targetDir, filename);
+      const base = path44.basename(filepath, path44.extname(filepath));
+      const ext = path44.extname(filepath);
       let counter = 1;
-      while (fs31.existsSync(filepath)) {
-        filepath = path43.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs32.existsSync(filepath)) {
+        filepath = path44.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs31.writeFileSync(filepath, code.trim(), "utf-8");
+        fs32.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -56603,8 +57137,8 @@ var gitingest = createSwarmTool({
 // src/tools/imports.ts
 init_dist();
 init_create_tool();
-import * as fs32 from "fs";
-import * as path44 from "path";
+import * as fs33 from "fs";
+import * as path45 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
@@ -56658,7 +57192,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path44.extname(filePath).toLowerCase();
+  const ext = path45.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -56682,15 +57216,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path44.resolve(targetFile);
+    _resolvedTarget = path45.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path44.basename(targetFile, path44.extname(targetFile));
+  const targetBasename = path45.basename(targetFile, path45.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path44.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path44.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path45.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path45.normalize(targetWithoutExt).replace(/\\/g, "/");
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
   for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
     const modulePath = match[1] || match[2] || match[3];
@@ -56713,9 +57247,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path44.dirname(targetFile);
-    const targetExt = path44.extname(targetFile);
-    const targetBasenameNoExt = path44.basename(targetFile, targetExt);
+    const _targetDir = path45.dirname(targetFile);
+    const targetExt = path45.extname(targetFile);
+    const targetBasenameNoExt = path45.basename(targetFile, targetExt);
     const moduleNormalized = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
     const moduleName = modulePath.split(/[/\\]/).pop() || "";
     const moduleNameNoExt = moduleName.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
@@ -56755,7 +57289,7 @@ function parseImports(content, targetFile, targetSymbol) {
   }
   return imports;
 }
-var SKIP_DIRECTORIES2 = new Set([
+var SKIP_DIRECTORIES3 = new Set([
   "node_modules",
   ".git",
   "dist",
@@ -56772,7 +57306,7 @@ var SKIP_DIRECTORIES2 = new Set([
 function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs32.readdirSync(dir);
+    entries = fs33.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -56782,14 +57316,14 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
   }
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
-    if (SKIP_DIRECTORIES2.has(entry)) {
-      stats.skippedDirs.push(path44.join(dir, entry));
+    if (SKIP_DIRECTORIES3.has(entry)) {
+      stats.skippedDirs.push(path45.join(dir, entry));
       continue;
     }
-    const fullPath = path44.join(dir, entry);
+    const fullPath = path45.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs32.statSync(fullPath);
+      stat2 = fs33.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -56800,7 +57334,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
     if (stat2.isDirectory()) {
       findSourceFiles(fullPath, files, stats);
     } else if (stat2.isFile()) {
-      const ext = path44.extname(fullPath).toLowerCase();
+      const ext = path45.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -56857,8 +57391,8 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path44.resolve(file3);
-      if (!fs32.existsSync(targetFile)) {
+      const targetFile = path45.resolve(file3);
+      if (!fs33.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -56868,7 +57402,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs32.statSync(targetFile);
+      const targetStat = fs33.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -56879,7 +57413,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path44.dirname(targetFile);
+      const baseDir = path45.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -56894,12 +57428,12 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs32.statSync(filePath);
+          const stat2 = fs33.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs32.readFileSync(filePath);
+          const buffer = fs33.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -57448,8 +57982,8 @@ init_dist();
 init_config();
 init_schema();
 init_manager();
-import * as fs33 from "fs";
-import * as path45 from "path";
+import * as fs34 from "fs";
+import * as path46 from "path";
 init_utils2();
 init_create_tool();
 function safeWarn(message, error93) {
@@ -57668,7 +58202,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   };
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path45.basename(dir);
+      const projectName = path46.basename(dir);
       await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
     } catch (error93) {
       safeWarn("[phase_complete] Failed to curate lessons from retrospective:", error93);
@@ -57708,7 +58242,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs33.readFileSync(planPath, "utf-8");
+      const planRaw = fs34.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && targetPhase.tasks.every((t) => t.status === "completed")) {
@@ -57739,7 +58273,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs33.readFileSync(planPath, "utf-8");
+      const planRaw = fs34.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -57777,7 +58311,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs33.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs34.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
     warnings.push(`Warning: failed to write phase complete event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -57796,12 +58330,12 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     }
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planJson = fs33.readFileSync(planPath, "utf-8");
+      const planJson = fs34.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planJson);
       const phaseObj = plan.phases.find((p) => p.id === phase);
       if (phaseObj) {
         phaseObj.status = "completed";
-        fs33.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
+        fs34.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
 `, "utf-8");
       }
     } catch (error93) {
@@ -57855,8 +58389,8 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs34 from "fs";
-import * as path46 from "path";
+import * as fs35 from "fs";
+import * as path47 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -57874,28 +58408,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs34.existsSync(path46.join(cwd, "package.json"))) {
+  if (fs35.existsSync(path47.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs34.existsSync(path46.join(cwd, "pyproject.toml")) || fs34.existsSync(path46.join(cwd, "requirements.txt"))) {
+  if (fs35.existsSync(path47.join(cwd, "pyproject.toml")) || fs35.existsSync(path47.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs34.existsSync(path46.join(cwd, "Cargo.toml"))) {
+  if (fs35.existsSync(path47.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs34.existsSync(path46.join(cwd, "go.mod"))) {
+  if (fs35.existsSync(path47.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs34.readdirSync(cwd);
+    const files = fs35.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs34.existsSync(path46.join(cwd, "Gemfile")) || fs34.existsSync(path46.join(cwd, "Gemfile.lock"))) {
+  if (fs35.existsSync(path47.join(cwd, "Gemfile")) || fs35.existsSync(path47.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs34.existsSync(path46.join(cwd, "pubspec.yaml"))) {
+  if (fs35.existsSync(path47.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -58957,8 +59491,8 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs37 from "fs";
-import * as path49 from "path";
+import * as fs38 from "fs";
+import * as path50 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -59103,8 +59637,8 @@ function pLimit(concurrency) {
     },
     map: {
       async value(iterable, function_) {
-        const promises3 = Array.from(iterable, (value, index) => this(function_, value, index));
-        return Promise.all(promises3);
+        const promises4 = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises4);
       }
     }
   });
@@ -59117,6 +59651,7 @@ function validateConcurrency(concurrency) {
 }
 
 // src/tools/pre-check-batch.ts
+init_manager();
 init_utils();
 init_create_tool();
 init_lint();
@@ -59125,8 +59660,8 @@ init_lint();
 init_manager();
 
 // src/quality/metrics.ts
-import * as fs35 from "fs";
-import * as path47 from "path";
+import * as fs36 from "fs";
+import * as path48 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -59164,11 +59699,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs35.statSync(filePath);
+    const stat2 = fs36.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs35.readFileSync(filePath, "utf-8");
+    const content = fs36.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -59178,8 +59713,8 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
-    if (!fs35.existsSync(fullPath)) {
+    const fullPath = path48.isAbsolute(file3) ? file3 : path48.join(workingDir, file3);
+    if (!fs36.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -59300,8 +59835,8 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs35.readFileSync(filePath, "utf-8");
-    const ext = path47.extname(filePath).toLowerCase();
+    const content = fs36.readFileSync(filePath, "utf-8");
+    const ext = path48.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -59327,8 +59862,8 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
-    if (!fs35.existsSync(fullPath)) {
+    const fullPath = path48.isAbsolute(file3) ? file3 : path48.join(workingDir, file3);
+    if (!fs36.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -59361,16 +59896,16 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
-    if (!fs35.existsSync(fullPath)) {
+    const fullPath = path48.isAbsolute(file3) ? file3 : path48.join(workingDir, file3);
+    if (!fs36.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs35.statSync(fullPath);
+      const stat2 = fs36.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES5) {
         continue;
       }
-      const content = fs35.readFileSync(fullPath, "utf-8");
+      const content = fs36.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -59394,8 +59929,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename8 = path47.basename(filePath);
-  const _ext = path47.extname(filePath).toLowerCase();
+  const basename9 = path48.basename(filePath);
+  const _ext = path48.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -59410,7 +59945,7 @@ function isTestFile(filePath) {
     ".spec.jsx"
   ];
   for (const pattern of testPatterns) {
-    if (basename8.includes(pattern)) {
+    if (basename9.includes(pattern)) {
       return true;
     }
   }
@@ -59476,8 +60011,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path48, glob) {
-  const normalizedPath = path48.replace(/\\/g, "/");
+function matchesGlobSegment(path49, glob) {
+  const normalizedPath = path49.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -59508,8 +60043,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path48, glob) {
-  const normalizedPath = path48.replace(/\\/g, "/");
+function globMatches(path49, glob) {
+  const normalizedPath = path49.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -59545,31 +60080,31 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path47.join(workingDir, "src");
-  if (fs35.existsSync(srcDir)) {
+  const srcDir = path48.join(workingDir, "src");
+  if (fs36.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path47.join(workingDir, dir);
-    if (fs35.existsSync(dirPath)) {
+    const dirPath = path48.join(workingDir, dir);
+    if (fs36.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path47.join(workingDir, "tests");
-  if (fs35.existsSync(testsDir)) {
+  const testsDir = path48.join(workingDir, "tests");
+  if (fs36.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path47.join(workingDir, dir);
-    if (fs35.existsSync(dirPath) && dirPath !== testsDir) {
+    const dirPath = path48.join(workingDir, dir);
+    if (fs36.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -59581,9 +60116,9 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs35.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs36.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path47.join(dirPath, entry.name);
+      const fullPath = path48.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -59591,7 +60126,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${dirPath}/`, "");
-        const ext = path47.extname(entry.name).toLowerCase();
+        const ext = path48.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -59627,7 +60162,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs35.readFileSync(fullPath, "utf-8");
+          const content = fs36.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -59841,8 +60376,8 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs36 from "fs";
-import * as path48 from "path";
+import * as fs37 from "fs";
+import * as path49 from "path";
 import { extname as extname9 } from "path";
 
 // src/sast/rules/c.ts
@@ -60709,17 +61244,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs36.statSync(filePath);
+    const stats = fs37.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES6) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs36.openSync(filePath, "r");
+    const fd = fs37.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs36.readSync(fd, buffer, 0, 8192, 0);
-    fs36.closeSync(fd);
+    const bytesRead = fs37.readSync(fd, buffer, 0, 8192, 0);
+    fs37.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -60758,7 +61293,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs36.readFileSync(filePath, "utf-8");
+    const content = fs37.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -60805,8 +61340,8 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path48.isAbsolute(filePath) ? filePath : path48.resolve(directory, filePath);
-    if (!fs36.existsSync(resolvedPath)) {
+    const resolvedPath = path49.isAbsolute(filePath) ? filePath : path49.resolve(directory, filePath);
+    if (!fs37.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -61004,18 +61539,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path49.win32.resolve(inputPath);
-  } else if (path49.isAbsolute(inputPath)) {
-    resolved = path49.resolve(inputPath);
+    resolved = path50.win32.resolve(inputPath);
+  } else if (path50.isAbsolute(inputPath)) {
+    resolved = path50.resolve(inputPath);
   } else {
-    resolved = path49.resolve(baseDir, inputPath);
+    resolved = path50.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path49.resolve(workspaceDir);
+  const workspaceResolved = path50.resolve(workspaceDir);
   let relative6;
   if (isWinAbs) {
-    relative6 = path49.win32.relative(workspaceResolved, resolved);
+    relative6 = path50.win32.relative(workspaceResolved, resolved);
   } else {
-    relative6 = path49.relative(workspaceResolved, resolved);
+    relative6 = path50.relative(workspaceResolved, resolved);
   }
   if (relative6.startsWith("..")) {
     return "path traversal detected";
@@ -61076,13 +61611,13 @@ async function runLintWrapped(files, directory, _config) {
 }
 async function runLintOnFiles(linter, files, workspaceDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path49.join(workspaceDir, "node_modules", ".bin");
+  const binDir = path50.join(workspaceDir, "node_modules", ".bin");
   const validatedFiles = [];
   for (const file3 of files) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path49.resolve(file3);
+    const resolvedPath = path50.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -61100,10 +61635,10 @@ async function runLintOnFiles(linter, files, workspaceDir) {
   }
   let command;
   if (linter === "biome") {
-    const biomeBin = isWindows ? path49.join(binDir, "biome.EXE") : path49.join(binDir, "biome");
+    const biomeBin = isWindows ? path50.join(binDir, "biome.EXE") : path50.join(binDir, "biome");
     command = [biomeBin, "check", ...validatedFiles];
   } else {
-    const eslintBin = isWindows ? path49.join(binDir, "eslint.cmd") : path49.join(binDir, "eslint");
+    const eslintBin = isWindows ? path50.join(binDir, "eslint.cmd") : path50.join(binDir, "eslint");
     command = [eslintBin, ...validatedFiles];
   }
   try {
@@ -61240,7 +61775,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path49.resolve(file3);
+      const resolvedPath = path50.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -61258,14 +61793,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path49.extname(file3).toLowerCase();
+      const ext = path50.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat2;
       try {
-        stat2 = fs37.statSync(file3);
+        stat2 = fs38.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -61276,7 +61811,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs37.readFileSync(file3);
+        const buffer = fs38.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -61417,7 +61952,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path49.resolve(directory, file3));
+    changedFiles.push(path50.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -61464,6 +61999,26 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
     gatesPassed = false;
     warn(`pre_check_batch: Secretscan error - GATE FAILED: ${secretscanResult.error}`);
   }
+  if (secretscanResult.ran && secretscanResult.result) {
+    try {
+      const scanResult = secretscanResult.result;
+      const secretscanEvidence = {
+        task_id: "secretscan",
+        type: "secretscan",
+        timestamp: new Date().toISOString(),
+        agent: "pre_check_batch",
+        verdict: scanResult.count > 0 ? "fail" : "pass",
+        summary: `Secretscan: ${scanResult.count} finding(s), ${scanResult.files_scanned ?? 0} files scanned, ${scanResult.skipped_files ?? 0} skipped`,
+        findings_count: scanResult.count,
+        scan_directory: scanResult.scan_dir,
+        files_scanned: scanResult.files_scanned,
+        skipped_files: scanResult.skipped_files
+      };
+      await saveEvidence(directory, "secretscan", secretscanEvidence);
+    } catch (e) {
+      warn(`Failed to persist secretscan evidence: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
   if (sastScanResult.ran && sastScanResult.result) {
     if (sastScanResult.result.verdict === "fail") {
       gatesPassed = false;
@@ -61568,7 +62123,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path49.resolve(typedArgs.directory);
+    const resolvedDirectory = path50.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory3(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -61676,8 +62231,8 @@ ${paginatedContent}`;
 init_tool();
 init_manager2();
 init_create_tool();
-import * as fs38 from "fs";
-import * as path50 from "path";
+import * as fs39 from "fs";
+import * as path51 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
   const placeholderPattern = /^\[\w[\w\s]*\]$/;
@@ -61781,19 +62336,19 @@ async function executeSavePlan(args2, fallbackDir) {
   try {
     await savePlan(dir, plan);
     try {
-      const markerPath = path50.join(dir, ".swarm", ".plan-write-marker");
+      const markerPath = path51.join(dir, ".swarm", ".plan-write-marker");
       const marker = JSON.stringify({
         source: "save_plan",
         timestamp: new Date().toISOString(),
         phases_count: plan.phases.length,
         tasks_count: tasksCount
       });
-      await fs38.promises.writeFile(markerPath, marker, "utf8");
+      await fs39.promises.writeFile(markerPath, marker, "utf8");
     } catch {}
     return {
       success: true,
       message: "Plan saved successfully",
-      plan_path: path50.join(dir, ".swarm", "plan.json"),
+      plan_path: path51.join(dir, ".swarm", "plan.json"),
       phases_count: plan.phases.length,
       tasks_count: tasksCount
     };
@@ -61831,8 +62386,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs39 from "fs";
-import * as path51 from "path";
+import * as fs40 from "fs";
+import * as path52 from "path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -62678,9 +63233,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs39.readdirSync(dir, { withFileTypes: true });
+      const entries = fs40.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path51.join(dir, entry.name);
+        const fullPath = path52.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -62689,7 +63244,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path51.relative(rootDir, fullPath));
+              manifestFiles.push(path52.relative(rootDir, fullPath));
               break;
             }
           }
@@ -62705,13 +63260,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs39.readdirSync(dir, { withFileTypes: true });
+      const entries = fs40.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path51.join(dir, entry.name);
+        const fullPath = path52.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path51.relative(workingDir, fullPath));
+              found.push(path52.relative(workingDir, fullPath));
               break;
             }
           }
@@ -62724,11 +63279,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path51.dirname(file3);
+    let currentDir = path52.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path51.sep) {
-        dirs.add(path51.join(workingDir, currentDir));
-        const parent = path51.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path52.sep) {
+        dirs.add(path52.join(workingDir, currentDir));
+        const parent = path52.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -62742,7 +63297,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs39.mkdirSync(outputDir, { recursive: true });
+    fs40.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -62812,7 +63367,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path51.isAbsolute(relativeOutputDir) ? relativeOutputDir : path51.join(workingDir, relativeOutputDir);
+    const outputDir = path52.isAbsolute(relativeOutputDir) ? relativeOutputDir : path52.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -62835,11 +63390,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path51.isAbsolute(manifestFile) ? manifestFile : path51.join(workingDir, manifestFile);
-        if (!fs39.existsSync(fullPath)) {
+        const fullPath = path52.isAbsolute(manifestFile) ? manifestFile : path52.join(workingDir, manifestFile);
+        if (!fs40.existsSync(fullPath)) {
           continue;
         }
-        const content = fs39.readFileSync(fullPath, "utf-8");
+        const content = fs40.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -62852,8 +63407,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path51.join(outputDir, filename);
-    fs39.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path52.join(outputDir, filename);
+    fs40.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -62895,8 +63450,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs40 from "fs";
-import * as path52 from "path";
+import * as fs41 from "fs";
+import * as path53 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -62928,28 +63483,28 @@ function normalizePath2(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path52.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path52.sep) ? cwd : cwd + path52.sep;
+    const resolvedPath = path53.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path53.sep) ? cwd : cwd + path53.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path52.extname(resolvedPath).toLowerCase();
+    const ext = path53.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs40.statSync(resolvedPath);
+    const stats = fs41.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs40.existsSync(resolvedPath)) {
+    if (!fs41.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path52.resolve(cwd, candidate);
-    if (fs40.existsSync(candidatePath)) {
-      const stats = fs40.statSync(candidatePath);
+    const candidatePath = path53.resolve(cwd, candidate);
+    if (fs41.existsSync(candidatePath)) {
+      const stats = fs41.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -62958,8 +63513,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs40.readFileSync(specFile, "utf-8");
-  const ext = path52.extname(specFile).toLowerCase();
+  const content = fs41.readFileSync(specFile, "utf-8");
+  const ext = path53.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -63030,12 +63585,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs40.readdirSync(dir, { withFileTypes: true });
+      entries = fs41.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path52.join(dir, entry.name);
+      const fullPath = path53.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -63045,7 +63600,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path52.extname(entry.name).toLowerCase();
+        const ext = path53.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -63063,7 +63618,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs40.readFileSync(filePath, "utf-8");
+  const content = fs41.readFileSync(filePath, "utf-8");
   const lines = content.split(/\r?\n/);
   const expressRegex = /(?:app|router|server|express)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/g;
   const flaskRegex = /@(?:app|blueprint|bp)\.route\s*\(\s*['"]([^'"]+)['"]/g;
@@ -63214,8 +63769,8 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs41 from "fs";
-import * as path53 from "path";
+import * as fs42 from "fs";
+import * as path54 from "path";
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsControlCharacters(str) {
@@ -63244,11 +63799,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path53.resolve(workspace, filePath);
-    const realWorkspace = fs41.realpathSync(workspace);
-    const realResolvedPath = fs41.realpathSync(resolvedPath);
-    const relativePath = path53.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path53.isAbsolute(relativePath)) {
+    const resolvedPath = path54.resolve(workspace, filePath);
+    const realWorkspace = fs42.realpathSync(workspace);
+    const realResolvedPath = fs42.realpathSync(resolvedPath);
+    const relativePath = path54.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path54.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -63260,17 +63815,17 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path53.join(cwd, filePath);
+  const fullPath = path54.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs41.statSync(fullPath);
+    const stats = fs42.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs41.readFileSync(fullPath, "utf-8");
+    content = fs42.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -63412,17 +63967,17 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path53.join(cwd, filePath);
+  const fullPath = path54.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs41.statSync(fullPath);
+    const stats = fs42.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs41.readFileSync(fullPath, "utf-8");
+    content = fs42.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -63495,7 +64050,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path53.extname(file3);
+    const ext = path54.extname(file3);
     if (containsControlCharacters(file3)) {
       return JSON.stringify({
         file: file3,
@@ -63566,8 +64121,8 @@ init_test_runner();
 init_dist();
 init_utils();
 init_create_tool();
-import * as fs42 from "fs";
-import * as path54 from "path";
+import * as fs43 from "fs";
+import * as path55 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -63589,7 +64144,7 @@ var SUPPORTED_EXTENSIONS2 = new Set([
   ".swift",
   ".kt"
 ]);
-var SKIP_DIRECTORIES3 = new Set([
+var SKIP_DIRECTORIES4 = new Set([
   "node_modules",
   "dist",
   "build",
@@ -63638,9 +64193,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path54.resolve(paths);
-    const normalizedCwd = path54.resolve(cwd);
-    const normalizedResolved = path54.resolve(resolvedPath);
+    const resolvedPath = path55.resolve(paths);
+    const normalizedCwd = path55.resolve(cwd);
+    const normalizedResolved = path55.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -63656,25 +64211,25 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path54.extname(filePath).toLowerCase();
+  const ext = path55.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles2(dir, files = []) {
   let entries;
   try {
-    entries = fs42.readdirSync(dir);
+    entries = fs43.readdirSync(dir);
   } catch {
     return files;
   }
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
-    if (SKIP_DIRECTORIES3.has(entry)) {
+    if (SKIP_DIRECTORIES4.has(entry)) {
       continue;
     }
-    const fullPath = path54.join(dir, entry);
+    const fullPath = path55.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs42.statSync(fullPath);
+      stat2 = fs43.statSync(fullPath);
     } catch {
       continue;
     }
@@ -63767,7 +64322,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs42.existsSync(scanPath)) {
+    if (!fs43.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -63777,13 +64332,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs42.statSync(scanPath);
+    const stat2 = fs43.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path54.extname(scanPath)}`,
+          error: `unsupported file extension: ${path55.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -63796,11 +64351,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs42.statSync(filePath);
+        const fileStat = fs43.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs42.readFileSync(filePath, "utf-8");
+        const content = fs43.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -63828,18 +64383,18 @@ var todo_extract = createSwarmTool({
 // src/tools/update-task-status.ts
 init_tool();
 init_schema();
-import * as fs44 from "fs";
-import * as path56 from "path";
+import * as fs45 from "fs";
+import * as path57 from "path";
 
 // src/hooks/diff-scope.ts
-import * as fs43 from "fs";
-import * as path55 from "path";
+import * as fs44 from "fs";
+import * as path56 from "path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path55.join(directory, ".swarm", "plan.json");
-    if (!fs43.existsSync(planPath))
+    const planPath = path56.join(directory, ".swarm", "plan.json");
+    if (!fs44.existsSync(planPath))
       return null;
-    const raw = fs43.readFileSync(planPath, "utf-8");
+    const raw = fs44.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -63951,7 +64506,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path56.basename(file3);
+    const fileName = path57.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -63973,8 +64528,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     if (hasActiveTurboMode2()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path56.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs44.readFileSync(planPath, "utf-8");
+        const planPath = path57.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs45.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -63993,8 +64548,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     const resolvedDir = workingDirectory;
     try {
-      const evidencePath = path56.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
-      const raw = fs44.readFileSync(evidencePath, "utf-8");
+      const evidencePath = path57.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
+      const raw = fs45.readFileSync(evidencePath, "utf-8");
       const evidence = JSON.parse(raw);
       if (evidence?.required_gates && Array.isArray(evidence.required_gates) && evidence?.gates) {
         const allGatesMet = evidence.required_gates.every((gate) => evidence.gates[gate] != null);
@@ -64034,8 +64589,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     try {
       const resolvedDir2 = workingDirectory;
-      const planPath = path56.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs44.readFileSync(planPath, "utf-8");
+      const planPath = path57.join(resolvedDir2, ".swarm", "plan.json");
+      const planRaw = fs45.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -64216,8 +64771,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path56.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path56.sep);
+    normalizedDir = path57.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path57.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -64227,11 +64782,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path56.resolve(normalizedDir);
+    const resolvedDir = path57.resolve(normalizedDir);
     try {
-      const realPath = fs44.realpathSync(resolvedDir);
-      const planPath = path56.join(realPath, ".swarm", "plan.json");
-      if (!fs44.existsSync(planPath)) {
+      const realPath = fs45.realpathSync(resolvedDir);
+      const planPath = path57.join(realPath, ".swarm", "plan.json");
+      if (!fs45.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -64453,7 +65008,7 @@ var OpenCodeSwarm = async (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 = path57.resolve(ctx.directory, ".swarm");
+    const swarmDir = path58.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -64745,7 +65300,9 @@ var OpenCodeSwarm = async (ctx) => {
       await safeHook(activityHooks.toolBefore)(input, output);
     },
     "tool.execute.after": async (input, output) => {
-      console.debug("[hook-chain] toolAfter start sessionID=%s agent=%s tool=%s", input.sessionID, input.agent, input.tool?.name);
+      if (process.env.DEBUG_SWARM) {
+        console.debug("[hook-chain] toolAfter start sessionID=%s agent=%s tool=%s", input.sessionID, input.agent, input.tool?.name);
+      }
       await activityHooks.toolAfter(input, output);
       await guardrailsHooks.toolAfter(input, output);
       await safeHook(delegationLedgerHook.toolAfter)(input, output);
@@ -64805,7 +65362,9 @@ var OpenCodeSwarm = async (ctx) => {
       deleteStoredInputArgs(input.callID);
     },
     "chat.message": safeHook(async (input, output) => {
-      console.debug("[session] chat.message sessionID=%s agent=%s", input.sessionID, input.agent);
+      if (process.env.DEBUG_SWARM) {
+        console.debug("[session] chat.message sessionID=%s agent=%s", input.sessionID, input.agent);
+      }
       await delegationHandler(input, output);
     }),
     automation: automationManager