opencode-swarm 6.29.0 → 6.29.2

package/dist/index.js

@@ -14217,7 +14217,7 @@ var init_evidence_schema = __esm(() => {
   });
   RetrospectiveEvidenceSchema = BaseEvidenceSchema.extend({
     type: exports_external.literal("retrospective"),
-    phase_number: exports_external.number().int().min(0).max(99),
+    phase_number: exports_external.number().int().min(1).max(99),
     total_tool_calls: exports_external.number().int().min(0).max(9999),
     coder_revisions: exports_external.number().int().min(0).max(999),
     reviewer_rejections: exports_external.number().int().min(0).max(999),
@@ -14882,7 +14882,7 @@ var init_schema = __esm(() => {
   });
   IncrementalVerifyConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
-    command: exports_external.string().nullable().default(null),
+    command: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).nullable().default(null),
     timeoutMs: exports_external.number().int().min(1000).max(300000).default(30000),
     triggerAgents: exports_external.array(exports_external.string()).default(["coder"])
   });
@@ -35942,7 +35942,7 @@ __export(exports_gate_evidence, {
   DEFAULT_REQUIRED_GATES: () => DEFAULT_REQUIRED_GATES
 });
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, renameSync as renameSync7, unlinkSync as unlinkSync4 } from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 function isValidTaskId2(taskId) {
   if (!taskId)
     return false;
@@ -35989,10 +35989,10 @@ function expandRequiredGates(existingGates, newAgentType) {
   return combined.sort();
 }
 function getEvidenceDir(directory) {
-  return path28.join(directory, ".swarm", "evidence");
+  return path29.join(directory, ".swarm", "evidence");
 }
 function getEvidencePath(directory, taskId) {
-  return path28.join(getEvidenceDir(directory), `${taskId}.json`);
+  return path29.join(getEvidenceDir(directory), `${taskId}.json`);
 }
 function readExisting(evidencePath) {
   try {
@@ -36106,10 +36106,10 @@ function createPreflightIntegration(config3) {
     });
     const report = await runPreflight(directory, request.currentPhase, preflightConfig);
     if (statusArtifact) {
-      const state = report.overall === "pass" ? "success" : "failure";
-      statusArtifact.recordOutcome(state, request.currentPhase, report.message);
+      const state2 = report.overall === "pass" ? "success" : "failure";
+      statusArtifact.recordOutcome(state2, request.currentPhase, report.message);
       console.log("[PreflightIntegration] Status artifact updated", {
-        state,
+        state: state2,
         phase: request.currentPhase,
         message: report.message
       });
@@ -37601,11 +37601,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path45) {
+      function locateFile(path46) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path45, scriptDirectory);
+          return Module["locateFile"](path46, scriptDirectory);
         }
-        return scriptDirectory + path45;
+        return scriptDirectory + path46;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -39353,7 +39353,7 @@ var init_runtime = __esm(() => {
 });
 
 // src/index.ts
-import * as path55 from "path";
+import * as path56 from "path";
 
 // src/agents/index.ts
 init_config();
@@ -39418,7 +39418,8 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000, dire
     scopeViolationDetected: false,
     modifiedFilesThisCoderTask: [],
     turboMode: false,
-    loopDetectionWindow: []
+    loopDetectionWindow: [],
+    pendingAdvisoryMessages: []
   };
   swarmState.agentSessions.set(sessionId, sessionState);
   swarmState.activeAgent.set(sessionId, agentName);
@@ -39523,6 +39524,9 @@ function ensureAgentSession(sessionId, agentName, directory) {
     if (session.loopDetectionWindow === undefined) {
       session.loopDetectionWindow = [];
     }
+    if (session.pendingAdvisoryMessages === undefined) {
+      session.pendingAdvisoryMessages = [];
+    }
     session.lastToolCallTime = now;
     return session;
   }
@@ -40179,6 +40183,7 @@ Activates when: user asks to "specify", "define requirements", "write a spec", o
      - Refine \u2192 delegate to MODE: CLARIFY-SPEC
    - If NO: proceed to generation (step 2)
    - If this is called from the stale spec archival path (MODE: PLAN option 1) \u2014 archival was already completed; skip this check and proceed directly to generation (step 2)
