opencode-swarm 6.32.4 → 6.33.1

package/dist/index.js

@@ -14798,6 +14798,7 @@ var init_schema = __esm(() => {
     max_consecutive_errors: exports_external.number().min(2).max(20).default(5),
     warning_threshold: exports_external.number().min(0.1).max(0.9).default(0.75),
     idle_timeout_minutes: exports_external.number().min(5).max(240).default(60),
+    no_op_warning_threshold: exports_external.number().min(1).max(100).default(15),
     qa_gates: exports_external.object({
       required_tools: exports_external.array(exports_external.string().min(1)).default([
         "diff",
@@ -14913,6 +14914,7 @@ var init_schema = __esm(() => {
     pipeline: PipelineConfigSchema.optional(),
     phase_complete: PhaseCompleteConfigSchema.optional(),
     qa_retry_limit: exports_external.number().min(1).max(10).default(3),
+    execution_mode: exports_external.enum(["strict", "balanced", "fast"]).default("balanced"),
     inject_phase_reminders: exports_external.boolean().default(true),
     hooks: HooksConfigSchema.optional(),
     gates: GateConfigSchema.optional(),
@@ -36248,7 +36250,7 @@ __export(exports_gate_evidence, {
   deriveRequiredGates: () => deriveRequiredGates,
   DEFAULT_REQUIRED_GATES: () => DEFAULT_REQUIRED_GATES
 });
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync8, unlinkSync as unlinkSync4 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync8, unlinkSync as unlinkSync5 } from "fs";
 import * as path30 from "path";
 function isValidTaskId2(taskId) {
   if (!taskId)
@@ -36316,7 +36318,7 @@ async function atomicWrite(targetPath, content) {
     renameSync8(tempPath, targetPath);
   } finally {
     try {
-      unlinkSync4(tempPath);
+      unlinkSync5(tempPath);
     } catch {}
   }
 }
@@ -46774,6 +46776,8 @@ function formatHandoffMarkdown(data) {
 init_utils2();
 import { mkdirSync as mkdirSync7, renameSync as renameSync4 } from "fs";
 import * as path19 from "path";
+var pendingWrite = null;
+var lastWritePromise = Promise.resolve();
 function serializeAgentSession(s) {
   const gateLog = {};
   const rawGateLog = s.gateLog ?? new Map;
@@ -46858,14 +46862,28 @@ async function writeSnapshot(directory, state) {
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await Bun.write(tempPath, content);
     renameSync4(tempPath, resolvedPath);
-  } catch {}
+  } catch (error93) {
+    console.warn("[snapshot-writer] write failed:", error93 instanceof Error ? error93.message : String(error93));
+  }
 }
 function createSnapshotWriterHook(directory) {
   return async (_input, _output) => {
-    try {
-      await writeSnapshot(directory, swarmState);
-    } catch {}
-  };
+    if (pendingWrite)
+      clearTimeout(pendingWrite);
+    pendingWrite = setTimeout(() => {
+      pendingWrite = null;
+      lastWritePromise = writeSnapshot(directory, swarmState).catch(() => {});
+    }, 2000);
+  };
+}
+async function flushPendingSnapshot(directory) {
+  if (pendingWrite) {
+    clearTimeout(pendingWrite);
+    pendingWrite = null;
+    await writeSnapshot(directory, swarmState).catch(() => {});
+  } else {
+    await lastWritePromise;
+  }
 }
 
 // src/commands/handoff.ts
@@ -46877,6 +46895,7 @@ async function handleHandoffCommand(directory, _args) {
   await Bun.write(tempPath, markdown);
   renameSync5(tempPath, resolvedPath);
   await writeSnapshot(directory, swarmState);
+  await flushPendingSnapshot(directory);
   return `## Handoff Brief Written
 
 Brief written to \`.swarm/handoff.md\`.
@@ -47586,6 +47605,37 @@ async function handleResetCommand(directory, args2) {
 `);
 }
 
+// src/commands/reset-session.ts
+init_utils2();
+import * as fs15 from "fs";
+async function handleResetSessionCommand(directory, _args) {
+  const results = [];
+  try {
+    const statePath = validateSwarmPath(directory, "session/state.json");
+    if (fs15.existsSync(statePath)) {
+      fs15.unlinkSync(statePath);
+      results.push("\u2705 Deleted .swarm/session/state.json");
+    } else {
+      results.push("\u23ED\uFE0F state.json not found (already clean)");
+    }
+  } catch {
+    results.push("\u274C Failed to delete state.json");
+  }
+  const sessionCount = swarmState.agentSessions.size;
+  swarmState.agentSessions.clear();
+  results.push(`\u2705 Cleared ${sessionCount} in-memory agent session(s)`);
+  return [
+    "## Session State Reset",
+    "",
+    ...results,
+    "",
+    "Session state cleared. Plan, evidence, and knowledge preserved.",
+    "",
+    "**Next step:** Start a new OpenCode session. The plugin will initialize fresh session state on startup."
+  ].join(`
+`);
+}
+
 // src/summaries/manager.ts
 init_utils2();
 init_utils();
@@ -47696,18 +47746,18 @@ ${error93 instanceof Error ? error93.message : String(error93)}`;
 
 // src/commands/rollback.ts
 init_utils2();
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as path27 from "path";
 async function handleRollbackCommand(directory, args2) {
   const phaseArg = args2[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs15.existsSync(manifestPath2)) {
+    if (!fs16.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs15.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs16.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -47729,12 +47779,12 @@ async function handleRollbackCommand(directory, args2) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs15.existsSync(manifestPath)) {
+  if (!fs16.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs15.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs16.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -47744,10 +47794,10 @@ async function handleRollbackCommand(directory, args2) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs15.existsSync(checkpointDir)) {
+  if (!fs16.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs15.readdirSync(checkpointDir);
+  const checkpointFiles = fs16.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -47758,7 +47808,7 @@ async function handleRollbackCommand(directory, args2) {
     const src = path27.join(checkpointDir, file3);
     const dest = path27.join(swarmDir, file3);
     try {
-      fs15.cpSync(src, dest, { recursive: true, force: true });
+      fs16.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -47775,7 +47825,7 @@ async function handleRollbackCommand(directory, args2) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs15.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs16.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93);
@@ -47818,11 +47868,11 @@ async function handleSimulateCommand(directory, args2) {
   ];
   const report = reportLines.filter(Boolean).join(`
 `);
-  const fs16 = await import("fs/promises");
+  const fs17 = await import("fs/promises");
   const path28 = await import("path");
   const reportPath = path28.join(directory, ".swarm", "simulate-report.md");
-  await fs16.mkdir(path28.dirname(reportPath), { recursive: true });
-  await fs16.writeFile(reportPath, report, "utf-8");
+  await fs17.mkdir(path28.dirname(reportPath), { recursive: true });
+  await fs17.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
 
@@ -48179,7 +48229,7 @@ init_utils2();
 init_manager2();
 
 // src/services/compaction-service.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as path28 from "path";
 function makeInitialState() {
   return {
@@ -48201,7 +48251,7 @@ function appendSnapshot(directory, tier, budgetPct, message) {
 ## [${tier.toUpperCase()}] ${timestamp} \u2014 ${budgetPct.toFixed(1)}% used
 ${message}
 `;
-    fs16.appendFileSync(snapshotPath, entry, "utf-8");
+    fs17.appendFileSync(snapshotPath, entry, "utf-8");
   } catch {}
 }
 function buildObservationMessage(budgetPct) {
@@ -48749,6 +48799,47 @@ async function executeWriteRetro(args2, directory) {
       message: "Invalid summary: must be a non-empty string"
     }, null, 2);
   }
+  if (args2.task_id !== undefined) {
+    const tid = args2.task_id;
+    if (!tid || tid.length === 0 || tid.length > 200) {
+      return JSON.stringify({
+        success: false,
+        phase,
+        message: "Invalid task ID: must match pattern"
+      }, null, 2);
+    }
+    if (/\0/.test(tid)) {
+      return JSON.stringify({
+        success: false,
+        phase,
+        message: "Invalid task ID: contains null bytes"
+      }, null, 2);
+    }
+    for (let i2 = 0;i2 < tid.length; i2++) {
+      if (tid.charCodeAt(i2) < 32) {
+        return JSON.stringify({
+          success: false,
+          phase,
+          message: "Invalid task ID: contains control characters"
+        }, null, 2);
+      }
+    }
+    if (tid.includes("..") || tid.includes("/") || tid.includes("\\")) {
+      return JSON.stringify({
+        success: false,
+        phase,
+        message: "Invalid task ID: path traversal detected"
+      }, null, 2);
+    }
+    const VALID_TASK_ID = /^(retro-\d+|\d+\.\d+(\.\d+)*)$/;
+    if (!VALID_TASK_ID.test(tid)) {
+      return JSON.stringify({
+        success: false,
+        phase,
+        message: "Invalid task ID: must match pattern"
+      }, null, 2);
+    }
+  }
   const taskId = args2.task_id ?? `retro-${phase}`;
   const retroEntry = {
     task_id: taskId,
@@ -48988,6 +49079,10 @@ var COMMAND_REGISTRY = {
     handler: (ctx) => handleResetCommand(ctx.directory, ctx.args),
     description: "Clear swarm state files [--confirm]"
   },
+  "reset-session": {
+    handler: (ctx) => handleResetSessionCommand(ctx.directory, ctx.args),
+    description: "Clear session state while preserving plan, evidence, and knowledge"
+  },
   rollback: {
     handler: (ctx) => handleRollbackCommand(ctx.directory, ctx.args),
     description: "Restore swarm state to a checkpoint <phase>"
@@ -49092,7 +49187,7 @@ init_constants();
 init_schema();
 
 // src/hooks/agent-activity.ts
-import { renameSync as renameSync7, unlinkSync as unlinkSync3 } from "fs";
+import { renameSync as renameSync7, unlinkSync as unlinkSync4 } from "fs";
 init_utils();
 init_utils2();
 function createAgentActivityHooks(config3, directory) {
@@ -49169,7 +49264,7 @@ async function doFlush(directory) {
       renameSync7(tempPath, path29);
     } catch (writeError) {
       try {
-        unlinkSync3(tempPath);
+        unlinkSync4(tempPath);
       } catch {}
       throw writeError;
     }
@@ -49215,7 +49310,7 @@ ${content.substring(endIndex + 1)}`;
 }
 // src/hooks/compaction-customizer.ts
 init_manager2();
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import { join as join25 } from "path";
 init_utils2();
 function createCompactionCustomizerHook(config3, directory) {
@@ -49263,7 +49358,7 @@ function createCompactionCustomizerHook(config3, directory) {
       }
       try {
         const summariesDir = join25(directory, ".swarm", "summaries");
-        const files = await fs17.promises.readdir(summariesDir);
+        const files = await fs18.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
           output.context.push(`[CONTEXT OPTIMIZATION] Tool outputs from earlier in this session have been stored to disk. When compacting, replace any large tool output blocks (bash, test_runner, lint, diff results) with a one-line reference: "[Output stored \u2014 use /swarm retrieve to access full content]". Preserve the tool name, exit status, and any error messages. Discard raw output lines.`);
@@ -49748,7 +49843,7 @@ function maskToolOutput(msg, _threshold) {
 }
 // src/hooks/delegation-gate.ts
 init_schema();
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import * as path31 from "path";
 
 // src/hooks/guardrails.ts
@@ -49809,6 +49904,8 @@ function setStoredInputArgs(callID, args2) {
 function deleteStoredInputArgs(callID) {
   storedInputArgs.delete(callID);
 }
+var toolCallsSinceLastWrite = new Map;
+var noOpWarningIssued = new Set;
 function extractPhaseNumber(phaseString) {
   if (!phaseString)
     return 1;
@@ -50326,6 +50423,19 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
           session.modifiedFilesThisCoderTask = [];
         }
       }
+      const sessionId = input.sessionID;
+      const normalizedToolName = input.tool.replace(/^[^:]+[:.]/, "");
+      if (isWriteTool(normalizedToolName)) {
+        toolCallsSinceLastWrite.set(sessionId, 0);
+      } else {
+        const count = (toolCallsSinceLastWrite.get(sessionId) ?? 0) + 1;
+        toolCallsSinceLastWrite.set(sessionId, count);
+        const threshold = cfg.no_op_warning_threshold ?? 15;
+        if (count >= threshold && !noOpWarningIssued.has(sessionId) && session?.pendingAdvisoryMessages) {
+          noOpWarningIssued.add(sessionId);
+          session.pendingAdvisoryMessages.push(`WARNING: Agent has made ${count} tool calls with no file modifications. If you are stuck, use /swarm handoff to reset or /swarm turbo to reduce overhead.`);
+        }
+      }
       const window2 = getActiveWindow(input.sessionID);
       if (!window2)
         return;
@@ -50611,6 +50721,7 @@ function hashArgs(args2) {
 
 // src/hooks/delegation-gate.ts
 init_utils2();
+var pendingCoderScopeByTaskId = new Map;
 function extractTaskLine(text) {
   const match = text.match(/TASK:\s*(.+?)(?:\n|$)/i);
   return match ? match[1].trim() : null;
@@ -50646,7 +50757,7 @@ function getEvidenceTaskId(session, directory) {
     if (!resolvedPlanPath.startsWith(resolvedDirectory + path31.sep) && resolvedPlanPath !== resolvedDirectory) {
       return null;
     }
-    const planContent = fs18.readFileSync(resolvedPlanPath, "utf-8");
+    const planContent = fs19.readFileSync(resolvedPlanPath, "utf-8");
     const plan = JSON.parse(planContent);
     if (!plan || !Array.isArray(plan.phases)) {
       return null;
@@ -50996,6 +51107,11 @@ ${trimComment}${after}`;
           }
         }
         session.declaredCoderScope = declaredFiles.length > 0 ? declaredFiles : null;
+        if (declaredFiles.length > 0 && currentTaskId) {
+          pendingCoderScopeByTaskId.set(currentTaskId, declaredFiles);
+        } else {
+          pendingCoderScopeByTaskId.delete(currentTaskId);
+        }
         try {
           advanceTaskState(session, currentTaskId, "coder_delegated");
         } catch (err2) {
@@ -51123,7 +51239,7 @@ ${warningLines.join(`
 }
 // src/hooks/delegation-sanitizer.ts
 init_utils2();
-import * as fs19 from "fs";
+import * as fs20 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,
@@ -51194,7 +51310,7 @@ function createDelegationSanitizerHook(directory) {
               stripped_patterns: result.stripped,
               timestamp: new Date().toISOString()
             };
-            fs19.appendFileSync(eventsPath, `${JSON.stringify(event)}
+            fs20.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
           } catch {}
         }
@@ -51451,12 +51567,12 @@ init_schema();
 init_manager();
 init_detector();
 init_manager2();
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager2();
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as path33 from "path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
@@ -51614,8 +51730,8 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
     const contextPath = path33.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
-      if (fs20.existsSync(contextPath)) {
-        contextContent = fs20.readFileSync(contextPath, "utf-8");
+      if (fs21.existsSync(contextPath)) {
+        contextContent = fs21.readFileSync(contextPath, "utf-8");
       }
     } catch {
       return {
@@ -52109,11 +52225,11 @@ function createSystemEnhancerHook(config3, directory) {
               if (handoffContent) {
                 const handoffPath = validateSwarmPath(directory, "handoff.md");
                 const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-                if (fs21.existsSync(consumedPath)) {
+                if (fs22.existsSync(consumedPath)) {
                   warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                  fs21.unlinkSync(consumedPath);
+                  fs22.unlinkSync(consumedPath);
                 }
-                fs21.renameSync(handoffPath, consumedPath);
+                fs22.renameSync(handoffPath, consumedPath);
                 const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -52393,11 +52509,11 @@ ${budgetWarning}`);
             if (handoffContent) {
               const handoffPath = validateSwarmPath(directory, "handoff.md");
               const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-              if (fs21.existsSync(consumedPath)) {
+              if (fs22.existsSync(consumedPath)) {
                 warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                fs21.unlinkSync(consumedPath);
+                fs22.unlinkSync(consumedPath);
               }
-              fs21.renameSync(handoffPath, consumedPath);
+              fs22.renameSync(handoffPath, consumedPath);
               const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -53166,7 +53282,7 @@ function isReadTool(toolName) {
 }
 
 // src/hooks/incremental-verify.ts
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import * as path34 from "path";
 
 // src/hooks/spawn-helper.ts
@@ -53242,21 +53358,21 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs22.existsSync(path34.join(projectDir, "bun.lockb")))
+  if (fs23.existsSync(path34.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs22.existsSync(path34.join(projectDir, "pnpm-lock.yaml")))
+  if (fs23.existsSync(path34.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs22.existsSync(path34.join(projectDir, "yarn.lock")))
+  if (fs23.existsSync(path34.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs22.existsSync(path34.join(projectDir, "package-lock.json")))
+  if (fs23.existsSync(path34.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
   const pkgPath = path34.join(projectDir, "package.json");
-  if (fs22.existsSync(pkgPath)) {
+  if (fs23.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs23.readFileSync(pkgPath, "utf8"));
       const scripts = pkg.scripts;
       if (scripts?.typecheck) {
         const pm = detectPackageManager(projectDir);
@@ -53270,8 +53386,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs22.existsSync(path34.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs22.existsSync(path34.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs23.existsSync(path34.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs23.existsSync(path34.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -53279,17 +53395,17 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs22.existsSync(path34.join(projectDir, "go.mod"))) {
+  if (fs23.existsSync(path34.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs22.existsSync(path34.join(projectDir, "Cargo.toml"))) {
+  if (fs23.existsSync(path34.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs22.existsSync(path34.join(projectDir, "pyproject.toml")) || fs22.existsSync(path34.join(projectDir, "requirements.txt")) || fs22.existsSync(path34.join(projectDir, "setup.py"))) {
+  if (fs23.existsSync(path34.join(projectDir, "pyproject.toml")) || fs23.existsSync(path34.join(projectDir, "requirements.txt")) || fs23.existsSync(path34.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
-    const entries = fs22.readdirSync(projectDir);
+    const entries = fs23.readdirSync(projectDir);
     if (entries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       return {
         command: ["dotnet", "build", "--no-restore"],
@@ -53358,7 +53474,7 @@ ${errorSummary}`);
 }
 
 // src/hooks/knowledge-reader.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import * as path35 from "path";
 var JACCARD_THRESHOLD = 0.6;
@@ -53411,7 +53527,7 @@ async function recordLessonsShown(directory, lessonIds, currentPhase) {
   const shownFile = path35.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     let shownData = {};
-    if (existsSync20(shownFile)) {
+    if (existsSync21(shownFile)) {
       const content = await readFile5(shownFile, "utf-8");
       shownData = JSON.parse(content);
     }
@@ -53513,7 +53629,7 @@ async function readMergedKnowledge(directory, config3, context) {
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
   const shownFile = path35.join(directory, ".swarm", ".knowledge-shown.json");
   try {
-    if (!existsSync20(shownFile)) {
+    if (!existsSync21(shownFile)) {
       return;
     }
     const content = await readFile5(shownFile, "utf-8");
@@ -53983,12 +54099,12 @@ Use this data to avoid repeating known failure patterns.`;
 // src/hooks/curator-drift.ts
 init_event_bus();
 init_utils2();
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as path36 from "path";
 var DRIFT_REPORT_PREFIX = "drift-report-phase-";
 async function readPriorDriftReports(directory) {
   const swarmDir = path36.join(directory, ".swarm");
-  const entries = await fs23.promises.readdir(swarmDir).catch(() => null);
+  const entries = await fs24.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
   const reportFiles = entries.filter((name2) => name2.startsWith(DRIFT_REPORT_PREFIX) && name2.endsWith(".json")).sort();
@@ -54015,9 +54131,9 @@ async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
   const swarmDir = path36.dirname(filePath);
-  await fs23.promises.mkdir(swarmDir, { recursive: true });
+  await fs24.promises.mkdir(swarmDir, { recursive: true });
   try {
-    await fs23.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs24.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)}`);
   }
@@ -54303,7 +54419,7 @@ var WRITE_TOOLS = new Set([
   "append",
   "prepend"
 ]);
-function createScopeGuardHook(config3, _directory, injectAdvisory) {
+function createScopeGuardHook(config3, directory, injectAdvisory) {
   const enabled = config3.enabled ?? true;
   const _skipInTurbo = config3.skip_in_turbo ?? false;
   return {
@@ -54320,7 +54436,7 @@ function createScopeGuardHook(config3, _directory, injectAdvisory) {
       const isArchitect2 = stripKnownSwarmPrefix(agentName) === ORCHESTRATOR_NAME;
       if (isArchitect2)
         return;
-      const declaredScope = session?.declaredCoderScope;
+      const declaredScope = session?.declaredCoderScope ?? (session?.currentTaskId ? pendingCoderScopeByTaskId.get(session.currentTaskId) : null);
       if (!declaredScope || declaredScope.length === 0)
         return;
       const argsObj = output.args;
@@ -54328,7 +54444,7 @@ function createScopeGuardHook(config3, _directory, injectAdvisory) {
       if (typeof rawFilePath !== "string" || !rawFilePath)
         return;
       const filePath = rawFilePath.replace(/[\r\n\t]/g, "_").split(String.fromCharCode(27)).join("_").replace(/\[[\d;]*m/g, "");
-      if (!isFileInScope(filePath, declaredScope)) {
+      if (!isFileInScope(filePath, declaredScope, directory)) {
         const taskId = session?.currentTaskId ?? "unknown";
         const violationMessage = `SCOPE VIOLATION: ${agentName} attempted to modify '${filePath}' which is not in declared scope for task ${taskId}. Declared scope: [${declaredScope.slice(0, 3).join(", ")}${declaredScope.length > 3 ? "..." : ""}]`;
         if (session) {
@@ -54351,10 +54467,11 @@ function createScopeGuardHook(config3, _directory, injectAdvisory) {
     }
   };
 }
-function isFileInScope(filePath, scopeEntries) {
-  const resolvedFile = path37.resolve(filePath);
+function isFileInScope(filePath, scopeEntries, directory) {
+  const dir = directory ?? process.cwd();
+  const resolvedFile = path37.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path37.resolve(scope);
+    const resolvedScope = path37.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
     const rel = path37.relative(resolvedScope, resolvedFile);
@@ -54407,7 +54524,7 @@ function createSelfReviewHook(config3, injectAdvisory) {
 }
 
 // src/hooks/slop-detector.ts
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 import * as path38 from "path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
@@ -54453,7 +54570,7 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
 function walkFiles(dir, exts, deadline) {
   const results = [];
   try {
-    for (const entry of fs24.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs25.readdirSync(dir, { withFileTypes: true })) {
       if (deadline !== undefined && Date.now() > deadline)
         break;
       if (entry.isSymbolicLink())
@@ -54473,7 +54590,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs24.existsSync(path38.join(projectDir, "package.json"));
+  const hasPackageJson = fs25.existsSync(path38.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -54496,7 +54613,7 @@ function checkDeadExports(content, projectDir, startTime) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = fs24.readFileSync(file3, "utf-8");
+          const text = fs25.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -54629,7 +54746,7 @@ Review before proceeding.`;
 
 // src/hooks/steering-consumed.ts
 init_utils2();
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -54638,7 +54755,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs25.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs26.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -54804,6 +54921,10 @@ async function rehydrateState(snapshot) {
   }
   if (snapshot.agentSessions) {
     for (const [sessionId, serializedSession] of Object.entries(snapshot.agentSessions)) {
+      if (!serializedSession || typeof serializedSession !== "object" || typeof serializedSession.agentName !== "string" || typeof serializedSession.lastToolCallTime !== "number" || typeof serializedSession.delegationActive !== "boolean") {
+        console.warn("[snapshot-reader] Skipping malformed session %s: missing required fields (agentName, lastToolCallTime, delegationActive)", sessionId);
+        continue;
+      }
       swarmState.agentSessions.set(sessionId, deserializeAgentSession(serializedSession));
     }
   }
@@ -54995,7 +55116,7 @@ var build_check = createSwarmTool({
 // src/tools/check-gate-status.ts
 init_dist();
 init_create_tool();
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 import * as path39 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
 var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
@@ -55019,12 +55140,12 @@ function isPathWithinSwarm(filePath, workspaceRoot) {
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs26.existsSync(evidencePath)) {
+  if (!fs27.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs26.readFileSync(evidencePath, "utf-8");
+    content = fs27.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -55145,7 +55266,7 @@ init_checkpoint();
 // src/tools/complexity-hotspots.ts
 init_dist();
 init_create_tool();
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 import * as path40 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
@@ -55275,11 +55396,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs27.statSync(filePath);
+    const stat2 = fs28.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs27.readFileSync(filePath, "utf-8");
+    const content = fs28.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -55300,7 +55421,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs27.existsSync(fullPath)) {
+    if (!fs28.existsSync(fullPath)) {
       fullPath = path40.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
@@ -55509,7 +55630,7 @@ var curator_analyze = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 import * as path41 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
@@ -55602,9 +55723,9 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
     const resolvedDir = path41.resolve(normalizedDir);
     try {
-      const realPath = fs28.realpathSync(resolvedDir);
+      const realPath = fs29.realpathSync(resolvedDir);
       const planPath2 = path41.join(realPath, ".swarm", "plan.json");
-      if (!fs28.existsSync(planPath2)) {
+      if (!fs29.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -55628,7 +55749,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   const directory = normalizedDir || fallbackDir;
   const planPath = path41.resolve(directory, ".swarm", "plan.json");
-  if (!fs28.existsSync(planPath)) {
+  if (!fs29.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -55637,7 +55758,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs28.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs29.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -56042,7 +56163,7 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as path42 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
@@ -56091,12 +56212,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs29.existsSync(evidenceDir) || !fs29.statSync(evidenceDir).isDirectory()) {
+  if (!fs30.existsSync(evidenceDir) || !fs30.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs29.readdirSync(evidenceDir);
+    files = fs30.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -56112,7 +56233,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs29.lstatSync(filePath);
+      const stat2 = fs30.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -56121,7 +56242,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs29.statSync(filePath);
+      fileStat = fs30.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -56130,7 +56251,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs29.readFileSync(filePath, "utf-8");
+      content = fs30.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -56240,7 +56361,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs29.readFileSync(planPath, "utf-8");
+      planContent = fs30.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -56275,7 +56396,7 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as path43 from "path";
 var EXT_MAP = {
   python: ".py",
@@ -56338,8 +56459,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs30.existsSync(targetDir)) {
-      fs30.mkdirSync(targetDir, { recursive: true });
+    if (!fs31.existsSync(targetDir)) {
+      fs31.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -56361,12 +56482,12 @@ var extract_code_blocks = createSwarmTool({
       const base = path43.basename(filepath, path43.extname(filepath));
       const ext = path43.extname(filepath);
       let counter = 1;
-      while (fs30.existsSync(filepath)) {
+      while (fs31.existsSync(filepath)) {
         filepath = path43.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs30.writeFileSync(filepath, code.trim(), "utf-8");
+        fs31.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -56482,7 +56603,7 @@ var gitingest = createSwarmTool({
 // src/tools/imports.ts
 init_dist();
 init_create_tool();
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 import * as path44 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
@@ -56651,7 +56772,7 @@ var SKIP_DIRECTORIES2 = new Set([
 function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs31.readdirSync(dir);
+    entries = fs32.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -56668,7 +56789,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
     const fullPath = path44.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs31.statSync(fullPath);
+      stat2 = fs32.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -56737,7 +56858,7 @@ var imports = createSwarmTool({
     }
     try {
       const targetFile = path44.resolve(file3);
-      if (!fs31.existsSync(targetFile)) {
+      if (!fs32.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -56747,7 +56868,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs31.statSync(targetFile);
+      const targetStat = fs32.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -56773,12 +56894,12 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs31.statSync(filePath);
+          const stat2 = fs32.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs31.readFileSync(filePath);
+          const buffer = fs32.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -56950,7 +57071,7 @@ var knowledgeAdd = createSwarmTool({
 });
 // src/tools/knowledge-query.ts
 init_dist();
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 init_create_tool();
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
@@ -57020,14 +57141,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync28(swarmPath)) {
+  if (!existsSync29(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync28(hivePath)) {
+  if (!existsSync29(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -57327,7 +57448,7 @@ init_dist();
 init_config();
 init_schema();
 init_manager();
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 import * as path45 from "path";
 init_utils2();
 init_create_tool();
@@ -57587,7 +57708,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs32.readFileSync(planPath, "utf-8");
+      const planRaw = fs33.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")) {
@@ -57618,7 +57739,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs32.readFileSync(planPath, "utf-8");
+      const planRaw = fs33.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -57656,7 +57777,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs32.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs33.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)}`);
@@ -57675,12 +57796,12 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     }
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planJson = fs32.readFileSync(planPath, "utf-8");
+      const planJson = fs33.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planJson);
       const phaseObj = plan.phases.find((p) => p.id === phase);
       if (phaseObj) {
         phaseObj.status = "completed";
-        fs32.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
+        fs33.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
 `, "utf-8");
       }
     } catch (error93) {
@@ -57699,6 +57820,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     agentsMissing,
     warnings
   };
+  await flushPendingSnapshot(dir);
   return JSON.stringify({ ...result, timestamp: event.timestamp, duration_ms: durationMs }, null, 2);
 }
 var phase_complete = createSwarmTool({
@@ -57733,7 +57855,7 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 import * as path46 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
@@ -57752,28 +57874,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs33.existsSync(path46.join(cwd, "package.json"))) {
+  if (fs34.existsSync(path46.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs33.existsSync(path46.join(cwd, "pyproject.toml")) || fs33.existsSync(path46.join(cwd, "requirements.txt"))) {
+  if (fs34.existsSync(path46.join(cwd, "pyproject.toml")) || fs34.existsSync(path46.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs33.existsSync(path46.join(cwd, "Cargo.toml"))) {
+  if (fs34.existsSync(path46.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs33.existsSync(path46.join(cwd, "go.mod"))) {
+  if (fs34.existsSync(path46.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs33.readdirSync(cwd);
+    const files = fs34.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs33.existsSync(path46.join(cwd, "Gemfile")) || fs33.existsSync(path46.join(cwd, "Gemfile.lock"))) {
+  if (fs34.existsSync(path46.join(cwd, "Gemfile")) || fs34.existsSync(path46.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs33.existsSync(path46.join(cwd, "pubspec.yaml"))) {
+  if (fs34.existsSync(path46.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -58835,7 +58957,7 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 import * as path49 from "path";
 
 // node_modules/yocto-queue/index.js
@@ -59003,7 +59125,7 @@ init_lint();
 init_manager();
 
 // src/quality/metrics.ts
-import * as fs34 from "fs";
+import * as fs35 from "fs";
 import * as path47 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
@@ -59042,11 +59164,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs34.statSync(filePath);
+    const stat2 = fs35.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs34.readFileSync(filePath, "utf-8");
+    const content = fs35.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -59057,7 +59179,7 @@ async function computeComplexityDelta(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
-    if (!fs34.existsSync(fullPath)) {
+    if (!fs35.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -59178,7 +59300,7 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs34.readFileSync(filePath, "utf-8");
+    const content = fs35.readFileSync(filePath, "utf-8");
     const ext = path47.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
@@ -59206,7 +59328,7 @@ async function computePublicApiDelta(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
-    if (!fs34.existsSync(fullPath)) {
+    if (!fs35.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -59240,15 +59362,15 @@ async function computeDuplicationRatio(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
-    if (!fs34.existsSync(fullPath)) {
+    if (!fs35.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs34.statSync(fullPath);
+      const stat2 = fs35.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES5) {
         continue;
       }
-      const content = fs34.readFileSync(fullPath, "utf-8");
+      const content = fs35.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -59424,7 +59546,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
   const srcDir = path47.join(workingDir, "src");
-  if (fs34.existsSync(srcDir)) {
+  if (fs35.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
@@ -59432,14 +59554,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
     const dirPath = path47.join(workingDir, dir);
-    if (fs34.existsSync(dirPath)) {
+    if (fs35.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
   const testsDir = path47.join(workingDir, "tests");
-  if (fs34.existsSync(testsDir)) {
+  if (fs35.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
@@ -59447,7 +59569,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
     const dirPath = path47.join(workingDir, dir);
-    if (fs34.existsSync(dirPath) && dirPath !== testsDir) {
+    if (fs35.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -59459,7 +59581,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs34.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs35.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path47.join(dirPath, entry.name);
       if (entry.isDirectory()) {
@@ -59505,7 +59627,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs34.readFileSync(fullPath, "utf-8");
+          const content = fs35.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -59719,7 +59841,7 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 import * as path48 from "path";
 import { extname as extname9 } from "path";
 
@@ -60587,17 +60709,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs35.statSync(filePath);
+    const stats = fs36.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 = fs35.openSync(filePath, "r");
+    const fd = fs36.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs35.readSync(fd, buffer, 0, 8192, 0);
-    fs35.closeSync(fd);
+    const bytesRead = fs36.readSync(fd, buffer, 0, 8192, 0);
+    fs36.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -60636,7 +60758,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs35.readFileSync(filePath, "utf-8");
+    const content = fs36.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -60684,7 +60806,7 @@ async function sastScan(input, directory, config3) {
       continue;
     }
     const resolvedPath = path48.isAbsolute(filePath) ? filePath : path48.resolve(directory, filePath);
-    if (!fs35.existsSync(resolvedPath)) {
+    if (!fs36.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -61143,7 +61265,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let stat2;
       try {
-        stat2 = fs36.statSync(file3);
+        stat2 = fs37.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -61154,7 +61276,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs36.readFileSync(file3);
+        const buffer = fs37.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -61554,7 +61676,7 @@ ${paginatedContent}`;
 init_tool();
 init_manager2();
 init_create_tool();
-import * as fs37 from "fs";
+import * as fs38 from "fs";
 import * as path50 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
@@ -61666,7 +61788,7 @@ async function executeSavePlan(args2, fallbackDir) {
         phases_count: plan.phases.length,
         tasks_count: tasksCount
       });
-      await fs37.promises.writeFile(markerPath, marker, "utf8");
+      await fs38.promises.writeFile(markerPath, marker, "utf8");
     } catch {}
     return {
       success: true,
@@ -61709,7 +61831,7 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 import * as path51 from "path";
 
 // src/sbom/detectors/index.ts
@@ -62556,7 +62678,7 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs38.readdirSync(dir, { withFileTypes: true });
+      const entries = fs39.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path51.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
@@ -62583,7 +62705,7 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs38.readdirSync(dir, { withFileTypes: true });
+      const entries = fs39.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path51.join(dir, entry.name);
         if (entry.isFile()) {
@@ -62620,7 +62742,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs38.mkdirSync(outputDir, { recursive: true });
+    fs39.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -62714,10 +62836,10 @@ var sbom_generate = createSwarmTool({
     for (const manifestFile of manifestFiles) {
       try {
         const fullPath = path51.isAbsolute(manifestFile) ? manifestFile : path51.join(workingDir, manifestFile);
-        if (!fs38.existsSync(fullPath)) {
+        if (!fs39.existsSync(fullPath)) {
           continue;
         }
-        const content = fs38.readFileSync(fullPath, "utf-8");
+        const content = fs39.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -62731,7 +62853,7 @@ var sbom_generate = createSwarmTool({
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
     const outputPath = path51.join(outputDir, filename);
-    fs38.writeFileSync(outputPath, bomJson, "utf-8");
+    fs39.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -62773,7 +62895,7 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs39 from "fs";
+import * as fs40 from "fs";
 import * as path52 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
@@ -62815,19 +62937,19 @@ function discoverSpecFile(cwd, specFileArg) {
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs39.statSync(resolvedPath);
+    const stats = fs40.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs39.existsSync(resolvedPath)) {
+    if (!fs40.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
     const candidatePath = path52.resolve(cwd, candidate);
-    if (fs39.existsSync(candidatePath)) {
-      const stats = fs39.statSync(candidatePath);
+    if (fs40.existsSync(candidatePath)) {
+      const stats = fs40.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -62836,7 +62958,7 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs39.readFileSync(specFile, "utf-8");
+  const content = fs40.readFileSync(specFile, "utf-8");
   const ext = path52.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
@@ -62908,7 +63030,7 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs39.readdirSync(dir, { withFileTypes: true });
+      entries = fs40.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -62941,7 +63063,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs39.readFileSync(filePath, "utf-8");
+  const content = fs40.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;
@@ -63092,7 +63214,7 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs40 from "fs";
+import * as fs41 from "fs";
 import * as path53 from "path";
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
@@ -63123,8 +63245,8 @@ function containsWindowsAttacks(str) {
 function isPathInWorkspace(filePath, workspace) {
   try {
     const resolvedPath = path53.resolve(workspace, filePath);
-    const realWorkspace = fs40.realpathSync(workspace);
-    const realResolvedPath = fs40.realpathSync(resolvedPath);
+    const realWorkspace = fs41.realpathSync(workspace);
+    const realResolvedPath = fs41.realpathSync(resolvedPath);
     const relativePath = path53.relative(realWorkspace, realResolvedPath);
     if (relativePath.startsWith("..") || path53.isAbsolute(relativePath)) {
       return false;
@@ -63144,11 +63266,11 @@ function extractTSSymbols(filePath, cwd) {
   }
   let content;
   try {
-    const stats = fs40.statSync(fullPath);
+    const stats = fs41.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs40.readFileSync(fullPath, "utf-8");
+    content = fs41.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -63296,11 +63418,11 @@ function extractPythonSymbols(filePath, cwd) {
   }
   let content;
   try {
-    const stats = fs40.statSync(fullPath);
+    const stats = fs41.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs40.readFileSync(fullPath, "utf-8");
+    content = fs41.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -63444,7 +63566,7 @@ init_test_runner();
 init_dist();
 init_utils();
 init_create_tool();
-import * as fs41 from "fs";
+import * as fs42 from "fs";
 import * as path54 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
@@ -63540,7 +63662,7 @@ function isSupportedExtension(filePath) {
 function findSourceFiles2(dir, files = []) {
   let entries;
   try {
-    entries = fs41.readdirSync(dir);
+    entries = fs42.readdirSync(dir);
   } catch {
     return files;
   }
@@ -63552,7 +63674,7 @@ function findSourceFiles2(dir, files = []) {
     const fullPath = path54.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs41.statSync(fullPath);
+      stat2 = fs42.statSync(fullPath);
     } catch {
       continue;
     }
@@ -63645,7 +63767,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs41.existsSync(scanPath)) {
+    if (!fs42.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -63655,7 +63777,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs41.statSync(scanPath);
+    const stat2 = fs42.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
@@ -63674,11 +63796,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs41.statSync(filePath);
+        const fileStat = fs42.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs41.readFileSync(filePath, "utf-8");
+        const content = fs42.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -63706,18 +63828,18 @@ var todo_extract = createSwarmTool({
 // src/tools/update-task-status.ts
 init_tool();
 init_schema();
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 import * as path56 from "path";
 
 // src/hooks/diff-scope.ts
-import * as fs42 from "fs";
+import * as fs43 from "fs";
 import * as path55 from "path";
 function getDeclaredScope(taskId, directory) {
   try {
     const planPath = path55.join(directory, ".swarm", "plan.json");
-    if (!fs42.existsSync(planPath))
+    if (!fs43.existsSync(planPath))
       return null;
-    const raw = fs42.readFileSync(planPath, "utf-8");
+    const raw = fs43.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -63852,7 +63974,7 @@ function checkReviewerGate(taskId, workingDirectory) {
       const resolvedDir2 = workingDirectory;
       try {
         const planPath = path56.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs43.readFileSync(planPath, "utf-8");
+        const planRaw = fs44.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -63872,7 +63994,7 @@ function checkReviewerGate(taskId, workingDirectory) {
     const resolvedDir = workingDirectory;
     try {
       const evidencePath = path56.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
-      const raw = fs43.readFileSync(evidencePath, "utf-8");
+      const raw = fs44.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);
@@ -63913,7 +64035,7 @@ function checkReviewerGate(taskId, workingDirectory) {
     try {
       const resolvedDir2 = workingDirectory;
       const planPath = path56.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs43.readFileSync(planPath, "utf-8");
+      const planRaw = fs44.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -64107,9 +64229,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     }
     const resolvedDir = path56.resolve(normalizedDir);
     try {
-      const realPath = fs43.realpathSync(resolvedDir);
+      const realPath = fs44.realpathSync(resolvedDir);
       const planPath = path56.join(realPath, ".swarm", "plan.json");
-      if (!fs43.existsSync(planPath)) {
+      if (!fs44.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -64623,6 +64745,7 @@ var OpenCodeSwarm = async (ctx) => {
       await safeHook(activityHooks.toolBefore)(input, output);
     },
     "tool.execute.after": async (input, output) => {
+      console.debug("[hook-chain] toolAfter start sessionID=%s agent=%s tool=%s", input.sessionID, input.agent, input.tool?.name);
       await activityHooks.toolAfter(input, output);
       await guardrailsHooks.toolAfter(input, output);
       await safeHook(delegationLedgerHook.toolAfter)(input, output);
@@ -64637,12 +64760,15 @@ var OpenCodeSwarm = async (ctx) => {
       await safeHook(darkMatterDetectorHook)(input, output);
       await snapshotWriterHook(input, output);
       await toolSummarizerHook?.(input, output);
-      if (slopDetectorHook)
-        await slopDetectorHook.toolAfter(input, output);
-      if (incrementalVerifyHook)
-        await incrementalVerifyHook.toolAfter(input, output);
-      if (compactionServiceHook)
-        await compactionServiceHook.toolAfter(input, output);
+      const execMode = config3.execution_mode ?? "balanced";
+      if (execMode === "strict") {
+        if (slopDetectorHook)
+          await slopDetectorHook.toolAfter(input, output);
+        if (incrementalVerifyHook)
+          await incrementalVerifyHook.toolAfter(input, output);
+        if (compactionServiceHook)
+          await compactionServiceHook.toolAfter(input, output);
+      }
       const toolOutputConfig = config3.tool_output;
       if (toolOutputConfig && toolOutputConfig.truncation_enabled !== false && typeof output.output === "string") {
         const defaultTruncatableTools = new Set([
@@ -64676,8 +64802,12 @@ var OpenCodeSwarm = async (ctx) => {
           session.lastAgentEventTime = Date.now();
         }
       }
+      deleteStoredInputArgs(input.callID);
     },
-    "chat.message": safeHook(delegationHandler),
+    "chat.message": safeHook(async (input, output) => {
+      console.debug("[session] chat.message sessionID=%s agent=%s", input.sessionID, input.agent);
+      await delegationHandler(input, output);
+    }),
     automation: automationManager
   };
 };