+1b. Run CODEBASE REALITY CHECK for any codebase references mentioned by the user or implied by the feature. Skip if work is purely greenfield (no existing codebase to check). Report discrepancies before proceeding to explorer.
 2. Delegate to \`{{AGENT_PREFIX}}explorer\` to scan the codebase for relevant context (existing patterns, related code, affected areas).
 3. Delegate to \`{{AGENT_PREFIX}}sme\` for domain research on the feature area to surface known constraints, best practices, and integration concerns.
 4. Generate \`.swarm/spec.md\` capturing:
@@ -40205,22 +40210,23 @@ Each requirement must be independently testable.
 Prefer informed defaults over asking the user \u2014 use \`[NEEDS CLARIFICATION]\` only when uncertainty could change scope, security, or core behavior.
 
 EXTERNAL PLAN IMPORT PATH \u2014 when the user provides an existing implementation plan (markdown content, pasted text, or a reference to a file):
-1. Read and parse the provided plan content.
-2. Reverse-engineer \`.swarm/spec.md\` from the plan:
+1. Run CODEBASE REALITY CHECK scoped to every file, function, API, and behavioral assumption in the provided plan. Report discrepancies to user before proceeding.
+2. Read and parse the provided plan content.
+3. Reverse-engineer \`.swarm/spec.md\` from the plan:
    - Derive FR-### functional requirements from task descriptions
    - Derive SC-### success criteria from acceptance criteria in tasks
    - Identify user scenarios from the plan's phase/feature groupings
    - Surface implicit assumptions as \`[NEEDS CLARIFICATION]\` markers
-3. Validate the provided plan against swarm task format requirements:
+4. Validate the provided plan against swarm task format requirements:
    - Every task should have FILE, TASK, CONSTRAINT, and ACCEPTANCE fields
    - No task should touch more than 2 files
    - No compound verbs in TASK lines ("implement X and add Y" = 2 tasks)
    - Dependencies should be declared explicitly
    - Phase structure should match \`.swarm/plan.md\` format
-4. Report gaps, format issues, and improvement suggestions to the user.
-5. Ask: "Should I also flesh out any areas that seem underspecified?"
+5. Report gaps, format issues, and improvement suggestions to the user.
+6. Ask: "Should I also flesh out any areas that seem underspecified?"
    - If yes: delegate to \`{{AGENT_PREFIX}}sme\` for targeted research on weak areas, then propose specific improvements.
-6. Output: both a \`.swarm/spec.md\` (extracted from the plan) and a validated version of the user's plan.
+7. Output: both a \`.swarm/spec.md\` (extracted from the plan) and a validated version of the user's plan.
 
 EXTERNAL PLAN RULES:
 - Surface ALL changes as suggestions \u2014 do not silently rewrite the user's plan.
@@ -40323,6 +40329,34 @@ User directives carried forward: {list any persistent directives}
 
 This briefing is a HARD REQUIREMENT for ALL phases. Skipping it is a process violation.
 
+### CODEBASE REALITY CHECK (Required Before Speccing or Planning)
+
+Before any spec generation, plan creation, or plan ingestion begins, the Architect must dispatch the Explorer agent in targeted, scoped chunks \u2014 one per logical area of the codebase referenced by the work (e.g., per module, per hook, per config surface). Each chunk must be explored with full depth rather than a broad surface pass.
+
+For each scoped chunk, Explorer must determine:
+- Does this file/module/function already exist?
+- If it exists, what is its current state? Does it already implement any part of what the plan or spec describes?
+- Is the plan's or user's assumption about the current state accurate? Flag any discrepancy between what is expected and what actually exists.
+- Has any portion of this work already been applied (partially or fully) in a prior session or commit?
+
+Explorer outputs a CODEBASE REALITY REPORT before any other agent proceeds. The report must list every referenced item with one of:
+  NOT STARTED | PARTIALLY DONE | ALREADY COMPLETE | ASSUMPTION INCORRECT
+
+Format:
+  REALITY CHECK: [N] references verified, [M] discrepancies found.
+    \u2713 src/hooks/incremental-verify.ts \u2014 exists, line 69 confirmed Bun.spawn
+    \u2717 src/services/status-service.ts \u2014 ASSUMPTION INCORRECT: compactionCount is no longer hardcoded (fixed in v6.29.1)
+    \u2713 src/config/evidence-schema.ts:107 \u2014 confirmed phase_number min(0)
+
+No implementation agent (coder, reviewer, test-engineer) may begin until this report is finalized.
+
+This check fires automatically in:
+- MODE: SPECIFY \u2014 before explorer dispatch for context (step 2)
+- MODE: PLAN \u2014 before plan generation or validation
+- EXTERNAL PLAN IMPORT PATH \u2014 before parsing the provided plan
+
+GREENFIELD EXEMPTION: If the work is purely greenfield (new project, no existing codebase references), skip this check.
+
 ### MODE: PLAN
 
 SPEC GATE (soft \u2014 check before planning):
@@ -40352,6 +40386,8 @@ SPEC GATE (soft \u2014 check before planning):
 
 This is a SOFT gate. When the user chooses "Skip and plan directly", proceed to the steps below exactly as before \u2014 do NOT modify any planning behavior.
 
+Run CODEBASE REALITY CHECK scoped to codebase elements referenced in spec.md or user constraints. Discrepancies must be reflected in the generated plan.
+
 Use the \`save_plan\` tool to create the implementation plan. Required parameters:
 - \`title\`: The real project name from the spec (NOT a placeholder like [Project])
 - \`swarm_id\`: The swarm identifier (e.g. "mega", "local", "paid")
@@ -47608,6 +47644,97 @@ No plan content available. Start by creating a .swarm/plan.md file.
 init_utils2();
 init_manager2();
 
+// src/services/compaction-service.ts
+import * as fs15 from "fs";
+import * as path27 from "path";
+function makeInitialState() {
+  return {
+    lastObservationAt: 0,
+    lastReflectionAt: 0,
+    lastEmergencyAt: 0,
+    observationCount: 0,
+    reflectionCount: 0,
+    emergencyCount: 0,
+    lastSnapshotAt: null
+  };
+}
+var state = makeInitialState();
+function appendSnapshot(directory, tier, budgetPct, message) {
+  try {
+    const snapshotPath = path27.join(directory, ".swarm", "context-snapshot.md");
+    const timestamp = new Date().toISOString();
+    const entry = `
+## [${tier.toUpperCase()}] ${timestamp} \u2014 ${budgetPct.toFixed(1)}% used
+${message}
+`;
+    fs15.appendFileSync(snapshotPath, entry, "utf-8");
+  } catch {}
+}
+function buildObservationMessage(budgetPct) {
+  return `[CONTEXT COMPACTION \u2014 OBSERVATION TIER]
+` + `Context window is ${budgetPct.toFixed(1)}% used. Initiating observation compaction.
+` + `INSTRUCTIONS: Summarise the key decisions made so far, files changed, errors resolved, ` + `and the current task state. Discard verbose tool outputs and raw file reads. ` + `Preserve: plan task ID, agent verdicts, file paths touched, unresolved blockers.
+` + `[/CONTEXT COMPACTION]`;
+}
+function buildReflectionMessage(budgetPct) {
+  return `[CONTEXT COMPACTION \u2014 REFLECTION TIER]
+` + `Context window is ${budgetPct.toFixed(1)}% used. Initiating reflection compaction.
+` + `INSTRUCTIONS: Re-summarise into a tighter format. Discard completed task details ` + `and resolved errors. Retain ONLY: current phase tasks remaining, open blockers, ` + `last 3 reviewer/test verdicts, and active file scope.
+` + `[/CONTEXT COMPACTION]`;
+}
+function buildEmergencyMessage(budgetPct, preserveLastN) {
+  return `[CONTEXT COMPACTION \u2014 EMERGENCY TIER]
+` + `Context window is ${budgetPct.toFixed(1)}% used. EMERGENCY compaction required.
+` + `INSTRUCTIONS: Retain ONLY the system prompt, the current task context, and the ` + `last ${preserveLastN} conversation turns. Discard everything else. ` + `If you cannot complete the current task in the remaining context, escalate to the user.
+` + `[/CONTEXT COMPACTION]`;
+}
+function createCompactionService(config3, directory, injectMessage) {
+  return {
+    toolAfter: async (_input, _output) => {
+      if (!config3.enabled)
+        return;
+      const budgetPct = swarmState.lastBudgetPct ?? 0;
+      if (budgetPct <= 0)
+        return;
+      const sessionId = _input.sessionID;
+      try {
+        if (budgetPct >= config3.emergencyThreshold && budgetPct > state.lastEmergencyAt + 5) {
+          state.lastEmergencyAt = budgetPct;
+          state.emergencyCount++;
+          const msg = buildEmergencyMessage(budgetPct, config3.preserveLastNTurns);
+          appendSnapshot(directory, "emergency", budgetPct, msg);
+          state.lastSnapshotAt = new Date().toISOString();
+          injectMessage(sessionId, msg);
+          return;
+        }
+        if (budgetPct >= config3.reflectionThreshold && budgetPct > state.lastReflectionAt + 5) {
+          state.lastReflectionAt = budgetPct;
+          state.reflectionCount++;
+          const msg = buildReflectionMessage(budgetPct);
+          appendSnapshot(directory, "reflection", budgetPct, msg);
+          state.lastSnapshotAt = new Date().toISOString();
+          injectMessage(sessionId, msg);
+          return;
+        }
+        if (budgetPct >= config3.observationThreshold && budgetPct > state.lastObservationAt + 5) {
+          state.lastObservationAt = budgetPct;
+          state.observationCount++;
+          const msg = buildObservationMessage(budgetPct);
+          appendSnapshot(directory, "observation", budgetPct, msg);
+          state.lastSnapshotAt = new Date().toISOString();
+          injectMessage(sessionId, msg);
+        }
+      } catch {}
+    }
+  };
+}
+function getCompactionMetrics() {
+  return {
+    compactionCount: state.observationCount + state.reflectionCount + state.emergencyCount,
+    lastSnapshotAt: state.lastSnapshotAt
+  };
+}
+
 // src/services/context-budget-service.ts
 init_utils2();
 function validateDirectory(directory) {
@@ -47650,9 +47777,9 @@ async function readBudgetState(directory) {
     return null;
   }
 }
-async function writeBudgetState(directory, state) {
+async function writeBudgetState(directory, state2) {
   const resolvedPath = validateSwarmPath(directory, "session/budget-state.json");
-  const content = JSON.stringify(state, null, 2);
+  const content = JSON.stringify(state2, null, 2);
   await Bun.write(resolvedPath, content);
 }
 async function countEvents(directory) {
@@ -47741,25 +47868,25 @@ async function formatBudgetWarning(report, directory, config3) {
     return formatWarningMessage(report);
   }
   const budgetState = await readBudgetState(directory);
-  const state = budgetState || {
+  const state2 = budgetState || {
     warningFiredAtTurn: null,
     criticalFiredAtTurn: null,
     lastInjectedAtTurn: null
   };
   const currentTurn = report.estimatedTurnCount;
   if (report.status === "warning") {
-    if (config3.warningMode === "once" && state.warningFiredAtTurn !== null) {
+    if (config3.warningMode === "once" && state2.warningFiredAtTurn !== null) {
       return null;
     }
-    if (config3.warningMode === "interval" && state.warningFiredAtTurn !== null && currentTurn - state.warningFiredAtTurn < config3.warningIntervalTurns) {
+    if (config3.warningMode === "interval" && state2.warningFiredAtTurn !== null && currentTurn - state2.warningFiredAtTurn < config3.warningIntervalTurns) {
       return null;
     }
-    state.warningFiredAtTurn = currentTurn;
-    state.lastInjectedAtTurn = currentTurn;
-    await writeBudgetState(directory, state);
+    state2.warningFiredAtTurn = currentTurn;
+    state2.lastInjectedAtTurn = currentTurn;
+    await writeBudgetState(directory, state2);
   } else if (report.status === "critical") {
-    state.criticalFiredAtTurn = currentTurn;
-    state.lastInjectedAtTurn = currentTurn;
+    state2.criticalFiredAtTurn = currentTurn;
+    state2.lastInjectedAtTurn = currentTurn;
   }
   return formatWarningMessage(report);
 }
@@ -47788,6 +47915,7 @@ async function getStatusData(directory, agents) {
       }
     }
     const agentCount2 = Object.keys(agents).length;
+    const metrics2 = getCompactionMetrics();
     return {
       hasPlan: true,
       currentPhase: currentPhase2,
@@ -47797,12 +47925,13 @@ async function getStatusData(directory, agents) {
       isLegacy: false,
       turboMode: hasActiveTurboMode(),
       contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
-      compactionCount: 0,
-      lastSnapshotAt: null
+      compactionCount: metrics2.compactionCount,
+      lastSnapshotAt: metrics2.lastSnapshotAt
     };
   }
   const planContent = await readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
+    const metrics2 = getCompactionMetrics();
     return {
       hasPlan: false,
       currentPhase: "Unknown",
@@ -47812,8 +47941,8 @@ async function getStatusData(directory, agents) {
       isLegacy: true,
       turboMode: hasActiveTurboMode(),
       contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
-      compactionCount: 0,
-      lastSnapshotAt: null
+      compactionCount: metrics2.compactionCount,
+      lastSnapshotAt: metrics2.lastSnapshotAt
     };
   }
   const currentPhase = extractCurrentPhase(planContent) || "Unknown";
@@ -47821,6 +47950,7 @@ async function getStatusData(directory, agents) {
   const incompleteTasks = (planContent.match(/^- \[ \]/gm) || []).length;
   const totalTasks = completedTasks + incompleteTasks;
   const agentCount = Object.keys(agents).length;
+  const metrics = getCompactionMetrics();
   return {
     hasPlan: true,
     currentPhase,
@@ -47830,8 +47960,8 @@ async function getStatusData(directory, agents) {
     isLegacy: true,
     turboMode: hasActiveTurboMode(),
     contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
-    compactionCount: 0,
-    lastSnapshotAt: null
+    compactionCount: metrics.compactionCount,
+    lastSnapshotAt: metrics.lastSnapshotAt
   };
 }
 function formatStatusMarkdown(status) {
@@ -48461,11 +48591,11 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path27 = `${directory}/.swarm/context.md`;
-    const tempPath = `${path27}.tmp`;
+    const path28 = `${directory}/.swarm/context.md`;
+    const tempPath = `${path28}.tmp`;
     try {
       await Bun.write(tempPath, updated);
-      renameSync6(tempPath, path27);
+      renameSync6(tempPath, path28);
     } catch (writeError) {
       try {
         unlinkSync3(tempPath);
@@ -49035,14 +49165,14 @@ function maskToolOutput(msg, _threshold) {
 }
 // src/hooks/delegation-gate.ts
 init_schema();
-import * as fs15 from "fs";
-import * as path29 from "path";
+import * as fs16 from "fs";
+import * as path30 from "path";
 
 // src/hooks/guardrails.ts
 init_constants();
 init_schema();
 init_manager2();
-import * as path27 from "path";
+import * as path28 from "path";
 init_utils();
 
 // src/hooks/loop-detector.ts
@@ -49135,10 +49265,10 @@ function isArchitect(sessionId) {
 function isOutsideSwarmDir(filePath, directory) {
   if (!filePath)
     return false;
-  const swarmDir = path27.resolve(directory, ".swarm");
-  const resolved = path27.resolve(directory, filePath);
-  const relative4 = path27.relative(swarmDir, resolved);
-  return relative4.startsWith("..") || path27.isAbsolute(relative4);
+  const swarmDir = path28.resolve(directory, ".swarm");
+  const resolved = path28.resolve(directory, filePath);
+  const relative4 = path28.relative(swarmDir, resolved);
+  return relative4.startsWith("..") || path28.isAbsolute(relative4);
 }
 function isSourceCodePath(filePath) {
   if (!filePath)
@@ -49205,13 +49335,13 @@ function getCurrentTaskId(sessionId) {
   return session?.currentTaskId ?? `${sessionId}:unknown`;
 }
 function isInDeclaredScope(filePath, scopeEntries) {
-  const resolvedFile = path27.resolve(filePath);
+  const resolvedFile = path28.resolve(filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path27.resolve(scope);
+    const resolvedScope = path28.resolve(scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path27.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path27.isAbsolute(rel);
+    const rel = path28.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path28.isAbsolute(rel);
   });
 }
 function createGuardrailsHooks(directoryOrConfig, config3) {
@@ -49298,9 +49428,9 @@ function createGuardrailsHooks(directoryOrConfig, config3) {
         const args2 = output.args;
         const targetPath = args2?.filePath ?? args2?.path ?? args2?.file ?? args2?.target;
         if (typeof targetPath === "string" && targetPath.length > 0) {
-          const resolvedTarget = path27.resolve(directory, targetPath).toLowerCase();
-          const planMdPath = path27.resolve(directory, ".swarm", "plan.md").toLowerCase();
-          const planJsonPath = path27.resolve(directory, ".swarm", "plan.json").toLowerCase();
+          const resolvedTarget = path28.resolve(directory, targetPath).toLowerCase();
+          const planMdPath = path28.resolve(directory, ".swarm", "plan.md").toLowerCase();
+          const planJsonPath = path28.resolve(directory, ".swarm", "plan.json").toLowerCase();
           if (resolvedTarget === planMdPath || resolvedTarget === planJsonPath) {
             throw new Error("PLAN STATE VIOLATION: Direct writes to .swarm/plan.md and .swarm/plan.json are blocked. " + "plan.md is auto-regenerated from plan.json by PlanSyncWorker. " + "Use update_task_status() to mark tasks complete, " + "phase_complete() for phase transitions, or " + "save_plan to create/restructure plans.");
           }
@@ -49349,9 +49479,9 @@ function createGuardrailsHooks(directoryOrConfig, config3) {
               }
             }
             for (const p of paths) {
-              const resolvedP = path27.resolve(directory, p);
-              const planMdPath = path27.resolve(directory, ".swarm", "plan.md").toLowerCase();
-              const planJsonPath = path27.resolve(directory, ".swarm", "plan.json").toLowerCase();
+              const resolvedP = path28.resolve(directory, p);
+              const planMdPath = path28.resolve(directory, ".swarm", "plan.md").toLowerCase();
+              const planJsonPath = path28.resolve(directory, ".swarm", "plan.json").toLowerCase();
               if (resolvedP.toLowerCase() === planMdPath || resolvedP.toLowerCase() === planJsonPath) {
                 throw new Error("PLAN STATE VIOLATION: Direct writes to .swarm/plan.md and .swarm/plan.json are blocked. " + "plan.md is auto-regenerated from plan.json by PlanSyncWorker. " + "Use update_task_status() to mark tasks complete, " + "phase_complete() for phase transitions, or " + "save_plan to create/restructure plans.");
               }
@@ -49371,7 +49501,7 @@ function createGuardrailsHooks(directoryOrConfig, config3) {
             }
           }
         }
-        if (typeof targetPath === "string" && targetPath.length > 0 && isOutsideSwarmDir(targetPath, directory) && isSourceCodePath(path27.relative(directory, path27.resolve(directory, targetPath)))) {
+        if (typeof targetPath === "string" && targetPath.length > 0 && isOutsideSwarmDir(targetPath, directory) && isSourceCodePath(path28.relative(directory, path28.resolve(directory, targetPath)))) {
           const session2 = swarmState.agentSessions.get(input.sessionID);
           if (session2) {
             session2.architectWriteCount++;
@@ -49653,6 +49783,30 @@ ${pending.message}
           }
         }
       }
+      if (isArchitectSession && (session?.pendingAdvisoryMessages?.length ?? 0) > 0) {
+        const advisories = session.pendingAdvisoryMessages;
+        let targetMsg = systemMessages[0];
+        if (!targetMsg) {
+          const newMsg = {
+            info: { role: "system" },
+            parts: [{ type: "text", text: "" }]
+          };
+          messages.unshift(newMsg);
+          targetMsg = newMsg;
+        }
+        const textPart2 = (targetMsg.parts ?? []).find((part) => part.type === "text" && typeof part.text === "string");
+        if (textPart2) {
+          const joined = advisories.join(`
+---
+`);
+          textPart2.text = `[ADVISORIES]
+${joined}
+[/ADVISORIES]
+
+` + textPart2.text;
+        }
+        session.pendingAdvisoryMessages = [];
+      }
       if (isArchitectSession && session && session.architectWriteCount > session.selfCodingWarnedAtCount) {
         let targetSystemMessage = systemMessages[0];
         if (!targetSystemMessage) {
@@ -49880,13 +50034,13 @@ function getEvidenceTaskId(session, directory) {
     if (typeof directory !== "string" || directory.length === 0) {
       return null;
     }
-    const resolvedDirectory = path29.resolve(directory);
-    const planPath = path29.join(resolvedDirectory, ".swarm", "plan.json");
-    const resolvedPlanPath = path29.resolve(planPath);
-    if (!resolvedPlanPath.startsWith(resolvedDirectory + path29.sep) && resolvedPlanPath !== resolvedDirectory) {
+    const resolvedDirectory = path30.resolve(directory);
+    const planPath = path30.join(resolvedDirectory, ".swarm", "plan.json");
+    const resolvedPlanPath = path30.resolve(planPath);
+    if (!resolvedPlanPath.startsWith(resolvedDirectory + path30.sep) && resolvedPlanPath !== resolvedDirectory) {
       return null;
     }
-    const planContent = fs15.readFileSync(resolvedPlanPath, "utf-8");
+    const planContent = fs16.readFileSync(resolvedPlanPath, "utf-8");
     const plan = JSON.parse(planContent);
     if (!plan || !Array.isArray(plan.phases)) {
       return null;
@@ -49944,23 +50098,23 @@ function createDelegationGateHook(config3, directory) {
         if (targetAgent === "test_engineer")
           hasTestEngineer = true;
         if (targetAgent === "reviewer" && session.taskWorkflowStates) {
-          for (const [taskId, state] of session.taskWorkflowStates) {
-            if (state === "coder_delegated" || state === "pre_check_passed") {
+          for (const [taskId, state2] of session.taskWorkflowStates) {
+            if (state2 === "coder_delegated" || state2 === "pre_check_passed") {
               try {
                 advanceTaskState(session, taskId, "reviewer_run");
               } catch (err2) {
-                console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state2}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
               }
             }
           }
         }
         if (targetAgent === "test_engineer" && session.taskWorkflowStates) {
-          for (const [taskId, state] of session.taskWorkflowStates) {
-            if (state === "reviewer_run") {
+          for (const [taskId, state2] of session.taskWorkflowStates) {
+            if (state2 === "reviewer_run") {
               try {
                 advanceTaskState(session, taskId, "tests_run");
               } catch (err2) {
-                console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                console.warn(`[delegation-gate] toolAfter: could not advance ${taskId} (${state2}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
               }
             }
           }
@@ -49976,12 +50130,12 @@ function createDelegationGateHook(config3, directory) {
               if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
                 otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
               }
-              for (const [taskId, state] of otherSession.taskWorkflowStates) {
-                if (state === "coder_delegated" || state === "pre_check_passed") {
+              for (const [taskId, state2] of otherSession.taskWorkflowStates) {
+                if (state2 === "coder_delegated" || state2 === "pre_check_passed") {
                   try {
                     advanceTaskState(otherSession, taskId, "reviewer_run");
                   } catch (err2) {
-                    console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state2}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -49991,12 +50145,12 @@ function createDelegationGateHook(config3, directory) {
               if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
                 otherSession.taskWorkflowStates.set(seedTaskId, "reviewer_run");
               }
-              for (const [taskId, state] of otherSession.taskWorkflowStates) {
-                if (state === "reviewer_run") {
+              for (const [taskId, state2] of otherSession.taskWorkflowStates) {
+                if (state2 === "reviewer_run") {
                   try {
                     advanceTaskState(otherSession, taskId, "tests_run");
                   } catch (err2) {
-                    console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    console.warn(`[delegation-gate] toolAfter cross-session: could not advance ${taskId} (${state2}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -50060,23 +50214,23 @@ function createDelegationGateHook(config3, directory) {
             session.qaSkipTaskIds = [];
           }
           if (hasReviewer && session.taskWorkflowStates) {
-            for (const [taskId, state] of session.taskWorkflowStates) {
-              if (state === "coder_delegated" || state === "pre_check_passed") {
+            for (const [taskId, state2] of session.taskWorkflowStates) {
+              if (state2 === "coder_delegated" || state2 === "pre_check_passed") {
                 try {
                   advanceTaskState(session, taskId, "reviewer_run");
                 } catch (err2) {
-                  console.warn(`[delegation-gate] fallback: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                  console.warn(`[delegation-gate] fallback: could not advance ${taskId} (${state2}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                 }
               }
             }
           }
           if (hasReviewer && hasTestEngineer && session.taskWorkflowStates) {
-            for (const [taskId, state] of session.taskWorkflowStates) {
-              if (state === "reviewer_run") {
+            for (const [taskId, state2] of session.taskWorkflowStates) {
+              if (state2 === "reviewer_run") {
                 try {
                   advanceTaskState(session, taskId, "tests_run");
                 } catch (err2) {
-                  console.warn(`[delegation-gate] fallback: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                  console.warn(`[delegation-gate] fallback: could not advance ${taskId} (${state2}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                 }
               }
             }
@@ -50091,12 +50245,12 @@ function createDelegationGateHook(config3, directory) {
               if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
                 otherSession.taskWorkflowStates.set(seedTaskId, "coder_delegated");
               }
-              for (const [taskId, state] of otherSession.taskWorkflowStates) {
-                if (state === "coder_delegated" || state === "pre_check_passed") {
+              for (const [taskId, state2] of otherSession.taskWorkflowStates) {
+                if (state2 === "coder_delegated" || state2 === "pre_check_passed") {
                   try {
                     advanceTaskState(otherSession, taskId, "reviewer_run");
                   } catch (err2) {
-                    console.warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    console.warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state2}) \u2192 reviewer_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -50112,12 +50266,12 @@ function createDelegationGateHook(config3, directory) {
               if (seedTaskId && !otherSession.taskWorkflowStates.has(seedTaskId)) {
                 otherSession.taskWorkflowStates.set(seedTaskId, "reviewer_run");
               }
-              for (const [taskId, state] of otherSession.taskWorkflowStates) {
-                if (state === "reviewer_run") {
+              for (const [taskId, state2] of otherSession.taskWorkflowStates) {
+                if (state2 === "reviewer_run") {
                   try {
                     advanceTaskState(otherSession, taskId, "tests_run");
                   } catch (err2) {
-                    console.warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
+                    console.warn(`[delegation-gate] fallback cross-session: could not advance ${taskId} (${state2}) \u2192 tests_run: ${err2 instanceof Error ? err2.message : String(err2)}`);
                   }
                 }
               }
@@ -50363,7 +50517,7 @@ ${warningLines.join(`
 }
 // src/hooks/delegation-sanitizer.ts
 init_utils2();
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 var SANITIZATION_PATTERNS = [
   /\b\d+(st|nd|rd|th)\s+(attempt|try|time)\b/gi,
   /\b(5th|fifth|final|last)\s+attempt\b/gi,
@@ -50434,7 +50588,7 @@ function createDelegationSanitizerHook(directory) {
               stripped_patterns: result.stripped,
               timestamp: new Date().toISOString()
             };
-            fs16.appendFileSync(eventsPath, `${JSON.stringify(event)}
+            fs17.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
           } catch {}
         }
@@ -50684,13 +50838,13 @@ init_schema();
 init_manager();
 init_detector();
 init_manager2();
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager2();
-import * as fs17 from "fs";
-import * as path30 from "path";
+import * as fs18 from "fs";
+import * as path31 from "path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
   detectContradictions: true,
@@ -50844,11 +50998,11 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
         currentPhase = legacyPhase;
       }
     }
-    const contextPath = path30.join(directory, ".swarm", "context.md");
+    const contextPath = path31.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
-      if (fs17.existsSync(contextPath)) {
-        contextContent = fs17.readFileSync(contextPath, "utf-8");
+      if (fs18.existsSync(contextPath)) {
+        contextContent = fs18.readFileSync(contextPath, "utf-8");
       }
     } catch {
       return {
@@ -51342,11 +51496,11 @@ function createSystemEnhancerHook(config3, directory) {
               if (handoffContent) {
                 const handoffPath = validateSwarmPath(directory, "handoff.md");
                 const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-                if (fs18.existsSync(consumedPath)) {
+                if (fs19.existsSync(consumedPath)) {
                   warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                  fs18.unlinkSync(consumedPath);
+                  fs19.unlinkSync(consumedPath);
                 }
-                fs18.renameSync(handoffPath, consumedPath);
+                fs19.renameSync(handoffPath, consumedPath);
                 const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -51626,11 +51780,11 @@ ${budgetWarning}`);
             if (handoffContent) {
               const handoffPath = validateSwarmPath(directory, "handoff.md");
               const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-              if (fs18.existsSync(consumedPath)) {
+              if (fs19.existsSync(consumedPath)) {
                 warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                fs18.unlinkSync(consumedPath);
+                fs19.unlinkSync(consumedPath);
               }
-              fs18.renameSync(handoffPath, consumedPath);
+              fs19.renameSync(handoffPath, consumedPath);
               const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -52308,55 +52462,112 @@ function createDarkMatterDetectorHook(directory) {
 }
 
 // src/hooks/incremental-verify.ts
-import * as fs19 from "fs";
-import * as path31 from "path";
+import * as fs20 from "fs";
+import * as path32 from "path";
+
+// src/hooks/spawn-helper.ts
+import { spawn } from "child_process";
+function spawnAsync(command, cwd, timeoutMs) {
+  return new Promise((resolve11) => {
+    try {
+      const [cmd, ...args2] = command;
+      const proc = spawn(cmd, args2, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      let done = false;
+      proc.stdout.on("data", (d) => {
+        stdout += d;
+      });
+      proc.stderr.on("data", (d) => {
+        stderr += d;
+      });
+      const timer = setTimeout(() => {
+        if (done)
+          return;
+        done = true;
+        try {
+          proc.stdout.destroy();
+        } catch {}
+        try {
+          proc.stderr.destroy();
+        } catch {}
+        try {
+          proc.kill();
+        } catch {}
+        resolve11(null);
+      }, timeoutMs);
+      proc.on("close", (code) => {
+        if (done)
+          return;
+        done = true;
+        clearTimeout(timer);
+        resolve11({ exitCode: code ?? 1, stdout, stderr });
+      });
+      proc.on("error", () => {
+        if (done)
+          return;
+        done = true;
+        clearTimeout(timer);
+        resolve11(null);
+      });
+    } catch {
+      resolve11(null);
+    }
+  });
+}
+
+// src/hooks/incremental-verify.ts
+var emittedSkipAdvisories = new Set;
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path31.join(projectDir, "package.json");
-  if (!fs19.existsSync(pkgPath))
-    return null;
-  try {
-    const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf8"));
-    const scripts = pkg.scripts;
-    if (scripts?.typecheck)
-      return ["bun", "run", "typecheck"];
-    if (scripts?.["type-check"])
-      return ["bun", "run", "type-check"];
-    const deps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies
-    };
-    if (!deps?.typescript && !fs19.existsSync(path31.join(projectDir, "tsconfig.json"))) {
+  const pkgPath = path32.join(projectDir, "package.json");
+  if (fs20.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf8"));
+      const scripts = pkg.scripts;
+      if (scripts?.typecheck)
+        return { command: ["bun", "run", "typecheck"], language: "typescript" };
+      if (scripts?.["type-check"])
+        return {
+          command: ["bun", "run", "type-check"],
+          language: "typescript"
+        };
+      const deps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      if (!deps?.typescript && !fs20.existsSync(path32.join(projectDir, "tsconfig.json"))) {
+        return null;
+      }
+      return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
+    } catch {
       return null;
     }
-    return ["npx", "tsc", "--noEmit"];
-  } catch {
-    return null;
   }
-}
-async function runWithTimeout(command, cwd, timeoutMs) {
+  if (fs20.existsSync(path32.join(projectDir, "go.mod"))) {
+    return { command: ["go", "vet", "./..."], language: "go" };
+  }
+  if (fs20.existsSync(path32.join(projectDir, "Cargo.toml"))) {
+    return { command: ["cargo", "check"], language: "rust" };
+  }
+  if (fs20.existsSync(path32.join(projectDir, "pyproject.toml")) || fs20.existsSync(path32.join(projectDir, "requirements.txt")) || fs20.existsSync(path32.join(projectDir, "setup.py"))) {
+    return { command: null, language: "python" };
+  }
   try {
-    const proc = Bun.spawn(command, {
-      cwd,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const timeoutHandle = setTimeout(() => {
-      try {
-        proc.kill();
-      } catch {}
-    }, timeoutMs);
-    try {
-      const [exitCode, stderr] = await Promise.all([
-        proc.exited,
-        new Response(proc.stderr).text()
-      ]);
-      return { exitCode, stderr };
-    } finally {
-      clearTimeout(timeoutHandle);
+    const entries = fs20.readdirSync(projectDir);
+    if (entries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
+      return {
+        command: ["dotnet", "build", "--no-restore"],
+        language: "csharp"
+      };
     }
-  } catch {
+  } catch {}
+  return null;
+}
+async function runWithTimeout(command, cwd, timeoutMs) {
+  const result = await spawnAsync(command, cwd, timeoutMs);
+  if (result === null)
     return null;
-  }
+  return { exitCode: result.exitCode, stderr: result.stderr };
 }
 function createIncrementalVerifyHook(config3, projectDir, injectMessage) {
   return {
@@ -52371,10 +52582,27 @@ function createIncrementalVerifyHook(config3, projectDir, injectMessage) {
       if (!config3.triggerAgents.includes(agentName) && !config3.triggerAgents.includes(subagentType)) {
         return;
       }
-      const command = config3.command != null ? config3.command.split(" ") : detectTypecheckCommand(projectDir);
-      if (!command)
+      let commandToRun = null;
+      if (config3.command != null) {
+        commandToRun = Array.isArray(config3.command) ? config3.command : config3.command.split(" ");
+      } else {
+        const detected = detectTypecheckCommand(projectDir);
+        if (detected === null) {
+          return;
+        }
+        if (detected.command === null) {
+          const dedupKey = `${input.sessionID}:${detected.language}`;
+          if (!emittedSkipAdvisories.has(dedupKey)) {
+            emittedSkipAdvisories.add(dedupKey);
+            injectMessage(input.sessionID, `POST-CODER CHECK SKIPPED: ${detected.language} project detected but no default checker available. Set incremental_verify.command in .swarm/config.json to enable.`);
+          }
+          return;
+        }
+        commandToRun = detected.command;
+      }
+      if (commandToRun === null)
         return;
-      const result = await runWithTimeout(command, projectDir, config3.timeoutMs);
+      const result = await runWithTimeout(commandToRun, projectDir, config3.timeoutMs);
       if (result === null) {
         return;
       }
@@ -52392,7 +52620,7 @@ ${errorSummary}`);
 // src/hooks/knowledge-reader.ts
 import { existsSync as existsSync19 } from "fs";
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import * as path32 from "path";
+import * as path33 from "path";
 var JACCARD_THRESHOLD = 0.6;
 var HIVE_TIER_BOOST = 0.05;
 var SAME_PROJECT_PENALTY = -0.05;
@@ -52440,7 +52668,7 @@ function inferCategoriesFromPhase(phaseDescription) {
   return ["process", "tooling"];
 }
 async function recordLessonsShown(directory, lessonIds, currentPhase) {
-  const shownFile = path32.join(directory, ".swarm", ".knowledge-shown.json");
+  const shownFile = path33.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     let shownData = {};
     if (existsSync19(shownFile)) {
@@ -52448,7 +52676,7 @@ async function recordLessonsShown(directory, lessonIds, currentPhase) {
       shownData = JSON.parse(content);
     }
     shownData[currentPhase] = lessonIds;
-    await mkdir4(path32.dirname(shownFile), { recursive: true });
+    await mkdir4(path33.dirname(shownFile), { recursive: true });
     await writeFile4(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
     console.warn("[swarm] Knowledge: failed to record shown lessons");
@@ -52543,7 +52771,7 @@ async function readMergedKnowledge(directory, config3, context) {
   return topN;
 }
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
-  const shownFile = path32.join(directory, ".swarm", ".knowledge-shown.json");
+  const shownFile = path33.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     if (!existsSync19(shownFile)) {
       return;
@@ -53015,12 +53243,12 @@ Use this data to avoid repeating known failure patterns.`;
 // src/hooks/curator-drift.ts
 init_event_bus();
 init_utils2();
-import * as fs20 from "fs";
-import * as path33 from "path";
+import * as fs21 from "fs";
+import * as path34 from "path";
 var DRIFT_REPORT_PREFIX = "drift-report-phase-";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path33.join(directory, ".swarm");
-  const entries = await fs20.promises.readdir(swarmDir).catch(() => null);
+  const swarmDir = path34.join(directory, ".swarm");
+  const entries = await fs21.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
   const reportFiles = entries.filter((name2) => name2.startsWith(DRIFT_REPORT_PREFIX) && name2.endsWith(".json")).sort();
@@ -53046,10 +53274,10 @@ async function readPriorDriftReports(directory) {
 async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
-  const swarmDir = path33.dirname(filePath);
-  await fs20.promises.mkdir(swarmDir, { recursive: true });
+  const swarmDir = path34.dirname(filePath);
+  await fs21.promises.mkdir(swarmDir, { recursive: true });
   try {
-    await fs20.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs21.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
   } catch (err2) {
     throw new Error(`[curator-drift] Failed to write drift report to ${filePath}: ${String(err2)}`);
   }
@@ -53300,6 +53528,8 @@ ${cachedInjectionText}`;
 }
 
 // src/hooks/slop-detector.ts
+import * as fs22 from "fs";
+import * as path35 from "path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -53310,7 +53540,7 @@ function countMatches(text, pattern) {
   return (text.match(pattern) ?? []).length;
 }
 function checkAbstractionBloat(content, threshold) {
-  const newClasses = countMatches(content, /^\+.*\bclass\s+\w+/gm);
+  const newClasses = countMatches(content, /^\+.*\b(?:class|struct|impl)\s+\w+/gm);
   if (newClasses >= threshold) {
     return {
       type: "abstraction_bloat",
@@ -53320,8 +53550,8 @@ function checkAbstractionBloat(content, threshold) {
   return null;
 }
 function checkCommentStrip(content, threshold) {
-  const removedComments = countMatches(content, /^-\s*\/[/*]/gm);
-  const addedComments = countMatches(content, /^\+\s*\/[/*]/gm);
+  const removedComments = countMatches(content, /^-\s*(?:\/[/*]|#|--)/gm);
+  const addedComments = countMatches(content, /^\+\s*(?:\/[/*]|#|--)/gm);
   if (removedComments >= threshold && addedComments === 0) {
     return {
       type: "comment_strip",
@@ -53341,8 +53571,33 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
   }
   return null;
 }
-async function checkDeadExports(content, projectDir, startTime) {
-  const exportMatches = content.matchAll(/^(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
+function walkFiles(dir, exts, deadline) {
+  const results = [];
+  try {
+    for (const entry of fs22.readdirSync(dir, { withFileTypes: true })) {
+      if (deadline !== undefined && Date.now() > deadline)
+        break;
+      if (entry.isSymbolicLink())
+        continue;
+      const full = path35.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git")
+          continue;
+        results.push(...walkFiles(full, exts, deadline));
+      } else if (entry.isFile()) {
+        if (exts.some((ext) => entry.name.endsWith(ext))) {
+          results.push(full);
+        }
+      }
+    }
+  } catch {}
+  return results;
+}
+function checkDeadExports(content, projectDir, startTime) {
+  const hasPackageJson = fs22.existsSync(path35.join(projectDir, "package.json"));
+  if (!hasPackageJson)
+    return null;
+  const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
   const newExports = [];
   for (const match of exportMatches) {
     if (match[1])
@@ -53350,19 +53605,19 @@ async function checkDeadExports(content, projectDir, startTime) {
   }
   if (newExports.length === 0)
     return null;
+  const files = walkFiles(projectDir, [".ts", ".tsx", ".js", ".jsx"], startTime + 480);
   const deadExports = [];
   for (const name2 of newExports) {
     if (Date.now() - startTime > 480)
       break;
     try {
       const importPattern = new RegExp(`\\bimport\\b[^;]*\\b${name2}\\b`, "g");
-      const glob = new Bun.Glob(`src/**/*.ts`);
       let found = false;
-      for await (const file3 of glob.scan(projectDir)) {
+      for (const file3 of files) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = await Bun.file(`${projectDir}/${file3}`).text();
+          const text = fs22.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -53416,7 +53671,7 @@ function createSlopDetectorHook(config3, projectDir, injectSystemMessage) {
       } catch {}
       if (Date.now() - startTime < 400) {
         try {
-          const dead = await checkDeadExports(content, projectDir, startTime);
+          const dead = checkDeadExports(content, projectDir, startTime);
           if (dead)
             findings.push(dead);
         } catch {}
@@ -53435,7 +53690,7 @@ Review before proceeding.`;
 
 // src/hooks/steering-consumed.ts
 init_utils2();
-import * as fs21 from "fs";
+import * as fs23 from "fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -53444,7 +53699,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs21.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs23.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -53484,93 +53739,12 @@ function createSteeringConsumedHook(directory) {
   return safeHook(hook);
 }
 
-// src/services/compaction-service.ts
-import * as fs22 from "fs";
-import * as path34 from "path";
-function makeInitialState() {
-  return {
-    lastObservationAt: 0,
-    lastReflectionAt: 0,
-    lastEmergencyAt: 0,
-    observationCount: 0,
-    reflectionCount: 0,
-    emergencyCount: 0
-  };
-}
-function appendSnapshot(directory, tier, budgetPct, message) {
-  try {
-    const snapshotPath = path34.join(directory, ".swarm", "context-snapshot.md");
-    const timestamp = new Date().toISOString();
-    const entry = `
-## [${tier.toUpperCase()}] ${timestamp} \u2014 ${budgetPct.toFixed(1)}% used
-${message}
-`;
-    fs22.appendFileSync(snapshotPath, entry, "utf-8");
-  } catch {}
-}
-function buildObservationMessage(budgetPct) {
-  return `[CONTEXT COMPACTION \u2014 OBSERVATION TIER]
-` + `Context window is ${budgetPct.toFixed(1)}% used. Initiating observation compaction.
-` + `INSTRUCTIONS: Summarise the key decisions made so far, files changed, errors resolved, ` + `and the current task state. Discard verbose tool outputs and raw file reads. ` + `Preserve: plan task ID, agent verdicts, file paths touched, unresolved blockers.
-` + `[/CONTEXT COMPACTION]`;
-}
-function buildReflectionMessage(budgetPct) {
-  return `[CONTEXT COMPACTION \u2014 REFLECTION TIER]
-` + `Context window is ${budgetPct.toFixed(1)}% used. Initiating reflection compaction.
-` + `INSTRUCTIONS: Re-summarise into a tighter format. Discard completed task details ` + `and resolved errors. Retain ONLY: current phase tasks remaining, open blockers, ` + `last 3 reviewer/test verdicts, and active file scope.
-` + `[/CONTEXT COMPACTION]`;
-}
-function buildEmergencyMessage(budgetPct, preserveLastN) {
-  return `[CONTEXT COMPACTION \u2014 EMERGENCY TIER]
-` + `Context window is ${budgetPct.toFixed(1)}% used. EMERGENCY compaction required.
-` + `INSTRUCTIONS: Retain ONLY the system prompt, the current task context, and the ` + `last ${preserveLastN} conversation turns. Discard everything else. ` + `If you cannot complete the current task in the remaining context, escalate to the user.
-` + `[/CONTEXT COMPACTION]`;
-}
-function createCompactionService(config3, directory, injectMessage) {
-  const state = makeInitialState();
-  return {
-    toolAfter: async (_input, _output) => {
-      if (!config3.enabled)
-        return;
-      const budgetPct = swarmState.lastBudgetPct ?? 0;
-      if (budgetPct <= 0)
-        return;
-      const sessionId = _input.sessionID;
-      try {
-        if (budgetPct >= config3.emergencyThreshold && budgetPct > state.lastEmergencyAt + 5) {
-          state.lastEmergencyAt = budgetPct;
-          state.emergencyCount++;
-          const msg = buildEmergencyMessage(budgetPct, config3.preserveLastNTurns);
-          appendSnapshot(directory, "emergency", budgetPct, msg);
-          injectMessage(sessionId, msg);
-          return;
-        }
-        if (budgetPct >= config3.reflectionThreshold && budgetPct > state.lastReflectionAt + 5) {
-          state.lastReflectionAt = budgetPct;
-          state.reflectionCount++;
-          const msg = buildReflectionMessage(budgetPct);
-          appendSnapshot(directory, "reflection", budgetPct, msg);
-          injectMessage(sessionId, msg);
-          return;
-        }
-        if (budgetPct >= config3.observationThreshold && budgetPct > state.lastObservationAt + 5) {
-          state.lastObservationAt = budgetPct;
-          state.observationCount++;
-          const msg = buildObservationMessage(budgetPct);
-          appendSnapshot(directory, "observation", budgetPct, msg);
-          injectMessage(sessionId, msg);
-        }
-      } catch {}
-    }
-  };
-}
-
 // src/index.ts
 init_config_doctor();
 
 // src/session/snapshot-reader.ts
 init_utils2();
-import path35 from "path";
+import path36 from "path";
 var VALID_TASK_WORKFLOW_STATES = [
   "idle",
   "coder_delegated",
@@ -53695,7 +53869,7 @@ function rehydrateState(snapshot) {
 async function reconcileTaskStatesFromPlan(directory) {
   let raw;
   try {
-    raw = await Bun.file(path35.join(directory, ".swarm/plan.json")).text();
+    raw = await Bun.file(path36.join(directory, ".swarm/plan.json")).text();
   } catch {
     return;
   }
@@ -53917,8 +54091,8 @@ var build_check = createSwarmTool({
 // src/tools/check-gate-status.ts
 init_dist();
 init_create_tool();
-import * as fs23 from "fs";
-import * as path36 from "path";
+import * as fs24 from "fs";
+import * as path37 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
 var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
 function isValidTaskId3(taskId) {
@@ -53935,18 +54109,18 @@ function isValidTaskId3(taskId) {
   return TASK_ID_PATTERN2.test(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path36.resolve(workspaceRoot);
-  const swarmPath = path36.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path36.resolve(filePath);
+  const normalizedWorkspace = path37.resolve(workspaceRoot);
+  const swarmPath = path37.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path37.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs23.existsSync(evidencePath)) {
+  if (!fs24.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs23.readFileSync(evidencePath, "utf-8");
+    content = fs24.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -53998,7 +54172,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path36.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path37.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -54058,8 +54232,8 @@ var check_gate_status = createSwarmTool({
 init_tool();
 init_create_tool();
 import { spawnSync } from "child_process";
-import * as fs24 from "fs";
-import * as path37 from "path";
+import * as fs25 from "fs";
+import * as path38 from "path";
 var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json";
 var MAX_LABEL_LENGTH = 100;
 var GIT_TIMEOUT_MS = 30000;
@@ -54110,13 +54284,13 @@ function validateLabel(label) {
   return null;
 }
 function getCheckpointLogPath(directory) {
-  return path37.join(directory, CHECKPOINT_LOG_PATH);
+  return path38.join(directory, CHECKPOINT_LOG_PATH);
 }
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
   try {
-    if (fs24.existsSync(logPath)) {
-      const content = fs24.readFileSync(logPath, "utf-8");
+    if (fs25.existsSync(logPath)) {
+      const content = fs25.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -54128,13 +54302,13 @@ function readCheckpointLog(directory) {
 }
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
-  const dir = path37.dirname(logPath);
-  if (!fs24.existsSync(dir)) {
-    fs24.mkdirSync(dir, { recursive: true });
+  const dir = path38.dirname(logPath);
+  if (!fs25.existsSync(dir)) {
+    fs25.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs24.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs24.renameSync(tempPath, logPath);
+  fs25.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs25.renameSync(tempPath, logPath);
 }
 function gitExec(args2) {
   const result = spawnSync("git", args2, {
@@ -54335,8 +54509,8 @@ var checkpoint = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_dist();
 init_create_tool();
-import * as fs25 from "fs";
-import * as path38 from "path";
+import * as fs26 from "fs";
+import * as path39 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
 var DEFAULT_TOP_N = 20;
@@ -54465,11 +54639,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs25.statSync(filePath);
+    const stat2 = fs26.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs25.readFileSync(filePath, "utf-8");
+    const content = fs26.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -54480,7 +54654,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path38.extname(file3).toLowerCase();
+    const ext = path39.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -54490,8 +54664,8 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs25.existsSync(fullPath)) {
-      fullPath = path38.join(cwd, file3);
+    if (!fs26.existsSync(fullPath)) {
+      fullPath = path39.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
     if (complexity !== null) {
@@ -54638,8 +54812,8 @@ var complexity_hotspots = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs26 from "fs";
-import * as path39 from "path";
+import * as fs27 from "fs";
+import * as path40 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
   const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
@@ -54718,8 +54892,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path39.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path39.sep);
+    normalizedDir = path40.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path40.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -54729,11 +54903,11 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path39.resolve(normalizedDir);
+    const resolvedDir = path40.resolve(normalizedDir);
     try {
-      const realPath = fs26.realpathSync(resolvedDir);
-      const planPath2 = path39.join(realPath, ".swarm", "plan.json");
-      if (!fs26.existsSync(planPath2)) {
+      const realPath = fs27.realpathSync(resolvedDir);
+      const planPath2 = path40.join(realPath, ".swarm", "plan.json");
+      if (!fs27.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -54753,8 +54927,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
   }
   const directory = normalizedDir ?? fallbackDir ?? process.cwd();
-  const planPath = path39.resolve(directory, ".swarm", "plan.json");
-  if (!fs26.existsSync(planPath)) {
+  const planPath = path40.resolve(directory, ".swarm", "plan.json");
+  if (!fs27.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -54763,7 +54937,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs26.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs27.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -54843,20 +55017,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path40 of paths) {
-    if (!path40 || path40.length === 0) {
+  for (const path41 of paths) {
+    if (!path41 || path41.length === 0) {
       return "empty path not allowed";
     }
-    if (path40.length > MAX_PATH_LENGTH) {
+    if (path41.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path40)) {
+    if (SHELL_METACHARACTERS2.test(path41)) {
       return "path contains shell metacharacters";
     }
-    if (path40.startsWith("-")) {
+    if (path41.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path40)) {
+    if (CONTROL_CHAR_PATTERN2.test(path41)) {
       return "path contains control characters";
     }
   }
@@ -54936,8 +55110,8 @@ var diff = tool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path40 = parts2[2];
-          files.push({ path: path40, additions, deletions });
+          const path41 = parts2[2];
+          files.push({ path: path41, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -55166,8 +55340,8 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs27 from "fs";
-import * as path40 from "path";
+import * as fs28 from "fs";
+import * as path41 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR2 = ".swarm/evidence";
@@ -55197,9 +55371,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path40.resolve(cwd);
-  const swarmPath = path40.join(normalizedCwd, ".swarm");
-  const normalizedPath = path40.resolve(filePath);
+  const normalizedCwd = path41.resolve(cwd);
+  const swarmPath = path41.join(normalizedCwd, ".swarm");
+  const normalizedPath = path41.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -55215,12 +55389,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs27.existsSync(evidenceDir) || !fs27.statSync(evidenceDir).isDirectory()) {
+  if (!fs28.existsSync(evidenceDir) || !fs28.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs27.readdirSync(evidenceDir);
+    files = fs28.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -55229,14 +55403,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path40.join(evidenceDir, filename);
+    const filePath = path41.join(evidenceDir, filename);
     try {
-      const resolvedPath = path40.resolve(filePath);
-      const evidenceDirResolved = path40.resolve(evidenceDir);
+      const resolvedPath = path41.resolve(filePath);
+      const evidenceDirResolved = path41.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs27.lstatSync(filePath);
+      const stat2 = fs28.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -55245,7 +55419,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs27.statSync(filePath);
+      fileStat = fs28.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -55254,7 +55428,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs27.readFileSync(filePath, "utf-8");
+      content = fs28.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -55350,7 +55524,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 = path40.join(cwd, PLAN_FILE);
+    const planPath = path41.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -55364,7 +55538,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs27.readFileSync(planPath, "utf-8");
+      planContent = fs28.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -55382,7 +55556,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path40.join(cwd, EVIDENCE_DIR2);
+    const evidenceDir = path41.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;
@@ -55399,8 +55573,8 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs28 from "fs";
-import * as path41 from "path";
+import * as fs29 from "fs";
+import * as path42 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -55462,8 +55636,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs28.existsSync(targetDir)) {
-      fs28.mkdirSync(targetDir, { recursive: true });
+    if (!fs29.existsSync(targetDir)) {
+      fs29.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -55481,16 +55655,16 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path41.join(targetDir, filename);
-      const base = path41.basename(filepath, path41.extname(filepath));
-      const ext = path41.extname(filepath);
+      let filepath = path42.join(targetDir, filename);
+      const base = path42.basename(filepath, path42.extname(filepath));
+      const ext = path42.extname(filepath);
       let counter = 1;
-      while (fs28.existsSync(filepath)) {
-        filepath = path41.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs29.existsSync(filepath)) {
+        filepath = path42.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs28.writeFileSync(filepath, code.trim(), "utf-8");
+        fs29.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -55603,8 +55777,8 @@ var gitingest = tool({
 });
 // src/tools/imports.ts
 init_dist();
-import * as fs29 from "fs";
-import * as path42 from "path";
+import * as fs30 from "fs";
+import * as path43 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
@@ -55658,7 +55832,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path42.extname(filePath).toLowerCase();
+  const ext = path43.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -55682,15 +55856,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path42.resolve(targetFile);
+    _resolvedTarget = path43.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path42.basename(targetFile, path42.extname(targetFile));
+  const targetBasename = path43.basename(targetFile, path43.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path42.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path42.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path43.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path43.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];
@@ -55713,9 +55887,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path42.dirname(targetFile);
-    const targetExt = path42.extname(targetFile);
-    const targetBasenameNoExt = path42.basename(targetFile, targetExt);
+    const _targetDir = path43.dirname(targetFile);
+    const targetExt = path43.extname(targetFile);
+    const targetBasenameNoExt = path43.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, "");
@@ -55772,7 +55946,7 @@ var SKIP_DIRECTORIES2 = new Set([
 function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs29.readdirSync(dir);
+    entries = fs30.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -55783,13 +55957,13 @@ 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(path42.join(dir, entry));
+      stats.skippedDirs.push(path43.join(dir, entry));
       continue;
     }
-    const fullPath = path42.join(dir, entry);
+    const fullPath = path43.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs29.statSync(fullPath);
+      stat2 = fs30.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -55800,7 +55974,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
     if (stat2.isDirectory()) {
       findSourceFiles(fullPath, files, stats);
     } else if (stat2.isFile()) {
-      const ext = path42.extname(fullPath).toLowerCase();
+      const ext = path43.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -55856,8 +56030,8 @@ var imports = tool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path42.resolve(file3);
-      if (!fs29.existsSync(targetFile)) {
+      const targetFile = path43.resolve(file3);
+      if (!fs30.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -55867,7 +56041,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs29.statSync(targetFile);
+      const targetStat = fs30.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -55878,7 +56052,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path42.dirname(targetFile);
+      const baseDir = path43.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -55893,12 +56067,12 @@ var imports = tool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs29.statSync(filePath);
+          const stat2 = fs30.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs29.readFileSync(filePath);
+          const buffer = fs30.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -55963,7 +56137,7 @@ var imports = tool({
 });
 // src/tools/knowledge-query.ts
 init_dist();
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 init_create_tool();
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
@@ -56033,14 +56207,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync27(swarmPath)) {
+  if (!existsSync28(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync27(hivePath)) {
+  if (!existsSync28(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -56199,8 +56373,8 @@ init_dist();
 init_config();
 init_schema();
 init_manager();
-import * as fs30 from "fs";
-import * as path43 from "path";
+import * as fs31 from "fs";
+import * as path44 from "path";
 init_utils2();
 init_create_tool();
 function safeWarn(message, error93) {
@@ -56395,7 +56569,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path43.basename(dir);
+      const projectName = path44.basename(dir);
       const knowledgeConfig = {
         enabled: true,
         swarm_max_entries: 100,
@@ -56443,7 +56617,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs30.readFileSync(planPath, "utf-8");
+      const planRaw = fs31.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")) {
@@ -56484,7 +56658,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs30.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs31.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)}`);
@@ -56503,12 +56677,12 @@ async function executePhaseComplete(args2, workingDirectory) {
     }
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planJson = fs30.readFileSync(planPath, "utf-8");
+      const planJson = fs31.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planJson);
       const phaseObj = plan.phases.find((p) => p.id === phase);
       if (phaseObj) {
         phaseObj.status = "completed";
-        fs30.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
+        fs31.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
 `, "utf-8");
       }
     } catch (error93) {
@@ -56558,8 +56732,8 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs31 from "fs";
-import * as path44 from "path";
+import * as fs32 from "fs";
+import * as path45 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -56577,28 +56751,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs31.existsSync(path44.join(cwd, "package.json"))) {
+  if (fs32.existsSync(path45.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs31.existsSync(path44.join(cwd, "pyproject.toml")) || fs31.existsSync(path44.join(cwd, "requirements.txt"))) {
+  if (fs32.existsSync(path45.join(cwd, "pyproject.toml")) || fs32.existsSync(path45.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs31.existsSync(path44.join(cwd, "Cargo.toml"))) {
+  if (fs32.existsSync(path45.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs31.existsSync(path44.join(cwd, "go.mod"))) {
+  if (fs32.existsSync(path45.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs31.readdirSync(cwd);
+    const files = fs32.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs31.existsSync(path44.join(cwd, "Gemfile")) || fs31.existsSync(path44.join(cwd, "Gemfile.lock"))) {
+  if (fs32.existsSync(path45.join(cwd, "Gemfile")) || fs32.existsSync(path45.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs31.existsSync(path44.join(cwd, "pubspec.yaml"))) {
+  if (fs32.existsSync(path45.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -57660,8 +57834,8 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs34 from "fs";
-import * as path47 from "path";
+import * as fs35 from "fs";
+import * as path48 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -57828,8 +58002,8 @@ init_lint();
 init_manager();
 
 // src/quality/metrics.ts
-import * as fs32 from "fs";
-import * as path45 from "path";
+import * as fs33 from "fs";
+import * as path46 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -57867,11 +58041,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs32.statSync(filePath);
+    const stat2 = fs33.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs32.readFileSync(filePath, "utf-8");
+    const content = fs33.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -57881,8 +58055,8 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path45.isAbsolute(file3) ? file3 : path45.join(workingDir, file3);
-    if (!fs32.existsSync(fullPath)) {
+    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    if (!fs33.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -58003,8 +58177,8 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs32.readFileSync(filePath, "utf-8");
-    const ext = path45.extname(filePath).toLowerCase();
+    const content = fs33.readFileSync(filePath, "utf-8");
+    const ext = path46.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -58030,8 +58204,8 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path45.isAbsolute(file3) ? file3 : path45.join(workingDir, file3);
-    if (!fs32.existsSync(fullPath)) {
+    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    if (!fs33.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -58064,16 +58238,16 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path45.isAbsolute(file3) ? file3 : path45.join(workingDir, file3);
-    if (!fs32.existsSync(fullPath)) {
+    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    if (!fs33.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs32.statSync(fullPath);
+      const stat2 = fs33.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES5) {
         continue;
       }
-      const content = fs32.readFileSync(fullPath, "utf-8");
+      const content = fs33.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -58097,8 +58271,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename8 = path45.basename(filePath);
-  const _ext = path45.extname(filePath).toLowerCase();
+  const basename8 = path46.basename(filePath);
+  const _ext = path46.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -58179,8 +58353,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path46, glob) {
-  const normalizedPath = path46.replace(/\\/g, "/");
+function matchesGlobSegment(path47, glob) {
+  const normalizedPath = path47.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -58211,8 +58385,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path46, glob) {
-  const normalizedPath = path46.replace(/\\/g, "/");
+function globMatches(path47, glob) {
+  const normalizedPath = path47.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -58248,31 +58422,31 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path45.join(workingDir, "src");
-  if (fs32.existsSync(srcDir)) {
+  const srcDir = path46.join(workingDir, "src");
+  if (fs33.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path45.join(workingDir, dir);
-    if (fs32.existsSync(dirPath)) {
+    const dirPath = path46.join(workingDir, dir);
+    if (fs33.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path45.join(workingDir, "tests");
-  if (fs32.existsSync(testsDir)) {
+  const testsDir = path46.join(workingDir, "tests");
+  if (fs33.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path45.join(workingDir, dir);
-    if (fs32.existsSync(dirPath) && dirPath !== testsDir) {
+    const dirPath = path46.join(workingDir, dir);
+    if (fs33.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -58284,9 +58458,9 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs32.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs33.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path45.join(dirPath, entry.name);
+      const fullPath = path46.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -58294,7 +58468,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${process.cwd()}/`, "");
-        const ext = path45.extname(entry.name).toLowerCase();
+        const ext = path46.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -58330,7 +58504,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs32.readFileSync(fullPath, "utf-8");
+          const content = fs33.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -58544,8 +58718,8 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs33 from "fs";
-import * as path46 from "path";
+import * as fs34 from "fs";
+import * as path47 from "path";
 import { extname as extname9 } from "path";
 
 // src/sast/rules/c.ts
@@ -59229,7 +59403,7 @@ function executeRulesSync(filePath, content, language) {
 }
 
 // src/sast/semgrep.ts
-import { execFile as execFile2, execFileSync as execFileSync2, spawn } from "child_process";
+import { execFile as execFile2, execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var _execFileAsync = promisify2(execFile2);
 var semgrepAvailableCache = null;
@@ -59294,7 +59468,7 @@ function mapSemgrepSeverity(severity) {
 }
 async function executeWithTimeout(command, args2, options) {
   return new Promise((resolve15) => {
-    const child = spawn(command, args2, {
+    const child = spawn2(command, args2, {
       shell: false,
       cwd: options.cwd
     });
@@ -59412,17 +59586,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs33.statSync(filePath);
+    const stats = fs34.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 = fs33.openSync(filePath, "r");
+    const fd = fs34.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs33.readSync(fd, buffer, 0, 8192, 0);
-    fs33.closeSync(fd);
+    const bytesRead = fs34.readSync(fd, buffer, 0, 8192, 0);
+    fs34.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -59461,7 +59635,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs33.readFileSync(filePath, "utf-8");
+    const content = fs34.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -59508,8 +59682,8 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path46.isAbsolute(filePath) ? filePath : path46.resolve(directory, filePath);
-    if (!fs33.existsSync(resolvedPath)) {
+    const resolvedPath = path47.isAbsolute(filePath) ? filePath : path47.resolve(directory, filePath);
+    if (!fs34.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -59707,18 +59881,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path47.win32.resolve(inputPath);
-  } else if (path47.isAbsolute(inputPath)) {
-    resolved = path47.resolve(inputPath);
+    resolved = path48.win32.resolve(inputPath);
+  } else if (path48.isAbsolute(inputPath)) {
+    resolved = path48.resolve(inputPath);
   } else {
-    resolved = path47.resolve(baseDir, inputPath);
+    resolved = path48.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path47.resolve(workspaceDir);
+  const workspaceResolved = path48.resolve(workspaceDir);
   let relative5;
   if (isWinAbs) {
-    relative5 = path47.win32.relative(workspaceResolved, resolved);
+    relative5 = path48.win32.relative(workspaceResolved, resolved);
   } else {
-    relative5 = path47.relative(workspaceResolved, resolved);
+    relative5 = path48.relative(workspaceResolved, resolved);
   }
   if (relative5.startsWith("..")) {
     return "path traversal detected";
@@ -59779,13 +59953,13 @@ async function runLintWrapped(files, directory, _config) {
 }
 async function runLintOnFiles(linter, files, workspaceDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path47.join(workspaceDir, "node_modules", ".bin");
+  const binDir = path48.join(workspaceDir, "node_modules", ".bin");
   const validatedFiles = [];
   for (const file3 of files) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path47.resolve(file3);
+    const resolvedPath = path48.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -59803,10 +59977,10 @@ async function runLintOnFiles(linter, files, workspaceDir) {
   }
   let command;
   if (linter === "biome") {
-    const biomeBin = isWindows ? path47.join(binDir, "biome.EXE") : path47.join(binDir, "biome");
+    const biomeBin = isWindows ? path48.join(binDir, "biome.EXE") : path48.join(binDir, "biome");
     command = [biomeBin, "check", ...validatedFiles];
   } else {
-    const eslintBin = isWindows ? path47.join(binDir, "eslint.cmd") : path47.join(binDir, "eslint");
+    const eslintBin = isWindows ? path48.join(binDir, "eslint.cmd") : path48.join(binDir, "eslint");
     command = [eslintBin, ...validatedFiles];
   }
   try {
@@ -59943,7 +60117,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path47.resolve(file3);
+      const resolvedPath = path48.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -59961,14 +60135,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path47.extname(file3).toLowerCase();
+      const ext = path48.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat2;
       try {
-        stat2 = fs34.statSync(file3);
+        stat2 = fs35.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -59979,7 +60153,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs34.readFileSync(file3);
+        const buffer = fs35.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -60120,7 +60294,7 @@ async function runPreCheckBatch(input, workspaceDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path47.resolve(directory, file3));
+    changedFiles.push(path48.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -60271,7 +60445,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path47.resolve(typedArgs.directory);
+    const resolvedDirectory = path48.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory3(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -60378,8 +60552,8 @@ ${paginatedContent}`;
 init_tool();
 init_manager2();
 init_create_tool();
-import * as fs35 from "fs";
-import * as path48 from "path";
+import * as fs36 from "fs";
+import * as path49 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
   const placeholderPattern = /^\[\w[\w\s]*\]$/;
@@ -60483,19 +60657,19 @@ async function executeSavePlan(args2, fallbackDir) {
   try {
     await savePlan(dir, plan);
     try {
-      const markerPath = path48.join(dir, ".swarm", ".plan-write-marker");
+      const markerPath = path49.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 fs35.promises.writeFile(markerPath, marker, "utf8");
+      await fs36.promises.writeFile(markerPath, marker, "utf8");
     } catch {}
     return {
       success: true,
       message: "Plan saved successfully",
-      plan_path: path48.join(dir, ".swarm", "plan.json"),
+      plan_path: path49.join(dir, ".swarm", "plan.json"),
       phases_count: plan.phases.length,
       tasks_count: tasksCount
     };
@@ -60533,8 +60707,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs36 from "fs";
-import * as path49 from "path";
+import * as fs37 from "fs";
+import * as path50 from "path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -61228,8 +61402,8 @@ function parsePackageResolved(content) {
     const pins = resolved.pins || [];
     for (const pin of pins) {
       const identity = pin.identity || pin.package || "";
-      const state = pin.state || {};
-      const version3 = state.version || state.revision || "";
+      const state2 = pin.state || {};
+      const version3 = state2.version || state2.revision || "";
       let org = "";
       const location = pin.location || "";
       const orgMatch = location.match(/github\.com\/([^/]+)\//);
@@ -61380,9 +61554,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs36.readdirSync(dir, { withFileTypes: true });
+      const entries = fs37.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path49.join(dir, entry.name);
+        const fullPath = path50.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -61391,7 +61565,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path49.relative(rootDir, fullPath));
+              manifestFiles.push(path50.relative(rootDir, fullPath));
               break;
             }
           }
@@ -61407,13 +61581,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs36.readdirSync(dir, { withFileTypes: true });
+      const entries = fs37.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path49.join(dir, entry.name);
+        const fullPath = path50.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path49.relative(workingDir, fullPath));
+              found.push(path50.relative(workingDir, fullPath));
               break;
             }
           }
@@ -61426,11 +61600,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path49.dirname(file3);
+    let currentDir = path50.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path49.sep) {
-        dirs.add(path49.join(workingDir, currentDir));
-        const parent = path49.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path50.sep) {
+        dirs.add(path50.join(workingDir, currentDir));
+        const parent = path50.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -61444,7 +61618,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs36.mkdirSync(outputDir, { recursive: true });
+    fs37.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -61514,7 +61688,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path49.isAbsolute(relativeOutputDir) ? relativeOutputDir : path49.join(workingDir, relativeOutputDir);
+    const outputDir = path50.isAbsolute(relativeOutputDir) ? relativeOutputDir : path50.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -61537,11 +61711,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path49.isAbsolute(manifestFile) ? manifestFile : path49.join(workingDir, manifestFile);
-        if (!fs36.existsSync(fullPath)) {
+        const fullPath = path50.isAbsolute(manifestFile) ? manifestFile : path50.join(workingDir, manifestFile);
+        if (!fs37.existsSync(fullPath)) {
           continue;
         }
-        const content = fs36.readFileSync(fullPath, "utf-8");
+        const content = fs37.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -61554,8 +61728,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path49.join(outputDir, filename);
-    fs36.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path50.join(outputDir, filename);
+    fs37.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -61597,8 +61771,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs37 from "fs";
-import * as path50 from "path";
+import * as fs38 from "fs";
+import * as path51 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -61630,28 +61804,28 @@ function normalizePath2(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path50.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path50.sep) ? cwd : cwd + path50.sep;
+    const resolvedPath = path51.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path51.sep) ? cwd : cwd + path51.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path50.extname(resolvedPath).toLowerCase();
+    const ext = path51.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 = fs37.statSync(resolvedPath);
+    const stats = fs38.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs37.existsSync(resolvedPath)) {
+    if (!fs38.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path50.resolve(cwd, candidate);
-    if (fs37.existsSync(candidatePath)) {
-      const stats = fs37.statSync(candidatePath);
+    const candidatePath = path51.resolve(cwd, candidate);
+    if (fs38.existsSync(candidatePath)) {
+      const stats = fs38.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -61660,8 +61834,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs37.readFileSync(specFile, "utf-8");
-  const ext = path50.extname(specFile).toLowerCase();
+  const content = fs38.readFileSync(specFile, "utf-8");
+  const ext = path51.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -61732,12 +61906,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs37.readdirSync(dir, { withFileTypes: true });
+      entries = fs38.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path50.join(dir, entry.name);
+      const fullPath = path51.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -61747,7 +61921,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path50.extname(entry.name).toLowerCase();
+        const ext = path51.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -61765,7 +61939,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs37.readFileSync(filePath, "utf-8");
+  const content = fs38.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;
@@ -61916,8 +62090,8 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs38 from "fs";
-import * as path51 from "path";
+import * as fs39 from "fs";
+import * as path52 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) {
@@ -61946,11 +62120,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path51.resolve(workspace, filePath);
-    const realWorkspace = fs38.realpathSync(workspace);
-    const realResolvedPath = fs38.realpathSync(resolvedPath);
-    const relativePath = path51.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path51.isAbsolute(relativePath)) {
+    const resolvedPath = path52.resolve(workspace, filePath);
+    const realWorkspace = fs39.realpathSync(workspace);
+    const realResolvedPath = fs39.realpathSync(resolvedPath);
+    const relativePath = path52.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path52.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -61962,17 +62136,17 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path51.join(cwd, filePath);
+  const fullPath = path52.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs38.statSync(fullPath);
+    const stats = fs39.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs38.readFileSync(fullPath, "utf-8");
+    content = fs39.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -62114,17 +62288,17 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path51.join(cwd, filePath);
+  const fullPath = path52.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs38.statSync(fullPath);
+    const stats = fs39.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs38.readFileSync(fullPath, "utf-8");
+    content = fs39.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -62197,7 +62371,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path51.extname(file3);
+    const ext = path52.extname(file3);
     if (containsControlCharacters(file3)) {
       return JSON.stringify({
         file: file3,
@@ -62268,8 +62442,8 @@ init_test_runner();
 init_dist();
 init_utils();
 init_create_tool();
-import * as fs39 from "fs";
-import * as path52 from "path";
+import * as fs40 from "fs";
+import * as path53 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -62340,9 +62514,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path52.resolve(paths);
-    const normalizedCwd = path52.resolve(cwd);
-    const normalizedResolved = path52.resolve(resolvedPath);
+    const resolvedPath = path53.resolve(paths);
+    const normalizedCwd = path53.resolve(cwd);
+    const normalizedResolved = path53.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -62358,13 +62532,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path52.extname(filePath).toLowerCase();
+  const ext = path53.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles2(dir, files = []) {
   let entries;
   try {
-    entries = fs39.readdirSync(dir);
+    entries = fs40.readdirSync(dir);
   } catch {
     return files;
   }
@@ -62373,10 +62547,10 @@ function findSourceFiles2(dir, files = []) {
     if (SKIP_DIRECTORIES3.has(entry)) {
       continue;
     }
-    const fullPath = path52.join(dir, entry);
+    const fullPath = path53.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs39.statSync(fullPath);
+      stat2 = fs40.statSync(fullPath);
     } catch {
       continue;
     }
@@ -62469,7 +62643,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs39.existsSync(scanPath)) {
+    if (!fs40.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -62479,13 +62653,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs39.statSync(scanPath);
+    const stat2 = fs40.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path52.extname(scanPath)}`,
+          error: `unsupported file extension: ${path53.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -62498,11 +62672,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs39.statSync(filePath);
+        const fileStat = fs40.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs39.readFileSync(filePath, "utf-8");
+        const content = fs40.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -62530,18 +62704,18 @@ var todo_extract = createSwarmTool({
 // src/tools/update-task-status.ts
 init_tool();
 init_schema();
-import * as fs41 from "fs";
-import * as path54 from "path";
+import * as fs42 from "fs";
+import * as path55 from "path";
 
 // src/hooks/diff-scope.ts
-import * as fs40 from "fs";
-import * as path53 from "path";
+import * as fs41 from "fs";
+import * as path54 from "path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path53.join(directory, ".swarm", "plan.json");
-    if (!fs40.existsSync(planPath))
+    const planPath = path54.join(directory, ".swarm", "plan.json");
+    if (!fs41.existsSync(planPath))
       return null;
-    const raw = fs40.readFileSync(planPath, "utf-8");
+    const raw = fs41.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -62653,7 +62827,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path54.basename(file3);
+    const fileName = path55.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -62675,8 +62849,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     if (hasActiveTurboMode2()) {
       const resolvedDir2 = workingDirectory ?? process.cwd();
       try {
-        const planPath = path54.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs41.readFileSync(planPath, "utf-8");
+        const planPath = path55.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs42.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -62695,8 +62869,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     const resolvedDir = workingDirectory ?? process.cwd();
     try {
-      const evidencePath = path54.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
-      const raw = fs41.readFileSync(evidencePath, "utf-8");
+      const evidencePath = path55.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
+      const raw = fs42.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);
@@ -62719,8 +62893,8 @@ function checkReviewerGate(taskId, workingDirectory) {
         continue;
       }
       validSessionCount++;
-      const state = getTaskState(session, taskId);
-      if (state === "tests_run" || state === "complete") {
+      const state2 = getTaskState(session, taskId);
+      if (state2 === "tests_run" || state2 === "complete") {
         return { blocked: false, reason: "" };
       }
     }
@@ -62731,13 +62905,13 @@ function checkReviewerGate(taskId, workingDirectory) {
     for (const [sessionId, session] of swarmState.agentSessions) {
       if (!(session.taskWorkflowStates instanceof Map))
         continue;
-      const state = getTaskState(session, taskId);
-      stateEntries.push(`${sessionId}: ${state}`);
+      const state2 = getTaskState(session, taskId);
+      stateEntries.push(`${sessionId}: ${state2}`);
     }
     try {
       const resolvedDir2 = workingDirectory ?? process.cwd();
-      const planPath = path54.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs41.readFileSync(planPath, "utf-8");
+      const planPath = path55.join(resolvedDir2, ".swarm", "plan.json");
+      const planRaw = fs42.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -62918,8 +63092,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path54.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path54.sep);
+    normalizedDir = path55.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path55.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -62929,11 +63103,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path54.resolve(normalizedDir);
+    const resolvedDir = path55.resolve(normalizedDir);
     try {
-      const realPath = fs41.realpathSync(resolvedDir);
-      const planPath = path54.join(realPath, ".swarm", "plan.json");
-      if (!fs41.existsSync(planPath)) {
+      const realPath = fs42.realpathSync(resolvedDir);
+      const planPath = path55.join(realPath, ".swarm", "plan.json");
+      if (!fs42.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -63085,16 +63259,24 @@ var OpenCodeSwarm = async (ctx) => {
     classThreshold: 3,
     commentStripThreshold: 5,
     diffLineThreshold: 200
-  }, ctx.directory, (_sessionId, message) => {
-    console.warn(`[slop-detector] ${message}`);
+  }, ctx.directory, (sessionId, message) => {
+    const s = swarmState.agentSessions.get(sessionId);
+    if (s) {
+      s.pendingAdvisoryMessages ??= [];
+      s.pendingAdvisoryMessages.push(message);
+    }
   }) : null;
   const incrementalVerifyHook = config3.incremental_verify?.enabled !== false ? createIncrementalVerifyHook(config3.incremental_verify ?? {
     enabled: true,
     command: null,
     timeoutMs: 30000,
     triggerAgents: ["coder"]
-  }, ctx.directory, (_sessionId, message) => {
-    console.warn(`[incremental-verify] ${message}`);
+  }, ctx.directory, (sessionId, message) => {
+    const s = swarmState.agentSessions.get(sessionId);
+    if (s) {
+      s.pendingAdvisoryMessages ??= [];
+      s.pendingAdvisoryMessages.push(message);
+    }
   }) : null;
   const compactionServiceHook = config3.compaction_service?.enabled !== false ? createCompactionService(config3.compaction_service ?? {
     enabled: true,
@@ -63102,8 +63284,12 @@ var OpenCodeSwarm = async (ctx) => {
     reflectionThreshold: 60,
     emergencyThreshold: 80,
     preserveLastNTurns: 5
-  }, ctx.directory, (_sessionId, message) => {
-    console.warn(`[compaction-service] ${message}`);
+  }, ctx.directory, (sessionId, message) => {
+    const s = swarmState.agentSessions.get(sessionId);
+    if (s) {
+      s.pendingAdvisoryMessages ??= [];
+      s.pendingAdvisoryMessages.push(message);
+    }
   }) : null;
   const snapshotWriterHook = createSnapshotWriterHook(ctx.directory);
   const automationConfig = AutomationConfigSchema.parse(config3.automation ?? {});
@@ -63115,7 +63301,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 = path55.resolve(ctx.directory, ".swarm");
+    const swarmDir = path56.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -63381,7 +63567,8 @@ var OpenCodeSwarm = async (ctx) => {
         const pressureSession = ensureAgentSession(input.sessionID, swarmState.activeAgent.get(input.sessionID) ?? ORCHESTRATOR_NAME);
         if (!pressureSession.contextPressureWarningSent) {
           pressureSession.contextPressureWarningSent = true;
-          console.warn(`[context-pressure] CONTEXT PRESSURE: ${swarmState.lastBudgetPct.toFixed(1)}% of context window estimated used. Prioritize completing the current task.`);
+          pressureSession.pendingAdvisoryMessages ??= [];
+          pressureSession.pendingAdvisoryMessages.push(`CONTEXT PRESSURE: ${swarmState.lastBudgetPct.toFixed(1)}% of context window used. Prioritize completing the current task before starting new work.`);
         }
       }
       await safeHook(activityHooks.toolBefore)(input, output);