opencode-swarm 7.87.0 → 7.87.2

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.87.0",
+    version: "7.87.2",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -18060,6 +18060,24 @@ var init_git_binary_missing_error = __esm(() => {
   };
 });
 
+// src/utils/transient-retry.ts
+function isTransientSpawnError(error49) {
+  if (!error49 || typeof error49 !== "object")
+    return false;
+  const code = error49.code;
+  return code === "ETIMEDOUT";
+}
+function transientBackoff(attempt) {
+  const delay = RETRY_BASE_DELAY_MS * 2 ** attempt;
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
+  } catch {
+    const start2 = Date.now();
+    while (Date.now() - start2 < delay) {}
+  }
+}
+var MAX_TRANSIENT_RETRIES = 5, RETRY_BASE_DELAY_MS = 200;
+
 // src/git/branch.ts
 import * as child_process from "node:child_process";
 import path6 from "node:path";
@@ -18092,26 +18110,34 @@ function gitExec(args2, cwd) {
   const subcommand = args2[0];
   const hardenedArgs = subcommand === "commit" || subcommand === "tag" ? ["-c", "commit.gpgsign=false", "-c", "tag.gpgsign=false", ...args2] : args2;
   for (const command of windowsGitCandidates()) {
-    const result = child_process.spawnSync(command, hardenedArgs, {
-      cwd,
-      encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
-      windowsHide: true,
-      maxBuffer: GIT_MAX_BUFFER_BYTES,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-    });
-    if (result.error) {
-      if (isGitBinaryMissing(result.error)) {
-        missingGitError ??= result.error;
-        continue;
+    for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
+      const result = child_process.spawnSync(command, hardenedArgs, {
+        cwd,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        windowsHide: true,
+        maxBuffer: GIT_MAX_BUFFER_BYTES,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+      });
+      if (!result.error && result.status === 0) {
+        return result.stdout;
+      }
+      if (result.error) {
+        if (isGitBinaryMissing(result.error)) {
+          missingGitError ??= result.error;
+          break;
+        }
+        if (isTransientSpawnError(result.error) && attempt < MAX_TRANSIENT_RETRIES - 1) {
+          transientBackoff(attempt);
+          continue;
+        }
+        throw new Error(errorMessage(result.error));
+      }
+      if (result.status !== 0) {
+        throw new Error(result.stderr || result.stdout || `git exited with ${result.status}`);
       }
-      throw new Error(errorMessage(result.error));
-    }
-    if (result.status !== 0) {
-      throw new Error(result.stderr || result.stdout || `git exited with ${result.status}`);
     }
-    return result.stdout;
   }
   throw new GitBinaryMissingError(process.platform === "win32" ? "git executable is not available on PATH or common Windows install locations" : "git executable is not available on PATH", { cause: missingGitError });
 }
@@ -60605,20 +60631,31 @@ function writeCheckpointLog(log2, directory) {
   fs23.renameSync(tempPath, logPath);
 }
 function gitExec2(args2, cwd) {
-  const result = child_process3.spawnSync("git", args2, {
-    cwd,
-    encoding: "utf-8",
-    timeout: GIT_TIMEOUT_MS2,
-    stdio: ["ignore", "pipe", "pipe"],
-    windowsHide: true
-  });
-  if (result.error) {
-    throw new Error(`git failed to start: ${result.error.code ?? "unknown"} — ${result.error.message}`);
-  }
-  if (result.status !== 0) {
+  for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
+    const result = child_process3.spawnSync("git", args2, {
+      cwd,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS2,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      maxBuffer: GIT_MAX_BUFFER_BYTES2
+    });
+    if (result.error) {
+      const code = result.error.code;
+      const message = result.error.message ?? "";
+      const isTransient = isTransientSpawnError(result.error) || /ETIMEDOUT|timed out/i.test(message);
+      if (!isTransient || attempt >= MAX_TRANSIENT_RETRIES - 1) {
+        throw new Error(`git failed to start: ${code ?? "unknown"} — ${message}`);
+      }
+      transientBackoff(attempt);
+      continue;
+    }
+    if (result.status === 0) {
+      return result.stdout ?? "";
+    }
     throw new Error(result.stderr?.trim() || `git exited with code ${result.status}`);
   }
-  return result.stdout;
+  throw new Error("git command failed after transient retries");
 }
 function appendRetentionEvent(directory, event) {
   try {
@@ -60635,9 +60672,20 @@ function getCurrentSha(directory) {
 function isGitRepo2(directory) {
   try {
     gitExec2(["rev-parse", "--git-dir"], directory);
-    return true;
-  } catch {
-    return false;
+    return { isRepo: true };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    const isTransient = /ETIMEDOUT|timed out/i.test(message) && !/not a git repository/i.test(message);
+    if (isTransient) {
+      return {
+        isRepo: false,
+        warning: "git probe failed after retry exhaustion — treating as not a git repository"
+      };
+    }
+    return {
+      isRepo: false,
+      warning: "git probe failed — directory may not be a git repository"
+    };
   }
 }
 function handleSave(label, directory) {
@@ -60718,7 +60766,8 @@ function saveCheckpointRecord(label, directory) {
       return { success: false, error: `duplicate label: "${label}"` };
     }
     let sha = "";
-    if (isGitRepo2(directory)) {
+    const repoProbe = isGitRepo2(directory);
+    if (repoProbe.isRepo) {
       try {
         sha = getCurrentSha(directory);
       } catch {
@@ -60731,7 +60780,14 @@ function saveCheckpointRecord(label, directory) {
       timestamp: new Date().toISOString()
     });
     writeCheckpointLog(log2, directory);
-    return { success: true, sha };
+    const result = {
+      success: true,
+      sha
+    };
+    if (!sha) {
+      result.warning = "no git restore target — checkpoint recorded without a SHA (directory may not be a git repository or HEAD is unavailable)";
+    }
+    return result;
   } catch (e) {
     return {
       success: false,
@@ -60805,11 +60861,12 @@ function handleDelete(label, directory) {
     }, null, 2);
   }
 }
-var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json", MAX_LABEL_LENGTH = 100, GIT_TIMEOUT_MS2 = 30000, SHELL_METACHARACTERS, SAFE_LABEL_PATTERN, CONTROL_CHAR_PATTERN, NON_ASCII_PATTERN, checkpoint;
+var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json", MAX_LABEL_LENGTH = 100, GIT_TIMEOUT_MS2 = 30000, GIT_MAX_BUFFER_BYTES2, SHELL_METACHARACTERS, SAFE_LABEL_PATTERN, CONTROL_CHAR_PATTERN, NON_ASCII_PATTERN, checkpoint;
 var init_checkpoint = __esm(() => {
   init_zod();
   init_config();
   init_create_tool();
+  GIT_MAX_BUFFER_BYTES2 = 5 * 1024 * 1024;
   SHELL_METACHARACTERS = /[;|&$`(){}<>!'"]/;
   SAFE_LABEL_PATTERN = /^[a-zA-Z0-9_ -]+$/;
   CONTROL_CHAR_PATTERN = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/;
@@ -60821,11 +60878,12 @@ var init_checkpoint = __esm(() => {
       label: exports_external.string().optional().describe("Checkpoint label (required for save, restore, delete)")
     },
     execute: async (args2, directory) => {
-      if (!isGitRepo2(directory)) {
+      const repoProbe = isGitRepo2(directory);
+      if (!repoProbe.isRepo) {
         return JSON.stringify({
           action: "unknown",
           success: false,
-          error: "not a git repository"
+          error: `${repoProbe.warning ?? "not a git repository"} — checkpoint tools require a git repository`
         }, null, 2);
       }
       let action;
@@ -62914,7 +62972,8 @@ async function runCuratorPostMortem(directory, options = {}) {
   } catch {
     warnings.push("Failed to load plan data.");
   }
-  const reportFilename = `post-mortem-${planId}.md`;
+  const effectivePlanId = planId === "unknown" ? `unknown-${Date.now()}` : planId;
+  const reportFilename = `post-mortem-${effectivePlanId}.md`;
   let reportPath;
   try {
     reportPath = validateSwarmPath(directory, reportFilename);
@@ -62930,22 +62989,22 @@ async function runCuratorPostMortem(directory, options = {}) {
   if (!options.force && isReportValid(reportPath)) {
     return {
       success: true,
-      planId,
+      planId: effectivePlanId,
       reportPath,
       summary: "Post-mortem report already exists (idempotent skip).",
       warnings
     };
   }
-  const lock = await _internals28.acquirePostMortemLock(directory, planId);
+  const lock = await _internals28.acquirePostMortemLock(directory, effectivePlanId);
   if (!lock.acquired) {
     return {
       success: false,
-      planId,
+      planId: effectivePlanId,
       reportPath,
       summary: null,
       warnings: [
         ...warnings,
-        `Concurrent post-mortem run in progress for plan ${planId}; skipped.`
+        `Concurrent post-mortem run in progress for plan ${effectivePlanId}; skipped.`
       ]
     };
   }
@@ -62995,7 +63054,7 @@ async function runCuratorPostMortem(directory, options = {}) {
     if (options.llmDelegate) {
       try {
         const { CURATOR_POSTMORTEM_PROMPT: CURATOR_POSTMORTEM_PROMPT2 } = await Promise.resolve().then(() => exports_explorer);
-        const userInput = assembleLLMInput(planId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
+        const userInput = assembleLLMInput(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
         const ac = new AbortController;
         const timer = setTimeout(() => ac.abort(), 300000);
         let llmOutput;
@@ -63011,17 +63070,17 @@ async function runCuratorPostMortem(directory, options = {}) {
         } finally {
           clearTimeout(timer);
         }
-        reportContent = `# Post-Mortem Report: ${planId}
+        reportContent = `# Post-Mortem Report: ${effectivePlanId}
 Generated: ${new Date().toISOString()}
 
 ${llmOutput}`;
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
         warnings.push(`LLM delegate failed, falling back to data-only report: ${msg}`);
-        reportContent = _internals28.buildDataOnlyReport(planId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
+        reportContent = _internals28.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
       }
     } else {
-      reportContent = _internals28.buildDataOnlyReport(planId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
+      reportContent = _internals28.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
     }
     try {
       const { mkdirSync: mkdirSync16 } = await import("node:fs");
@@ -63031,7 +63090,7 @@ ${llmOutput}`;
       const msg = err2 instanceof Error ? err2.message : String(err2);
       return {
         success: false,
-        planId,
+        planId: effectivePlanId,
         reportPath: null,
         summary: null,
         warnings: [...warnings, `Failed to write report: ${msg}`]
@@ -63041,13 +63100,13 @@ ${llmOutput}`;
     const neverAppliedCount = knowledgeSummary.filter((e) => e.applied === 0 && e.violated === 0 && e.ignored === 0).length;
     const totalViolations = knowledgeSummary.reduce((s, e) => s + e.violated, 0);
     const summary = [
-      `Post-mortem for plan "${planId}": ${totalEntries} knowledge entries reviewed.`,
+      `Post-mortem for plan "${effectivePlanId}": ${totalEntries} knowledge entries reviewed.`,
       `${neverAppliedCount} never-applied entries flagged; ${totalViolations} total violations recorded.`,
       `${proposals.length} pending proposals, ${unactionable.length} quarantined entries.`
     ].join(" ");
     return {
       success: true,
-      planId,
+      planId: effectivePlanId,
       reportPath,
       summary,
       warnings
@@ -71751,6 +71810,7 @@ var init_write_retro = __esm(() => {
 });
 
 // src/commands/close.ts
+import { spawnSync as spawnSync9 } from "node:child_process";
 import * as fsSync6 from "node:fs";
 import { promises as fs28 } from "node:fs";
 import path58 from "node:path";
@@ -71790,8 +71850,9 @@ function countSessionKnowledgeEntries(entries, sessionStart, fallbackCount) {
     return Number.isFinite(createdAtMs) && createdAtMs >= sessionStartMs;
   }).length;
 }
-async function copyDirRecursive(src, dest) {
+async function copyDirRecursiveWithFailures(src, dest) {
   let count = 0;
+  const failures = [];
   const entries = await fs28.readdir(src);
   await fs28.mkdir(dest, { recursive: true });
   for (const entry of entries) {
@@ -71800,17 +71861,32 @@ async function copyDirRecursive(src, dest) {
     try {
       const stat9 = await fs28.stat(srcEntry);
       if (stat9.isDirectory()) {
-        const subCount = await copyDirRecursive(srcEntry, destEntry).catch(() => 0);
-        count += subCount;
+        const subResult = await copyDirRecursiveWithFailures(srcEntry, destEntry);
+        count += subResult.copied;
+        failures.push(...subResult.failures);
       } else {
         try {
           await fs28.copyFile(srcEntry, destEntry);
           count++;
-        } catch {}
+        } catch (err2) {
+          const errno = err2?.code;
+          if (errno !== "ENOENT") {
+            failures.push(`${srcEntry}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+          }
+        }
       }
-    } catch {}
+    } catch (err2) {
+      const errno = err2?.code;
+      if (errno !== "ENOENT") {
+        failures.push(`${srcEntry}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+      }
+    }
   }
-  return count;
+  return { copied: count, failures };
+}
+async function copyDirRecursive(src, dest) {
+  const result = await copyDirRecursiveWithFailures(src, dest);
+  return result.copied;
 }
 function guaranteeAllPlansComplete(planData) {
   const closedPhaseIds = [];
@@ -72082,31 +72158,145 @@ async function runFinalizeStage(ctx) {
     ctx.warnings.push(`Post-mortem failed: ${msg}`);
   }
 }
+async function copySqliteSafe(srcPath, destPath) {
+  if (!fsSync6.existsSync(srcPath)) {
+    return {
+      success: true,
+      skipped: true,
+      reason: "source does not exist (ENOENT)"
+    };
+  }
+  let checkpointVerified = false;
+  try {
+    const result = spawnSync9("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
+      cwd: path58.dirname(srcPath),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 1e4,
+      windowsHide: true,
+      maxBuffer: 1024
+    });
+    if (result.error) {
+      const code = result.error.code;
+      if (code === "ENOENT") {
+        try {
+          await fs28.copyFile(srcPath, destPath);
+          return {
+            success: true,
+            reason: "copied without WAL checkpoint (sqlite3 CLI unavailable)"
+          };
+        } catch (copyErr) {
+          return {
+            success: false,
+            reason: `fallback copy failed: ${copyErr instanceof Error ? copyErr.message : String(copyErr)}`
+          };
+        }
+      }
+      return {
+        success: false,
+        reason: `wal_checkpoint failed: ${result.error instanceof Error ? result.error.message : String(result.error)}`
+      };
+    }
+    if (result.status !== 0) {
+      return {
+        success: false,
+        reason: `wal_checkpoint exited with code ${result.status}`
+      };
+    }
+    const output = (result.stdout || "").trim();
+    const lines = output.split(`
+`).filter((l) => l.trim());
+    if (lines.length >= 1) {
+      const dataLine = lines[0];
+      const columns = dataLine.split("|");
+      const busyFlag = parseInt(columns[0], 10);
+      checkpointVerified = !Number.isNaN(busyFlag) && busyFlag === 0;
+    }
+  } catch (err2) {
+    return {
+      success: false,
+      reason: `wal_checkpoint error: ${err2 instanceof Error ? err2.message : String(err2)}`
+    };
+  }
+  try {
+    await fs28.copyFile(srcPath, destPath);
+    if (checkpointVerified) {
+      return { success: true };
+    }
+    return {
+      success: true,
+      reason: "WAL checkpoint incomplete (busy) — archive copy may be stale, original preserved"
+    };
+  } catch (err2) {
+    return {
+      success: false,
+      reason: `copy failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+    };
+  }
+}
 async function runArchiveStage(ctx) {
   ctx.timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   ctx.archiveSuffix = Math.random().toString(36).slice(2, 8);
   ctx.archiveDir = path58.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
   try {
     await fs28.mkdir(ctx.archiveDir, { recursive: true });
+    const WAL_SIDECAR_FILES = new Set(["swarm.db-shm", "swarm.db-wal"]);
     for (const artifact of ARCHIVE_ARTIFACTS) {
+      if (WAL_SIDECAR_FILES.has(artifact)) {
+        continue;
+      }
       const srcPath = path58.join(ctx.swarmDir, artifact);
       const destPath = path58.join(ctx.archiveDir, artifact);
-      try {
-        await fs28.copyFile(srcPath, destPath);
-        ctx.archivedFileCount++;
-        if (ACTIVE_STATE_TO_CLEAN.includes(artifact)) {
-          ctx.archivedActiveStateFiles.add(artifact);
+      if (artifact === "swarm.db") {
+        const result = await copySqliteSafe(srcPath, destPath);
+        if (result.skipped) {} else if (result.success) {
+          ctx.archivedFileCount++;
+          if (result.reason) {
+            ctx.warnings.push(`Archived ${artifact}: ${result.reason}. Original preserved to prevent data loss.`);
+          } else {
+            ctx.archivedActiveStateFiles.add(artifact);
+          }
+        } else {
+          ctx.archiveFailureReasons.set(artifact, result.reason);
+          ctx.warnings.push(`Failed to archive ${artifact}: ${result.reason}. File preserved (not cleaned up).`);
         }
-      } catch {}
+      } else {
+        try {
+          await fs28.copyFile(srcPath, destPath);
+          ctx.archivedFileCount++;
+          if (ACTIVE_STATE_TO_CLEAN.includes(artifact)) {
+            ctx.archivedActiveStateFiles.add(artifact);
+          }
+        } catch (err2) {
+          const errno = err2?.code;
+          if (errno === "ENOENT") {} else {
+            const reason = err2 instanceof Error ? err2.message : String(err2);
+            ctx.archiveFailureReasons.set(artifact, `${errno ?? "unknown"}: ${reason}`);
+            ctx.warnings.push(`Failed to archive ${artifact} [${errno ?? "unknown"}]: ${reason}. File preserved (not cleaned up).`);
+          }
+        }
+      }
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
       const srcDir = path58.join(ctx.swarmDir, dirName);
       const destDir = path58.join(ctx.archiveDir, dirName);
       try {
-        const copied = await copyDirRecursive(srcDir, destDir);
-        ctx.archivedFileCount += copied;
-        ctx.archivedActiveStateDirs.add(dirName);
-      } catch {}
+        const result = await copyDirRecursiveWithFailures(srcDir, destDir);
+        ctx.archivedFileCount += result.copied;
+        if (result.failures.length === 0) {
+          ctx.archivedActiveStateDirs.add(dirName);
+        } else {
+          ctx.warnings.push(`Directory ${dirName} not fully archived (${result.failures.length} failure(s)). Source preserved.`);
+          for (const failure of result.failures) {
+            ctx.warnings.push(`  - ${failure}`);
+          }
+        }
+      } catch (err2) {
+        const code = err2.code;
+        if (code !== "ENOENT") {
+          ctx.warnings.push(`Failed to archive directory ${dirName} [${code ?? "unknown"}]: ${err2.message}. Source preserved.`);
+        }
+      }
     }
     ctx.archiveResult = `Archived ${ctx.archivedFileCount} artifact(s) to .swarm/archive/swarm-${ctx.timestamp}-${ctx.archiveSuffix}/`;
   } catch (archiveError) {
@@ -72147,14 +72337,21 @@ async function runCleanStage(ctx) {
   if (ctx.archivedActiveStateFiles.size > 0) {
     for (const artifact of ACTIVE_STATE_TO_CLEAN) {
       if (!ctx.archivedActiveStateFiles.has(artifact)) {
-        ctx.warnings.push(`Preserved ${artifact} because it was not successfully archived.`);
+        const reason = ctx.archiveFailureReasons?.get(artifact);
+        ctx.warnings.push(reason ? `Preserved ${artifact} because it was not successfully archived: ${reason}.` : `Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
       const filePath = path58.join(ctx.swarmDir, artifact);
       try {
         await fs28.unlink(filePath);
         cleanedFiles.push(artifact);
-      } catch {}
+      } catch (err2) {
+        const errno = err2?.code;
+        if (errno === "ENOENT") {} else {
+          const reason = err2 instanceof Error ? err2.message : String(err2);
+          ctx.warnings.push(`Failed to clean active-state file ${artifact} [${errno ?? "unknown"}]: ${reason}`);
+        }
+      }
     }
   } else {
     ctx.warnings.push("Skipped active-state cleanup because no active-state files were archived. Files preserved to prevent data loss.");
@@ -72176,15 +72373,33 @@ async function runCleanStage(ctx) {
       try {
         await fs28.unlink(path58.join(ctx.swarmDir, backup));
         configBackupsRemoved++;
-      } catch {}
+      } catch (err2) {
+        const errno = err2?.code;
+        if (errno === "ENOENT") {} else {
+          const reason = err2 instanceof Error ? err2.message : String(err2);
+          ctx.warnings.push(`Failed to clean config-backup ${backup} [${errno ?? "unknown"}]: ${reason}`);
+        }
+      }
     }
     const ledgerSiblings = swarmFiles.filter((f) => (f.startsWith("plan-ledger.archived-") || f.startsWith("plan-ledger.backup-")) && f.endsWith(".jsonl"));
     for (const sibling of ledgerSiblings) {
       try {
         await fs28.unlink(path58.join(ctx.swarmDir, sibling));
-      } catch {}
+      } catch (err2) {
+        const errno = err2?.code;
+        if (errno === "ENOENT") {} else {
+          const reason = err2 instanceof Error ? err2.message : String(err2);
+          ctx.warnings.push(`Failed to clean ledger sibling ${sibling} [${errno ?? "unknown"}]: ${reason}`);
+        }
+      }
     }
-  } catch {}
+  } catch (err2) {
+    const errno = err2?.code;
+    if (errno === "ENOENT") {} else {
+      const reason = err2 instanceof Error ? err2.message : String(err2);
+      ctx.warnings.push(`Failed to read ${ctx.swarmDir} for stale-file cleanup [${errno ?? "unknown"}]: ${reason}`);
+    }
+  }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
     path58.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
@@ -72210,9 +72425,21 @@ async function runCleanStage(ctx) {
       try {
         await fs28.unlink(path58.join(ctx.swarmDir, tmp));
         tmpFilesRemoved++;
-      } catch {}
+      } catch (err2) {
+        const errno = err2?.code;
+        if (errno === "ENOENT") {} else {
+          const reason = err2 instanceof Error ? err2.message : String(err2);
+          ctx.warnings.push(`Failed to clean tmp file ${tmp} [${errno ?? "unknown"}]: ${reason}`);
+        }
+      }
     }
-  } catch {}
+  } catch (err2) {
+    const errno = err2?.code;
+    if (errno === "ENOENT") {} else {
+      const reason = err2 instanceof Error ? err2.message : String(err2);
+      ctx.warnings.push(`Failed to read ${ctx.swarmDir} for tmp-file cleanup [${errno ?? "unknown"}]: ${reason}`);
+    }
+  }
   if (tmpFilesRemoved > 0) {
     cleanedFiles.push(`${tmpFilesRemoved} .tmp.* file(s)`);
   }
@@ -72229,9 +72456,14 @@ async function runCleanStage(ctx) {
     ""
   ].join(`
 `);
+  const contextTempPath = path58.join(path58.dirname(contextPath), `${path58.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await fs28.writeFile(contextPath, contextContent, "utf-8");
+    await fs28.writeFile(contextTempPath, contextContent, "utf-8");
+    fsSync6.renameSync(contextTempPath, contextPath);
   } catch (error93) {
+    try {
+      fsSync6.unlinkSync(contextTempPath);
+    } catch {}
     const msg = error93 instanceof Error ? error93.message : String(error93);
     ctx.warnings.push(`Failed to reset context.md: ${msg}`);
     console.warn("[close-command] Failed to write context.md:", error93);
@@ -72325,15 +72557,33 @@ async function handleCloseCommand(directory, args2, options = {}) {
   if (!finalizeLock.acquired) {
     return `❌ Another /swarm finalize is already running for this project. If you are certain no other run is active, wait for the lock to expire or remove the stale lock and retry.`;
   }
-  const phases = planData.phases ?? [];
-  const inProgressPhases = phases.filter((p) => p.status === "in_progress");
-  const isForced = args2.includes("--force");
-  const runSkillReview = args2.includes("--skill-review");
-  let planAlreadyDone = false;
-  if (planExists) {
-    planAlreadyDone = phases.length > 0 && phases.every((p) => p.status === "complete" || p.status === "completed" || p.status === "blocked" || p.status === "closed");
-  }
   try {
+    if (!planExists) {
+      const archiveDir = path58.join(swarmDir, "archive");
+      try {
+        const archiveEntries = await fs28.readdir(archiveDir);
+        const hasArchiveBundle = archiveEntries.some((entry) => entry.startsWith("swarm-"));
+        if (hasArchiveBundle) {
+          const hasActiveState = [
+            ...ACTIVE_STATE_TO_CLEAN,
+            ...ACTIVE_STATE_DIRS_TO_CLEAN
+          ].some((entry) => fsSync6.existsSync(path58.join(swarmDir, entry)));
+          if (!hasActiveState) {
+            return `✅ Already finalized — nothing to do.
+
+This project was already finalized in a previous /swarm close run. The plan has been archived and cleaned up. No further action is needed.`;
+          }
+        }
+      } catch {}
+    }
+    const phases = planData.phases ?? [];
+    const inProgressPhases = phases.filter((p) => p.status === "in_progress");
+    const isForced = args2.includes("--force");
+    const runSkillReview = args2.includes("--skill-review");
+    let planAlreadyDone = false;
+    if (planExists) {
+      planAlreadyDone = phases.length > 0 && phases.every((p) => p.status === "complete" || p.status === "completed" || p.status === "blocked" || p.status === "closed");
+    }
     const { config: loadedConfig } = _internals37.loadPluginConfigWithMeta(directory);
     const config3 = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
@@ -72370,6 +72620,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
       archivedFileCount: 0,
       archivedActiveStateFiles: new Set,
       archivedActiveStateDirs: new Set,
+      archiveFailureReasons: new Map,
       timestamp: "",
       archiveDir: "",
       archiveSuffix: "",
@@ -72432,9 +72683,14 @@ async function handleCloseCommand(directory, args2, options = {}) {
       ...ctx.warnings.length > 0 ? ["## Warnings", ...ctx.warnings.map((w) => `- ${w}`), ""] : []
     ].join(`
 `);
+    const closeSummaryTempPath = path58.join(path58.dirname(closeSummaryPath), `${path58.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs28.writeFile(closeSummaryPath, summaryContent, "utf-8");
+      await fs28.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
+      fsSync6.renameSync(closeSummaryTempPath, closeSummaryPath);
     } catch (error93) {
+      try {
+        fsSync6.unlinkSync(closeSummaryTempPath);
+      } catch {}
       const msg = error93 instanceof Error ? error93.message : String(error93);
       ctx.warnings.push(`Failed to write close-summary.md: ${msg}`);
       console.warn("[close-command] Failed to write close-summary.md:", error93);
@@ -72877,7 +73133,7 @@ __export(exports_skill_consolidation, {
   consolidationStatePath: () => consolidationStatePath,
   _internals: () => _internals38
 });
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { mkdir as mkdir16, readFile as readFile16, rename as rename9, writeFile as writeFile14 } from "node:fs/promises";
 import * as path60 from "node:path";
 function consolidationStatePath(directory) {
@@ -72885,7 +73141,7 @@ function consolidationStatePath(directory) {
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
-  if (!existsSync31(filePath))
+  if (!existsSync32(filePath))
     return {};
   try {
     const parsed = JSON.parse(await readFile16(filePath, "utf-8"));
@@ -74514,7 +74770,7 @@ var init_gate_bridge = __esm(() => {
 });
 
 // src/services/version-check.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync20, readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join49 } from "node:path";
 function cacheDir() {
@@ -74528,7 +74784,7 @@ function cacheFile() {
 function readVersionCache() {
   try {
     const path65 = cacheFile();
-    if (!existsSync32(path65))
+    if (!existsSync33(path65))
       return null;
     const raw = readFileSync17(path65, "utf-8");
     const parsed = JSON.parse(raw);
@@ -74626,10 +74882,10 @@ var init_version_check = __esm(() => {
 });
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync33 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import { readFile as readFile18 } from "node:fs/promises";
 async function readRawLines(filePath) {
-  if (!existsSync33(filePath))
+  if (!existsSync34(filePath))
     return { entries: [], corrupt: 0 };
   const content = await readFile18(filePath, "utf-8");
   const entries = [];
@@ -74754,7 +75010,7 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync33(filePath))
+  if (!filePath || !existsSync34(filePath))
     return 0;
   try {
     const content = await readFile18(filePath, "utf-8");
@@ -74837,7 +75093,7 @@ var init_knowledge_diagnostics = __esm(() => {
 
 // src/services/diagnose-service.ts
 import * as child_process6 from "node:child_process";
-import { existsSync as existsSync34, readdirSync as readdirSync7, readFileSync as readFileSync18, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync35, readdirSync as readdirSync7, readFileSync as readFileSync18, statSync as statSync11 } from "node:fs";
 import path65 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function validateTaskDag(plan) {
@@ -75085,7 +75341,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync34(directory) || !statSync11(directory).isDirectory()) {
+    if (!existsSync35(directory) || !statSync11(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "❌",
@@ -75150,7 +75406,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path65.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync34(configPath)) {
+  if (!existsSync35(configPath)) {
     return {
       name: "Config Parseability",
       status: "✅",
@@ -75205,11 +75461,11 @@ async function checkGrammarWasmFiles() {
   const thisDir = path65.dirname(fileURLToPath2(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync34(path65.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync35(path65.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync34(path65.join(grammarDir, file3))) {
+    if (!existsSync35(path65.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -75228,7 +75484,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path65.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync34(manifestPath)) {
+  if (!existsSync35(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "✅",
@@ -75280,7 +75536,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path65.join(directory, ".swarm/events.jsonl");
-  if (!existsSync34(eventsPath)) {
+  if (!existsSync35(eventsPath)) {
     return {
       name: "Event Stream",
       status: "✅",
@@ -75321,7 +75577,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path65.join(directory, ".swarm/events.jsonl");
-  if (!existsSync34(eventsPath)) {
+  if (!existsSync35(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "✅",
@@ -75377,7 +75633,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path65.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync34(summaryPath)) {
+    if (!existsSync35(summaryPath)) {
       return {
         name: "Curator",
         status: "✅",
@@ -75579,7 +75835,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkKnowledgeHealth(directory));
   try {
     const evidenceDir = path65.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync34(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const snapshotFiles = existsSync35(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks5.push({
@@ -75612,7 +75868,7 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync34(cachePath)) {
+      if (!existsSync35(cachePath)) {
         cacheRows.push(`⬜ ${cachePath} — absent`);
         continue;
       }
@@ -80899,7 +81155,7 @@ var init_handoff_service = __esm(() => {
 });
 
 // src/session/snapshot-writer.ts
-import { closeSync as closeSync6, fsyncSync as fsyncSync2, mkdirSync as mkdirSync26, openSync as openSync6, renameSync as renameSync15 } from "node:fs";
+import { closeSync as closeSync6, fsyncSync as fsyncSync2, mkdirSync as mkdirSync26, openSync as openSync6, renameSync as renameSync16 } from "node:fs";
 import * as path72 from "node:path";
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -81018,7 +81274,7 @@ async function writeSnapshot(directory, state) {
         closeSync6(fd);
       }
     } catch {}
-    renameSync15(tempPath, resolvedPath);
+    renameSync16(tempPath, resolvedPath);
   } catch (error93) {
     log("[snapshot-writer] write failed", {
       error: error93 instanceof Error ? error93.message : String(error93)
@@ -81051,7 +81307,7 @@ var init_snapshot_writer = __esm(() => {
 
 // src/commands/handoff.ts
 import crypto7 from "node:crypto";
-import { renameSync as renameSync16, unlinkSync as unlinkSync11 } from "node:fs";
+import { renameSync as renameSync17, unlinkSync as unlinkSync12 } from "node:fs";
 async function handleHandoffCommand(directory, _args) {
   const handoffData = await getHandoffData(directory);
   const markdown = formatHandoffMarkdown(handoffData);
@@ -81060,10 +81316,10 @@ async function handleHandoffCommand(directory, _args) {
     const tempPath = `${resolvedPath}.tmp.${crypto7.randomUUID()}`;
     await bunWrite(tempPath, markdown);
     try {
-      renameSync16(tempPath, resolvedPath);
+      renameSync17(tempPath, resolvedPath);
     } catch (renameErr) {
       try {
-        unlinkSync11(tempPath);
+        unlinkSync12(tempPath);
       } catch {}
       throw renameErr;
     }
@@ -81072,10 +81328,10 @@ async function handleHandoffCommand(directory, _args) {
     const promptTempPath = `${promptPath}.tmp.${crypto7.randomUUID()}`;
     await bunWrite(promptTempPath, continuationPrompt);
     try {
-      renameSync16(promptTempPath, promptPath);
+      renameSync17(promptTempPath, promptPath);
     } catch (renameErr) {
       try {
-        unlinkSync11(promptTempPath);
+        unlinkSync12(promptTempPath);
       } catch {}
       throw renameErr;
     }
@@ -81252,7 +81508,7 @@ var init_history = __esm(() => {
 });
 
 // src/commands/_shared/url-security.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 function sanitizeUrl(raw) {
   let urlStr = raw.trim();
   urlStr = urlStr.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
@@ -81417,7 +81673,7 @@ var init_url_security = __esm(() => {
   IPV4_ZERO_NETWORK = /^0\./;
   IPV6_LINK_LOCAL = /^fe80:/i;
   IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-  _internals49 = { spawnSync: spawnSync9 };
+  _internals49 = { spawnSync: spawnSync10 };
 });
 
 // src/commands/issue.ts
@@ -81546,7 +81802,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync41, readFileSync as readFileSync25 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync25 } from "node:fs";
 import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile15 } from "node:fs/promises";
 import * as os14 from "node:os";
 import * as path73 from "node:path";
@@ -81563,7 +81819,7 @@ async function migrateContextToKnowledge(directory, config3) {
   const sentinelPath = path73.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path73.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync41(sentinelPath)) {
+  if (existsSync42(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -81572,7 +81828,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync41(contextPath)) {
+  if (!existsSync42(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -81664,7 +81920,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   const legacyHivePath = _internals50.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path73.join(path73.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync41(sentinelPath)) {
+  if (existsSync42(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -81673,7 +81929,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync41(legacyHivePath)) {
+  if (!existsSync42(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -81875,7 +82131,7 @@ function truncateLesson2(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path73.join(directory, "package.json");
-  if (existsSync41(packageJsonPath)) {
+  if (existsSync42(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync25(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -82494,7 +82750,26 @@ var init_redaction = __esm(() => {
     },
     {
       type: "env_secret",
-      pattern: /\b(?:[A-Z0-9]+_)*(?:KEY|TOKEN|SECRET|PASSWORD)\b\s*=\s*["']?[^\s"'`]{8,}["']?/gi
+      pattern: /\b(?:[A-Z][A-Z0-9]+_)+(?:KEY|TOKEN|SECRET|PASSWORD)\b\s*=\s*["']?[^\s"'`]{8,}["']?/gi
+    },
+    { type: "gitlab_token", pattern: /\bgl(?:pat|ptt)-[A-Za-z0-9_-]{15,}\b/g },
+    { type: "slack_token", pattern: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g },
+    {
+      type: "jwt_token",
+      pattern: /\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g
+    },
+    {
+      type: "aws_secret_access_key",
+      pattern: /\b(?:aws_secret_access_key|AWS_SECRET_ACCESS_KEY)\s*[=:]\s*[A-Za-z0-9/+=]{40}\b/g
+    },
+    {
+      type: "stripe_secret_key",
+      pattern: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{24,}\b/g
+    },
+    { type: "google_api_key", pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+    {
+      type: "openssh_private_key_block",
+      pattern: /-----BEGIN[ ]OPENSSH[ ]PRIVATE[ ]KEY-----[\s\S]*?-----END[ ]OPENSSH[ ]PRIVATE[ ]KEY-----/g
     }
   ];
 });
@@ -83012,7 +83287,7 @@ function normalizeMemoryAgentRole(agentRole) {
   if (base === "critic" || base === "critic_sounding_board" || base === "critic_drift_verifier" || base === "critic_hallucination_verifier" || base === "critic_architecture_supervisor") {
     return "security";
   }
-  if (base === "curator_init" || base === "curator_phase")
+  if (base === "curator_init" || base === "curator_phase" || base === "curator_postmortem")
     return "curator";
   if (base === "docs")
     return "sme";
@@ -83202,7 +83477,7 @@ function scoreMemoryRecordDetailed(record3, request, context) {
   if (request.mode === "injection" && request.requireQuerySignal !== false && !hasQuerySignal) {
     return { item: null, skipReason: "no_signal" };
   }
-  const score = textOverlap * 0.38 + tagOverlap * 0.16 + fileOverlap * 0.12 + symbolOverlap * 0.08 + taskTermOverlap * 0.08 + scopeSpecificityBoost(record3.scope) * 0.12 + kindProfileBoost(record3.kind, request) * 0.06 + roleBoost * 0.05 + record3.confidence * 0.08;
+  const score = textOverlap * SCORING_WEIGHTS.textOverlap + tagOverlap * SCORING_WEIGHTS.tagOverlap + fileOverlap * SCORING_WEIGHTS.fileOverlap + symbolOverlap * SCORING_WEIGHTS.symbolOverlap + taskTermOverlap * SCORING_WEIGHTS.taskTermOverlap + scopeSpecificityBoost(record3.scope) * SCORING_WEIGHTS.scopeSpecificityBoost + kindProfileBoost(record3.kind, request) * SCORING_WEIGHTS.kindProfileBoost + roleBoost * SCORING_WEIGHTS.roleBoost + record3.confidence * SCORING_WEIGHTS.confidence;
   const reasonParts = [
     textOverlap > 0 ? `text_overlap=${textOverlap.toFixed(2)}` : null,
     tagOverlap > 0 ? `tag_overlap=${tagOverlap.toFixed(2)}` : null,
@@ -83278,14 +83553,26 @@ function unionTokens(...sets) {
   }
   return union3;
 }
+var SCORING_WEIGHTS;
 var init_scoring = __esm(() => {
   init_role_profiles();
   init_schema2();
+  SCORING_WEIGHTS = {
+    textOverlap: 0.38,
+    tagOverlap: 0.16,
+    fileOverlap: 0.12,
+    symbolOverlap: 0.08,
+    taskTermOverlap: 0.08,
+    scopeSpecificityBoost: 0.12,
+    kindProfileBoost: 0.06,
+    roleBoost: 0.05,
+    confidence: 0.08
+  };
 });
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync42 } from "node:fs";
+import { existsSync as existsSync43 } from "node:fs";
 import {
   appendFile as appendFile9,
   mkdir as mkdir18,
@@ -83636,7 +83923,7 @@ function validateLoadedProposals(values, config3) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync42(filePath))
+  if (!existsSync43(filePath))
     return [];
   const content = await readFile20(filePath, "utf-8");
   const records = [];
@@ -83796,7 +84083,7 @@ var init_prompt_block = __esm(() => {
 });
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync43 } from "node:fs";
+import { existsSync as existsSync44, renameSync as renameSync18, unlinkSync as unlinkSync13 } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir19, readFile as readFile21, stat as stat10, writeFile as writeFile17 } from "node:fs/promises";
 import * as path75 from "node:path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
@@ -83828,10 +84115,10 @@ async function backupLegacyJsonl(rootDirectory, config3 = {}) {
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
     const source = path75.join(storageDir, filename);
-    if (!existsSync43(source))
+    if (!existsSync44(source))
       continue;
     const backup = path75.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync43(backup)) {
+    if (existsSync44(backup)) {
       results.push({ source, backup, created: false });
       continue;
     }
@@ -83845,20 +84132,47 @@ async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
   await mkdir19(exportDir, { recursive: true });
   const memoriesPath = path75.join(exportDir, "memories.jsonl");
   const proposalsPath = path75.join(exportDir, "proposals.jsonl");
-  await writeFile17(memoriesPath, toJsonl(memories), "utf-8");
-  await writeFile17(proposalsPath, toJsonl(proposals), "utf-8");
+  const memoriesTempPath = path75.join(path75.dirname(memoriesPath), `${path75.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  try {
+    await writeFile17(memoriesTempPath, toJsonl(memories), "utf-8");
+    renameSync18(memoriesTempPath, memoriesPath);
+  } catch (err2) {
+    try {
+      unlinkSync13(memoriesTempPath);
+    } catch {}
+    throw err2;
+  }
+  const proposalsTempPath = path75.join(path75.dirname(proposalsPath), `${path75.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  try {
+    await writeFile17(proposalsTempPath, toJsonl(proposals), "utf-8");
+    renameSync18(proposalsTempPath, proposalsPath);
+  } catch (err2) {
+    try {
+      unlinkSync13(proposalsTempPath);
+    } catch {}
+    throw err2;
+  }
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config3 = {}) {
   const reportPath = path75.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
   await mkdir19(path75.dirname(reportPath), { recursive: true });
-  await writeFile17(reportPath, `${JSON.stringify(report, null, 2)}
+  const reportTempPath = path75.join(path75.dirname(reportPath), `${path75.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  try {
+    await writeFile17(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
+    renameSync18(reportTempPath, reportPath);
+  } catch (err2) {
+    try {
+      unlinkSync13(reportTempPath);
+    } catch {}
+    throw err2;
+  }
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config3 = {}) {
   const reportPath = path75.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
-  if (!existsSync43(reportPath))
+  if (!existsSync44(reportPath))
     return null;
   try {
     return JSON.parse(await readFile21(reportPath, "utf-8"));
@@ -83872,13 +84186,13 @@ async function getLegacyJsonlFileStatus(rootDirectory, config3 = {}) {
   for (const file3 of ["memories.jsonl", "proposals.jsonl"]) {
     const filePath = path75.join(storageDir, file3);
     let sizeBytes = 0;
-    if (existsSync43(filePath)) {
+    if (existsSync44(filePath)) {
       sizeBytes = (await stat10(filePath)).size;
     }
     statuses.push({
       file: file3,
       path: filePath,
-      exists: existsSync43(filePath),
+      exists: existsSync44(filePath),
       sizeBytes
     });
   }
@@ -83959,7 +84273,7 @@ async function readProposalJsonl(filePath, config3) {
   return { records, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync43(filePath)) {
+  if (!existsSync44(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile21(filePath, "utf-8");
@@ -84013,6 +84327,7 @@ class SQLiteMemoryProvider {
   rootDirectory;
   config;
   initialized = false;
+  initPromise = null;
   db = null;
   ftsAvailable = false;
   memories = new Map;
@@ -84056,6 +84371,15 @@ class SQLiteMemoryProvider {
   async initialize() {
     if (this.initialized)
       return;
+    if (!this.initPromise) {
+      this.initPromise = this.doInitialize().catch((err2) => {
+        this.initPromise = null;
+        throw err2;
+      });
+    }
+    return this.initPromise;
+  }
+  async doInitialize() {
     const dbPath = this.databasePath();
     mkdirSync27(path76.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
@@ -84251,6 +84575,7 @@ class SQLiteMemoryProvider {
     this.db = null;
     this.ftsAvailable = false;
     this.initialized = false;
+    this.initPromise = null;
     this.lastAutomaticJsonlMigration = null;
   }
   async importJsonl() {
@@ -84387,8 +84712,6 @@ class SQLiteMemoryProvider {
     try {
       if (!this.hasMigration(FTS_SCHEMA_MIGRATION_NAME)) {
         this.recreateFtsIndex();
-        this.markMigration(FTS_SCHEMA_MIGRATION_VERSION, FTS_SCHEMA_MIGRATION_NAME);
-        this.insertEvent("migration", String(FTS_SCHEMA_MIGRATION_VERSION), FTS_SCHEMA_MIGRATION_NAME);
       } else {
         db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS ${FTS_TABLE_NAME} USING fts5(
 					${ftsCreateColumnsSql()}
@@ -84721,12 +85044,60 @@ class SQLiteMemoryProvider {
   }
   requireDb() {
     if (!this.db)
-      throw new Error("SQLite memory provider is not initialized");
+      throw new MemoryValidationError("SQLite memory provider is not initialized", "provider_not_initialized");
     return this.db;
   }
 }
 function splitSql(sql) {
-  return sql.split(";").map((statement) => statement.trim()).filter(Boolean);
+  const statements = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inLineComment = false;
+  for (let i2 = 0;i2 < sql.length; i2++) {
+    const char = sql[i2];
+    const next = sql[i2 + 1];
+    if (inLineComment) {
+      if (char === `
+`) {
+        inLineComment = false;
+      }
+      continue;
+    }
+    if (inSingleQuote) {
+      if (char === "'" && next === "'") {
+        current += "''";
+        i2++;
+        continue;
+      }
+      current += char;
+      if (char === "'") {
+        inSingleQuote = false;
+      }
+      continue;
+    }
+    if (char === "-" && next === "-") {
+      inLineComment = true;
+      i2++;
+      continue;
+    }
+    if (char === "'") {
+      inSingleQuote = true;
+      current += char;
+      continue;
+    }
+    if (char === ";") {
+      const trimmed2 = current.trim();
+      if (trimmed2)
+        statements.push(trimmed2);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  const trimmed = current.trim();
+  if (trimmed)
+    statements.push(trimmed);
+  return statements;
 }
 function buildFtsQuery(request) {
   const text = request.mode === "injection" && request.task ? `${request.task}
@@ -84790,7 +85161,7 @@ function rerankWithFts(items, ftsOrder) {
     };
   }).sort((a, b) => b.score - a.score || a.record.id.localeCompare(b.record.id));
 }
-var _DatabaseCtor2 = null, FTS_SCHEMA_MIGRATION_VERSION = 3, FTS_SCHEMA_MIGRATION_NAME = "create_memory_fts5_shadow_index", FTS_TABLE_NAME = "memory_items_fts", FTS_INDEX_COLUMNS, FTS_INSERT_COLUMNS, MIGRATIONS2, FTS_STOP_WORDS;
+var _DatabaseCtor2 = null, FTS_SCHEMA_MIGRATION_NAME = "create_memory_fts5_shadow_index", FTS_TABLE_NAME = "memory_items_fts", FTS_INDEX_COLUMNS, FTS_INSERT_COLUMNS, MIGRATIONS2, FTS_STOP_WORDS;
 var init_sqlite_provider = __esm(() => {
   init_utils2();
   init_config3();
@@ -84886,6 +85257,15 @@ var init_sqlite_provider = __esm(() => {
 			CREATE INDEX IF NOT EXISTS idx_memory_recall_usage_bundle
 				ON memory_recall_usage(bundle_id);
 		`
+    },
+    {
+      version: 3,
+      name: "create_memory_fts5_shadow_index",
+      sql: `
+			CREATE VIRTUAL TABLE IF NOT EXISTS ${FTS_TABLE_NAME} USING fts5(
+				${ftsCreateColumnsSql()}
+			);
+		`
     }
   ];
   FTS_STOP_WORDS = new Set([
@@ -84923,7 +85303,7 @@ var init_sqlite_provider = __esm(() => {
 
 // src/memory/gateway.ts
 import { createHash as createHash12 } from "node:crypto";
-import { existsSync as existsSync44, readFileSync as readFileSync26 } from "node:fs";
+import { existsSync as existsSync45, readFileSync as readFileSync26 } from "node:fs";
 import * as path77 from "node:path";
 
 class MemoryGateway {
@@ -85248,7 +85628,7 @@ function readGitRemoteUrl(directory) {
   if (gitRemoteUrlCache.has(directory))
     return gitRemoteUrlCache.get(directory);
   const gitConfigPath = path77.join(directory, ".git", "config");
-  if (!existsSync44(gitConfigPath)) {
+  if (!existsSync45(gitConfigPath)) {
     gitRemoteUrlCache.set(directory, undefined);
     return;
   }
@@ -86036,65 +86416,69 @@ async function recallForAgent(input) {
     agentId: input.agentId,
     runId: input.sessionID
   }, { config: input.config });
-  const resolvedConfig = resolveMemoryConfig(input.config);
-  if (!gateway.isEnabled()) {
-    await logInjectionSkipped(input, "disabled");
-    return null;
-  }
-  if (!resolvedConfig.recall.injection.enabled) {
-    await logInjectionSkipped(input, "disabled");
-    return null;
-  }
-  const scopes = gateway.deriveAllowedScopes();
-  const planInput = {
-    userGoal: compactText(input.userGoal),
-    runId: input.sessionID ?? "unknown",
-    agentRole: input.agentRole,
-    agentId: input.agentId,
-    agentTask: compactText(input.agentTask),
-    touchedFiles: extractTouchedFiles(input.agentTask)
-  };
-  const plan = buildMemoryRecallPlan(planInput, { scopes });
-  plan.maxItems = resolvedConfig.recall.injection.maxItems;
-  plan.tokenBudget = resolvedConfig.recall.injection.tokenBudget;
-  await input.appendRunLog(input.directory, input.sessionID, {
-    event: "recall_requested",
-    runId: input.sessionID ?? "unknown",
-    agentRole: input.agentRole,
-    agentId: input.agentId,
-    metadata: {
+  try {
+    const resolvedConfig = resolveMemoryConfig(input.config);
+    if (!gateway.isEnabled()) {
+      await logInjectionSkipped(input, "disabled");
+      return null;
+    }
+    if (!resolvedConfig.recall.injection.enabled) {
+      await logInjectionSkipped(input, "disabled");
+      return null;
+    }
+    const scopes = gateway.deriveAllowedScopes();
+    const planInput = {
+      userGoal: compactText(input.userGoal),
+      runId: input.sessionID ?? "unknown",
+      agentRole: input.agentRole,
+      agentId: input.agentId,
+      agentTask: compactText(input.agentTask),
+      touchedFiles: extractTouchedFiles(input.agentTask)
+    };
+    const plan = buildMemoryRecallPlan(planInput, { scopes });
+    plan.maxItems = resolvedConfig.recall.injection.maxItems;
+    plan.tokenBudget = resolvedConfig.recall.injection.tokenBudget;
+    await input.appendRunLog(input.directory, input.sessionID, {
+      event: "recall_requested",
+      runId: input.sessionID ?? "unknown",
+      agentRole: input.agentRole,
+      agentId: input.agentId,
+      metadata: {
+        kinds: plan.kinds,
+        maxItems: plan.maxItems,
+        tokenBudget: plan.tokenBudget,
+        scopeTypes: plan.scopes.map((scope) => scope.type)
+      }
+    });
+    const recallInput = {
+      query: plan.query,
+      task: planInput.agentTask,
+      mode: "injection",
+      scopes: plan.scopes,
       kinds: plan.kinds,
       maxItems: plan.maxItems,
       tokenBudget: plan.tokenBudget,
-      scopeTypes: plan.scopes.map((scope) => scope.type)
+      minScore: resolvedConfig.recall.injection.minScore,
+      requireQuerySignal: resolvedConfig.recall.injection.requireQuerySignal
+    };
+    const bundle = await gateway.recall(recallInput);
+    await input.appendRunLog(input.directory, input.sessionID, {
+      event: "recall_returned",
+      runId: input.sessionID ?? "unknown",
+      agentRole: input.agentRole,
+      agentId: input.agentId,
+      bundleId: bundle.id,
+      memoryIds: bundle.items.map((item) => item.record.id),
+      scores: bundle.items.map((item) => item.score),
+      tokenEstimate: bundle.tokenEstimate
+    });
+    if (bundle.items.length === 0) {
+      await logInjectionSkipped(input, bundle.diagnostics?.injectionSkipReason ?? "no_results", bundle);
     }
-  });
-  const recallInput = {
-    query: plan.query,
-    task: planInput.agentTask,
-    mode: "injection",
-    scopes: plan.scopes,
-    kinds: plan.kinds,
-    maxItems: plan.maxItems,
-    tokenBudget: plan.tokenBudget,
-    minScore: resolvedConfig.recall.injection.minScore,
-    requireQuerySignal: resolvedConfig.recall.injection.requireQuerySignal
-  };
-  const bundle = await gateway.recall(recallInput);
-  await input.appendRunLog(input.directory, input.sessionID, {
-    event: "recall_returned",
-    runId: input.sessionID ?? "unknown",
-    agentRole: input.agentRole,
-    agentId: input.agentId,
-    bundleId: bundle.id,
-    memoryIds: bundle.items.map((item) => item.record.id),
-    scores: bundle.items.map((item) => item.score),
-    tokenEstimate: bundle.tokenEstimate
-  });
-  if (bundle.items.length === 0) {
-    await logInjectionSkipped(input, bundle.diagnostics?.injectionSkipReason ?? "no_results", bundle);
+    return { bundle, scopes };
+  } finally {
+    await gateway.dispose?.();
   }
-  return { bundle, scopes };
 }
 async function logInjectionSkipped(input, reason, bundle) {
   await input.appendRunLog(input.directory, input.sessionID, {
@@ -86136,7 +86520,7 @@ function parseTaskToolInput(input) {
   };
 }
 function isCuratorAgent(agentRole) {
-  return agentRole === "curator" || agentRole === "curator_init" || agentRole === "curator_phase";
+  return agentRole === "curator" || agentRole === "curator_init" || agentRole === "curator_phase" || agentRole === "curator_postmortem";
 }
 function messagesContainRecall(messages) {
   return messages.some((message) => message?.parts?.some((part) => typeof part?.text === "string" && (part.text.includes(MEMORY_SENTINEL) || part.text.includes("Retrieved Swarm Memory"))));
@@ -86224,7 +86608,7 @@ var init_memory = __esm(() => {
 });
 
 // src/commands/memory.ts
-import { existsSync as existsSync45 } from "node:fs";
+import { existsSync as existsSync46 } from "node:fs";
 import * as path80 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function handleMemoryCommand(_directory, _args) {
@@ -86256,7 +86640,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config3.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync45(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync46(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -86509,7 +86893,16 @@ function parseEvaluateArgs(directory, args2) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      fixtureDirectory = path80.resolve(directory, next);
+      const resolvedFixtures = path80.resolve(directory, next);
+      const canonical = path80.normalize(resolvedFixtures) + path80.sep;
+      const allowedRootA = path80.normalize(directory) + path80.sep;
+      const allowedRootB = path80.normalize(path80.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path80.sep;
+      if (!canonical.startsWith(allowedRootA) && !canonical.startsWith(allowedRootB)) {
+        return {
+          error: "--fixtures <directory> must resolve under the project directory or the bundled tests/fixtures/memory-recall directory"
+        };
+      }
+      fixtureDirectory = resolvedFixtures;
       i2++;
       continue;
     }
@@ -91094,19 +91487,19 @@ function hasCompoundTestExtension(filename) {
   const lower = filename.toLowerCase();
   return COMPOUND_TEST_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-function isLanguageSpecificTestFile(basename12) {
-  const lower = basename12.toLowerCase();
+function isLanguageSpecificTestFile(basename13) {
+  const lower = basename13.toLowerCase();
   if (lower.endsWith("_test.go"))
     return true;
   if (lower.endsWith(".py") && (lower.startsWith("test_") || lower.endsWith("_test.py")))
     return true;
   if (lower.endsWith("_spec.rb"))
     return true;
-  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename12) || basename12.endsWith("Test.java") || basename12.endsWith("Tests.java") || lower.endsWith("it.java")))
+  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename13) || basename13.endsWith("Test.java") || basename13.endsWith("Tests.java") || lower.endsWith("it.java")))
     return true;
   if (lower.endsWith(".cs") && (lower.endsWith("test.cs") || lower.endsWith("tests.cs")))
     return true;
-  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename12) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
+  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename13) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
     return true;
   if (lower.endsWith(".tests.ps1"))
     return true;
@@ -91114,23 +91507,23 @@ function isLanguageSpecificTestFile(basename12) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename12 = path93.basename(filePath);
-  return hasCompoundTestExtension(basename12) || basename12.includes(".spec.") || basename12.includes(".test.") || isLanguageSpecificTestFile(basename12) || isTestDirectoryPath(normalizedPath);
+  const basename13 = path93.basename(filePath);
+  return hasCompoundTestExtension(basename13) || basename13.includes(".spec.") || basename13.includes(".test.") || isLanguageSpecificTestFile(basename13) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
     const relativeFile = path93.relative(workingDir, absoluteFile);
-    const basename12 = path93.basename(absoluteFile);
+    const basename13 = path93.basename(absoluteFile);
     const dirname43 = path93.dirname(absoluteFile);
     const preferRelativeOutput = !path93.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
-    const nameWithoutExt = basename12.replace(/\.[^.]+$/, "");
-    const ext = path93.extname(basename12);
+    const nameWithoutExt = basename13.replace(/\.[^.]+$/, "");
+    const ext = path93.extname(basename13);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -91141,7 +91534,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
       ...languageSpecificTestNames
     ].map((candidateName) => path93.join(dirname43, candidateName));
     const testDirectoryNames = [
-      basename12,
+      basename13,
       ...genericTestNames,
       ...languageSpecificTestNames
     ];
@@ -94085,7 +94478,9 @@ async function handleResetCommand(directory, args2) {
         fs51.unlinkSync(rootPath);
         results.push(`- ✅ Deleted ${filename} (root)`);
       }
-    } catch {}
+    } catch (err2) {
+      results.push(`- ❌ Failed to delete ${filename}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    }
   }
   try {
     resetAutomationManager();
@@ -95105,6 +95500,11 @@ var init_prm = __esm(() => {
 // src/commands/reset-session.ts
 import * as fs54 from "node:fs";
 import * as path98 from "node:path";
+function errorMessage2(err2) {
+  if (err2 instanceof Error)
+    return err2.message;
+  return String(err2);
+}
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -95118,22 +95518,30 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("❌ Failed to delete state.json");
   }
-  try {
-    const sessionDir = path98.dirname(validateSwarmPath(directory, "session/state.json"));
-    if (fs54.existsSync(sessionDir)) {
-      const files = fs54.readdirSync(sessionDir);
-      const otherFiles = files.filter((f) => f !== "state.json");
-      let deletedCount = 0;
-      for (const file3 of otherFiles) {
-        const filePath = path98.join(sessionDir, file3);
-        if (fs54.lstatSync(filePath).isFile()) {
-          fs54.unlinkSync(filePath);
-          deletedCount++;
-        }
-      }
-      results.push(`✅ Cleaned ${deletedCount} additional session file(s)`);
+  const sessionDir = path98.dirname(validateSwarmPath(directory, "session/state.json"));
+  let sessionFiles = [];
+  if (fs54.existsSync(sessionDir)) {
+    try {
+      sessionFiles = fs54.readdirSync(sessionDir);
+    } catch (err2) {
+      results.push(`❌ Failed to read session directory: ${errorMessage2(err2)}`);
     }
-  } catch {}
+  }
+  for (const file3 of sessionFiles) {
+    if (file3 === "state.json")
+      continue;
+    const filePath = path98.join(sessionDir, file3);
+    try {
+      if (!fs54.existsSync(filePath))
+        continue;
+      if (!fs54.lstatSync(filePath).isFile())
+        continue;
+      fs54.unlinkSync(filePath);
+      results.push(`✓ Deleted ${file3}`);
+    } catch (err2) {
+      results.push(`❌ Failed to delete ${file3}: ${errorMessage2(err2)}`);
+    }
+  }
   const sessionCount = swarmState.agentSessions.size;
   for (const [sessionId, session] of swarmState.agentSessions) {
     resetPrmSessionState(session, sessionId);
@@ -95163,7 +95571,7 @@ var init_reset_session = __esm(() => {
 });
 
 // src/summaries/manager.ts
-import { mkdirSync as mkdirSync29, readdirSync as readdirSync17, renameSync as renameSync17, rmSync as rmSync5, statSync as statSync20 } from "node:fs";
+import { mkdirSync as mkdirSync29, readdirSync as readdirSync17, renameSync as renameSync19, rmSync as rmSync5, statSync as statSync20 } from "node:fs";
 import * as path99 from "node:path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -95213,7 +95621,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   const tempPath = path99.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await bunWrite(tempPath, entryJson);
-    renameSync17(tempPath, summaryPath);
+    renameSync19(tempPath, summaryPath);
   } catch (error93) {
     try {
       rmSync5(tempPath, { force: true });
@@ -95347,6 +95755,7 @@ async function handleRollbackCommand(directory, args2) {
   ]);
   const successes = [];
   const failures = [];
+  const warnings = [];
   for (const file3 of checkpointFiles) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
@@ -95372,30 +95781,39 @@ async function handleRollbackCommand(directory, args2) {
 `);
   }
   const existingLedgerPath = path100.join(swarmDir, "plan-ledger.jsonl");
+  let ledgerDeletionFailed = false;
   if (fs55.existsSync(existingLedgerPath)) {
-    fs55.unlinkSync(existingLedgerPath);
-  }
-  try {
-    const planJsonPath = path100.join(swarmDir, "plan.json");
-    if (fs55.existsSync(planJsonPath)) {
-      const planRaw = fs55.readFileSync(planJsonPath, "utf-8");
-      const plan = PlanSchema.parse(JSON.parse(planRaw));
-      const planId = derivePlanId(plan);
-      const planHash = computePlanHash(plan);
-      await initLedger(directory, planId, planHash, plan);
-      await appendLedgerEvent(directory, {
-        event_type: "plan_rebuilt",
-        source: "rollback",
-        plan_id: planId
-      });
+    try {
+      fs55.unlinkSync(existingLedgerPath);
+    } catch (err2) {
+      ledgerDeletionFailed = true;
+      const errMsg = err2 instanceof Error ? err2.message : String(err2);
+      warnings.push(`⚠️ Warning: Could not delete stale ledger (${errMsg}). The ledger may be inconsistent with the restored plan. Run /swarm reset-session to clean up session state.`);
     }
-  } catch (initError) {
-    return [
-      `Rollback restored files but failed to initialize ledger: ${initError instanceof Error ? initError.message : String(initError)}`,
-      "The .swarm/plan.json has been restored but the ledger may be out of sync.",
-      "Run /swarm reset-session to reinitialize the ledger."
-    ].join(`
+  }
+  if (!ledgerDeletionFailed) {
+    try {
+      const planJsonPath = path100.join(swarmDir, "plan.json");
+      if (fs55.existsSync(planJsonPath)) {
+        const planRaw = fs55.readFileSync(planJsonPath, "utf-8");
+        const plan = PlanSchema.parse(JSON.parse(planRaw));
+        const planId = derivePlanId(plan);
+        const planHash = computePlanHash(plan);
+        await initLedger(directory, planId, planHash, plan);
+        await appendLedgerEvent(directory, {
+          event_type: "plan_rebuilt",
+          source: "rollback",
+          plan_id: planId
+        });
+      }
+    } catch (initError) {
+      return [
+        `Rollback restored files but failed to initialize ledger: ${initError instanceof Error ? initError.message : String(initError)}`,
+        "The .swarm/plan.json has been restored but the ledger may be out of sync.",
+        "Run /swarm reset-session to reinitialize the ledger."
+      ].join(`
 `);
+    }
   }
   const eventsPath = validateSwarmPath(directory, "events.jsonl");
   const rollbackEvent = {
@@ -95410,6 +95828,14 @@ async function handleRollbackCommand(directory, args2) {
   } catch (error93) {
     console.error("Failed to write rollback event:", error93 instanceof Error ? error93.message : String(error93));
   }
+  if (warnings.length > 0) {
+    return [
+      ...warnings,
+      "",
+      `Rolled back to phase ${targetPhase}: ${checkpoint2.label || "no label"}`
+    ].join(`
+`);
+  }
   return `Rolled back to phase ${targetPhase}: ${checkpoint2.label || "no label"}`;
 }
 var init_rollback = __esm(() => {
@@ -95587,6 +96013,7 @@ var init_sdd = __esm(() => {
 });
 
 // src/commands/simulate.ts
+import { renameSync as renameSync20, unlinkSync as unlinkSync18 } from "node:fs";
 async function handleSimulateCommand(directory, args2) {
   const thresholdIndex = args2.indexOf("--threshold");
   const minCommitsIndex = args2.indexOf("--min-commits");
@@ -95638,7 +96065,16 @@ Ensure this is a git repository with commit history.`;
     const path101 = await import("node:path");
     const reportPath = path101.join(directory, ".swarm", "simulate-report.md");
     await fs56.mkdir(path101.dirname(reportPath), { recursive: true });
-    await fs56.writeFile(reportPath, report, "utf-8");
+    const reportTempPath = path101.join(path101.dirname(reportPath), `${path101.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    try {
+      await fs56.writeFile(reportTempPath, report, "utf-8");
+      renameSync20(reportTempPath, reportPath);
+    } catch (err2) {
+      try {
+        unlinkSync18(reportTempPath);
+      } catch {}
+      throw err2;
+    }
   } catch (err2) {
     const writeErr = err2 instanceof Error ? err2.message : String(err2);
     warn(`simulate: failed to write report to ${directory}/.swarm/simulate-report.md`, writeErr);
@@ -103359,11 +103795,11 @@ __export(exports_evidence_summary_integration, {
   createEvidenceSummaryIntegration: () => createEvidenceSummaryIntegration,
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
-import { existsSync as existsSync57, mkdirSync as mkdirSync31, writeFileSync as writeFileSync18 } from "node:fs";
+import { existsSync as existsSync58, mkdirSync as mkdirSync31, writeFileSync as writeFileSync18 } from "node:fs";
 import * as path107 from "node:path";
 function persistSummary(projectDir, artifact, filename) {
   const swarmPath = path107.join(projectDir, ".swarm");
-  if (!existsSync57(swarmPath)) {
+  if (!existsSync58(swarmPath)) {
     mkdirSync31(swarmPath, { recursive: true });
   }
   const artifactPath = path107.join(swarmPath, filename);
@@ -103626,9 +104062,9 @@ function validateFilename(filename) {
     throw new Error("Invalid filename: contains null byte");
   }
   const pathSeparators = ["/", "\\", ".."];
-  for (const sep13 of pathSeparators) {
-    if (filename.includes(sep13)) {
-      throw new Error(`Invalid filename: contains path separator '${sep13}'`);
+  for (const sep14 of pathSeparators) {
+    if (filename.includes(sep14)) {
+      throw new Error(`Invalid filename: contains path separator '${sep14}'`);
     }
   }
   if (filename.startsWith("/") || filename.startsWith("\\") || /^[a-zA-Z]:/.test(filename)) {
@@ -104375,11 +104811,11 @@ var init_schema3 = __esm(() => {
 
 // src/summaries/store.ts
 import {
-  existsSync as existsSync69,
+  existsSync as existsSync70,
   mkdirSync as mkdirSync38,
   readFileSync as readFileSync48,
-  renameSync as renameSync23,
-  unlinkSync as unlinkSync19,
+  renameSync as renameSync26,
+  unlinkSync as unlinkSync22,
   writeFileSync as writeFileSync25
 } from "node:fs";
 import * as path120 from "node:path";
@@ -104388,11 +104824,11 @@ function writeRawSidecar(absPath, bundle) {
   const tempFile = `${absPath}.tmp-${Date.now()}-${process.pid}`;
   try {
     writeFileSync25(tempFile, JSON.stringify(bundle, null, 2), "utf-8");
-    renameSync23(tempFile, absPath);
+    renameSync26(tempFile, absPath);
   } finally {
-    if (existsSync69(tempFile)) {
+    if (existsSync70(tempFile)) {
       try {
-        unlinkSync19(tempFile);
+        unlinkSync22(tempFile);
       } catch {}
     }
   }
@@ -104477,7 +104913,7 @@ function readSupervisorReportRaw(directory, phase) {
   } catch {
     return null;
   }
-  if (!existsSync69(abs))
+  if (!existsSync70(abs))
     return null;
   try {
     const parsed = JSON.parse(readFileSync48(abs, "utf-8"));
@@ -107849,7 +108285,7 @@ __export(exports_runtime, {
   clearParserCache: () => clearParserCache,
   _internals: () => _internals80
 });
-import { existsSync as existsSync74, statSync as statSync28 } from "node:fs";
+import { existsSync as existsSync75, statSync as statSync28 } from "node:fs";
 import * as path133 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 async function initTreeSitter() {
@@ -107917,7 +108353,7 @@ async function loadGrammar(languageId) {
     const parser = new Parser;
     const wasmFileName = getWasmFileName(normalizedId);
     const wasmPath = path133.join(getGrammarsDirAbsolute(), wasmFileName);
-    if (!existsSync74(wasmPath)) {
+    if (!existsSync75(wasmPath)) {
       throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
 ` + `Make sure to run 'bun run build' to copy grammar files to dist/lang/grammars/`);
     }
@@ -108033,17 +108469,17 @@ function normalizeSeparators(filePath) {
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename15 = path135.basename(filePath);
+  const basename16 = path135.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
-      if (basename15 === pattern) {
+      if (basename16 === pattern) {
         return true;
       }
       continue;
     }
     if (pattern.startsWith("**/")) {
       const filenamePattern = pattern.slice(3);
-      if (basename15 === filenamePattern) {
+      if (basename16 === filenamePattern) {
         return true;
       }
       continue;
@@ -108436,7 +108872,7 @@ var init_doc_scan = __esm(() => {
 });
 
 // src/hooks/knowledge-reader.ts
-import { existsSync as existsSync75 } from "node:fs";
+import { existsSync as existsSync76 } from "node:fs";
 import { readFile as readFile28 } from "node:fs/promises";
 import * as path136 from "node:path";
 function inferCategoriesFromPhase(phaseDescription) {
@@ -108484,7 +108920,7 @@ function inferCategoriesFromPhase(phaseDescription) {
 }
 async function transactShownFile(shownFile, mutate) {
   return transactFile(shownFile, async (filePath) => {
-    if (!existsSync75(filePath))
+    if (!existsSync76(filePath))
       return {};
     try {
       const content = await readFile28(filePath, "utf-8");
@@ -108614,7 +109050,7 @@ async function readMergedKnowledge(directory, config3, context, opts) {
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
   const shownFile = path136.join(directory, ".swarm", ".knowledge-shown.json");
   try {
-    if (!existsSync75(shownFile)) {
+    if (!existsSync76(shownFile)) {
       return;
     }
     let shownIds;
@@ -109969,18 +110405,51 @@ var EvidencePlanSchema = exports_external.object({
   }).passthrough()).optional()
 }).passthrough();
 function ghExec(args2, cwd) {
-  const result = child_process7.spawnSync("gh", args2, {
-    cwd,
-    encoding: "utf-8",
-    timeout: GIT_TIMEOUT_MS3,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.status !== 0) {
-    throw new Error(result.stderr || `gh exited with ${result.status}`);
+  for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
+    const result = child_process7.spawnSync("gh", args2, {
+      cwd,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS3,
+      windowsHide: true,
+      maxBuffer: MAX_OUTPUT_BYTES4,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.error) {
+      if (isTransientSpawnError(result.error) && attempt < MAX_TRANSIENT_RETRIES - 1) {
+        transientBackoff(attempt);
+        continue;
+      }
+      if (result.error.code === "ENOENT") {
+        throw new Error(`gh failed to start: ENOENT — gh not installed or not on PATH`);
+      }
+      throw new Error(`gh failed to start: ${result.error.code} — ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+      throw new Error(result.stderr || result.stdout || `gh exited with ${result.status}`);
+    }
+    return result.stdout;
   }
-  return result.stdout;
+  throw new Error("gh exited with null");
 }
 var MAX_OUTPUT_BYTES4 = 5 * 1024 * 1024;
+function spawnSyncWithTransientRetry(command, args2, options) {
+  for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
+    const result = child_process7.spawnSync(command, args2, options);
+    if (result.error) {
+      if (isTransientSpawnError(result.error) && attempt < MAX_TRANSIENT_RETRIES - 1) {
+        transientBackoff(attempt);
+        continue;
+      }
+      throw new Error(`${command} failed: ${result.error.code} — ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+      const reason = result.stderr || result.stdout || `${command} exited with ${result.status}`;
+      throw new Error(`${command} failed: ${reason}`);
+    }
+    return result;
+  }
+  throw new Error(`${command} exited with null`);
+}
 async function ghExecAsync(args2, cwd) {
   return new Promise((resolve42, reject) => {
     const proc = child_process7.spawn("gh", args2, {
@@ -110042,7 +110511,7 @@ async function ghExecAsync(args2, cwd) {
     });
   });
 }
-var _internals70 = { ghExec, ghExecAsync };
+var _internals70 = { ghExec, ghExecAsync, spawnSyncWithTransientRetry };
 async function getPRStatus(prNumber, repoFullName, cwd) {
   let stdout;
   try {
@@ -112074,7 +112543,7 @@ init_state2();
 init_utils();
 init_bun_compat();
 init_utils2();
-import { renameSync as renameSync21, unlinkSync as unlinkSync17 } from "node:fs";
+import { renameSync as renameSync24, unlinkSync as unlinkSync20 } from "node:fs";
 import * as nodePath2 from "node:path";
 function createAgentActivityHooks(config3, directory) {
   if (config3.hooks?.agent_activity === false) {
@@ -112149,10 +112618,10 @@ async function doFlush(directory) {
     const tempPath = `${path116}.tmp`;
     try {
       await bunWrite(tempPath, updated);
-      renameSync21(tempPath, path116);
+      renameSync24(tempPath, path116);
     } catch (writeError) {
       try {
-        unlinkSync17(tempPath);
+        unlinkSync20(tempPath);
       } catch {}
       throw writeError;
     }
@@ -114331,7 +114800,7 @@ import * as path130 from "node:path";
 init_logger();
 init_path_security();
 import * as fsSync8 from "node:fs";
-import { existsSync as existsSync70, realpathSync as realpathSync13 } from "node:fs";
+import { existsSync as existsSync71, realpathSync as realpathSync13 } from "node:fs";
 import * as fsPromises5 from "node:fs/promises";
 import * as os16 from "node:os";
 import * as path125 from "node:path";
@@ -115634,7 +116103,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       if (realRoot === null) {
         return null;
       }
-      if (!existsSync70(resolved)) {
+      if (!existsSync71(resolved)) {
         const EXTENSIONS = [
           ".ts",
           ".tsx",
@@ -115648,7 +116117,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
         let found = null;
         for (const ext of EXTENSIONS) {
           const candidate = resolved + ext;
-          if (existsSync70(candidate)) {
+          if (existsSync71(candidate)) {
             found = candidate;
             break;
           }
@@ -116115,7 +116584,7 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   const walkBudgetMs = options?.walkBudgetMs ?? DEFAULT_WALK_BUDGET_MS;
   const followSymlinks = options?.followSymlinks ?? false;
   const absoluteRoot = path125.resolve(workspaceRoot);
-  if (!existsSync70(absoluteRoot)) {
+  if (!existsSync71(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
   if (isRefusedWorkspaceRoot(absoluteRoot)) {
@@ -116211,7 +116680,7 @@ function getCachedMtime(workspace) {
 }
 // src/tools/repo-graph/incremental.ts
 init_logger();
-import { existsSync as existsSync72 } from "node:fs";
+import { existsSync as existsSync73 } from "node:fs";
 import * as fsPromises7 from "node:fs/promises";
 import * as path129 from "node:path";
 
@@ -116777,7 +117246,7 @@ function buildOntologyPreflightPacket(graph, filePaths = [], options = {}) {
 init_utils2();
 init_logger();
 init_path_security();
-import { constants as constants5, existsSync as existsSync71, readFileSync as readFileSync51, statSync as statSync26 } from "node:fs";
+import { constants as constants5, existsSync as existsSync72, readFileSync as readFileSync51, statSync as statSync26 } from "node:fs";
 import * as fsPromises6 from "node:fs/promises";
 import * as path128 from "node:path";
 var WINDOWS_RENAME_MAX_RETRIES2 = 5;
@@ -116839,7 +117308,7 @@ async function loadGraph(workspace) {
   if (cached3 && !isDirty(normalized)) {
     try {
       const graphPath = getGraphPath(workspace);
-      if (existsSync71(graphPath)) {
+      if (existsSync72(graphPath)) {
         const stats2 = await fsPromises6.stat(graphPath);
         const cachedMtime = getCachedMtime(normalized);
         if (cachedMtime !== undefined && stats2.mtimeMs !== cachedMtime) {
@@ -116856,7 +117325,7 @@ async function loadGraph(workspace) {
   }
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync71(graphPath)) {
+    if (!existsSync72(graphPath)) {
       return null;
     }
     const stats2 = await fsPromises6.stat(graphPath);
@@ -116890,7 +117359,7 @@ function loadGraphSync(workspace) {
   const normalized = path128.normalize(workspace);
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync71(graphPath))
+    if (!existsSync72(graphPath))
       return null;
     const stats2 = statSync26(graphPath);
     const content = readFileSync51(graphPath, "utf-8");
@@ -117020,7 +117489,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
     const normalizedPath = normalizeGraphPath(rawFilePath);
-    const fileExists = existsSync72(rawFilePath);
+    const fileExists = existsSync73(rawFilePath);
     if (fileExists) {
       graph.edges = graph.edges.filter((e) => normalizeGraphPath(e.source) !== normalizedPath);
       const result = scanFile(rawFilePath, absoluteRoot, maxFileSize);
@@ -117060,7 +117529,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   if (loadedMtime !== undefined) {
     try {
       const graphPath = getGraphPath(workspaceRoot);
-      if (existsSync72(graphPath)) {
+      if (existsSync73(graphPath)) {
         const currentStats = await fsPromises7.stat(graphPath);
         if (currentStats.mtimeMs !== loadedMtime) {
           warn(`[repo-graph] Concurrent modification detected — falling back to full rebuild`);
@@ -121221,7 +121690,7 @@ init_task_file();
 init_logger();
 init_knowledge_store();
 var import_proper_lockfile9 = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync77 } from "node:fs";
+import { existsSync as existsSync78 } from "node:fs";
 import { appendFile as appendFile13, mkdir as mkdir28, readFile as readFile30 } from "node:fs/promises";
 import * as path140 from "node:path";
 function resolveApplicationLogPath(directory) {
@@ -121310,7 +121779,7 @@ async function bumpCountersBatch(directory, bumps) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
   await transactKnowledge(swarmPath, applyOne);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync77(hivePath)) {
+  if (existsSync78(hivePath)) {
     await transactKnowledge(hivePath, applyOne);
   }
 }
@@ -122284,7 +122753,7 @@ init_extractors();
 // src/hooks/phase-directives.ts
 init_knowledge_events();
 init_knowledge_store();
-import { existsSync as existsSync78 } from "node:fs";
+import { existsSync as existsSync79 } from "node:fs";
 async function collectPhaseDirectiveIds(directory, phaseLabel) {
   const events = await readKnowledgeEvents(directory);
   const ids = new Set;
@@ -122304,7 +122773,7 @@ async function readEntriesById(directory) {
   for (const e of swarm)
     map3.set(e.id, e);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync78(hivePath)) {
+  if (existsSync79(hivePath)) {
     const hive = await readKnowledge(hivePath);
     for (const e of hive)
       if (!map3.has(e.id))
@@ -124196,7 +124665,7 @@ init_schema();
 // src/services/directive-predicate-runner.ts
 init_bun_compat();
 init_logger();
-import { existsSync as existsSync81 } from "node:fs";
+import { existsSync as existsSync82 } from "node:fs";
 import * as path146 from "node:path";
 var PREDICATE_TIMEOUT_MS = 15000;
 var TOOL_BINARY_ALLOWLIST = new Set([
@@ -124238,7 +124707,7 @@ function findBinaryInPath(binary2) {
     if (!dir)
       continue;
     const candidate = path146.join(dir, exeName);
-    if (existsSync81(candidate))
+    if (existsSync82(candidate))
       return candidate;
   }
   return null;
@@ -125070,7 +125539,7 @@ init_state3();
 init_utils2();
 init_state2();
 init_bun_compat();
-import { renameSync as renameSync25 } from "node:fs";
+import { renameSync as renameSync28 } from "node:fs";
 var TRANSIENT_SESSION_FIELDS = [
   { name: "revisionLimitHit", resetValue: false },
   { name: "coderRevisions", resetValue: 0 },
@@ -125213,7 +125682,7 @@ async function readSnapshot(directory) {
     if (parsed.version !== 1 && parsed.version !== 2) {
       try {
         const quarantinePath = validateSwarmPath(directory, "session/state.json.quarantine");
-        renameSync25(resolvedPath, quarantinePath);
+        renameSync28(resolvedPath, quarantinePath);
       } catch {}
       return null;
     }
@@ -125312,14 +125781,14 @@ init_zod();
 init_path_security();
 init_create_tool();
 import {
-  existsSync as existsSync83,
+  existsSync as existsSync84,
   mkdirSync as mkdirSync39,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync56,
   realpathSync as realpathSync16,
-  renameSync as renameSync26,
+  renameSync as renameSync29,
   rmdirSync,
-  unlinkSync as unlinkSync22,
+  unlinkSync as unlinkSync25,
   writeFileSync as writeFileSync26
 } from "node:fs";
 import * as path149 from "node:path";
@@ -125673,15 +126142,15 @@ function atomicWriteFileSync2(targetPath, content) {
   }
   try {
     writeFileSync26(tempPath, content, "utf-8");
-    renameSync26(tempPath, targetPath);
+    renameSync29(tempPath, targetPath);
   } finally {
-    if (existsSync83(tempPath)) {
+    if (existsSync84(tempPath)) {
       try {
-        unlinkSync22(tempPath);
+        unlinkSync25(tempPath);
       } catch {}
     }
     const tempDir = path149.dirname(tempPath);
-    if (tempDir !== dir && existsSync83(tempDir)) {
+    if (tempDir !== dir && existsSync84(tempDir)) {
       try {
         rmdirSync(tempDir);
       } catch {}
@@ -125758,7 +126227,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
       };
     }
     const parentDir = path149.dirname(fullPath);
-    if (!existsSync83(parentDir)) {
+    if (!existsSync84(parentDir)) {
       return {
         file: targetPath,
         status: "error",
@@ -125774,7 +126243,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
         ]
       };
     }
-    if (existsSync83(fullPath)) {
+    if (existsSync84(fullPath)) {
       return {
         file: targetPath,
         status: "error",
@@ -125849,7 +126318,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
         ]
       };
     }
-    if (!existsSync83(fullPath)) {
+    if (!existsSync84(fullPath)) {
       return {
         file: targetPath,
         status: "error",
@@ -125867,7 +126336,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
     }
     if (!dryRun) {
       try {
-        unlinkSync22(fullPath);
+        unlinkSync25(fullPath);
       } catch (err2) {
         return {
           file: targetPath,
@@ -125893,7 +126362,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
       hunksFailed: 0
     };
   }
-  if (!existsSync83(fullPath)) {
+  if (!existsSync84(fullPath)) {
     return {
       file: targetPath,
       status: "error",
@@ -126044,7 +126513,7 @@ var applyPatch = createSwarmTool({
     const dryRun = obj.dryRun ?? false;
     const allowCreates = obj.allowCreates ?? false;
     const allowDeletes = obj.allowDeletes ?? false;
-    if (!existsSync83(directory)) {
+    if (!existsSync84(directory)) {
       return JSON.stringify(buildErrorResult("Workspace directory does not exist"), null, 2);
     }
     if (files.length === 0) {
@@ -127234,7 +127703,7 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename17 = path153.basename(filePath);
+  const basename18 = path153.basename(filePath);
   const _ext = path153.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
@@ -127250,7 +127719,7 @@ function isTestFile(filePath) {
     ".spec.jsx"
   ];
   for (const pattern of testPatterns) {
-    if (basename17.includes(pattern)) {
+    if (basename18.includes(pattern)) {
       return true;
     }
   }
@@ -127863,7 +128332,7 @@ ${body2}`);
 // src/council/council-evidence-writer.ts
 init_zod();
 init_task_file();
-import { appendFileSync as appendFileSync18, existsSync as existsSync88, mkdirSync as mkdirSync41, readFileSync as readFileSync62 } from "node:fs";
+import { appendFileSync as appendFileSync18, existsSync as existsSync89, mkdirSync as mkdirSync41, readFileSync as readFileSync62 } from "node:fs";
 import { join as join122 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
@@ -127907,7 +128376,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
   await _internals88.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
-    if (existsSync88(filePath)) {
+    if (existsSync89(filePath)) {
       try {
         const parsed = EvidenceFileSchema.parse(JSON.parse(readFileSync62(filePath, "utf-8")));
         safeAssignOwnProps(existingRoot, parsed);
@@ -128302,7 +128771,7 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 // src/council/criteria-store.ts
 init_zod();
 init_task_file();
-import { existsSync as existsSync89, mkdirSync as mkdirSync42, readFileSync as readFileSync63 } from "node:fs";
+import { existsSync as existsSync90, mkdirSync as mkdirSync42, readFileSync as readFileSync63 } from "node:fs";
 import { join as join123 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 var CouncilCriteriaSchema = exports_external.object({
@@ -128326,7 +128795,7 @@ async function writeCriteria(workingDir, taskId, criteria) {
 }
 function readCriteria(workingDir, taskId) {
   const filePath = join123(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
-  if (!existsSync89(filePath))
+  if (!existsSync90(filePath))
     return null;
   try {
     return CouncilCriteriaSchema.parse(JSON.parse(readFileSync63(filePath, "utf-8")));
@@ -130050,11 +130519,11 @@ init_zod();
 init_utils2();
 import { createHash as createHash18 } from "node:crypto";
 import {
-  existsSync as existsSync91,
+  existsSync as existsSync92,
   mkdirSync as mkdirSync43,
   readFileSync as readFileSync66,
-  renameSync as renameSync27,
-  unlinkSync as unlinkSync23,
+  renameSync as renameSync30,
+  unlinkSync as unlinkSync26,
   writeFileSync as writeFileSync28
 } from "node:fs";
 import * as path159 from "node:path";
@@ -130101,7 +130570,7 @@ function storeLaneOutput(directory, input, now = Date.now) {
   const absPath = validateSwarmPath(directory, relPath);
   const timestamp = new Date(now()).toISOString();
   try {
-    if (existsSync91(absPath)) {
+    if (existsSync92(absPath)) {
       const existing = LaneOutputArtifactSchema.safeParse(JSON.parse(readFileSync66(absPath, "utf-8")));
       if (existing.success && existing.data.digest === digest3) {
         return {
@@ -130155,7 +130624,7 @@ function readLaneOutput(directory, ref) {
   if (!REF_RE.test(ref))
     return null;
   const absPath = validateSwarmPath(directory, laneOutputRelativePath(ref));
-  if (!existsSync91(absPath))
+  if (!existsSync92(absPath))
     return null;
   let parsed;
   try {
@@ -130244,7 +130713,7 @@ function writeAtomicJson(absPath, value) {
     let lastRenameError;
     for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES3; attempt++) {
       try {
-        renameSync27(tempFile, absPath);
+        renameSync30(tempFile, absPath);
         lastRenameError = undefined;
         break;
       } catch (err2) {
@@ -130257,9 +130726,9 @@ function writeAtomicJson(absPath, value) {
     if (lastRenameError)
       throw lastRenameError;
   } finally {
-    if (existsSync91(tempFile)) {
+    if (existsSync92(tempFile)) {
       try {
-        unlinkSync23(tempFile);
+        unlinkSync26(tempFile);
       } catch {}
     }
   }
@@ -137109,7 +137578,7 @@ init_zod();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync97 } from "node:fs";
+import { existsSync as existsSync98 } from "node:fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -137185,14 +137654,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync97(swarmPath)) {
+  if (!existsSync98(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync97(hivePath)) {
+  if (!existsSync98(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -138016,8 +138485,8 @@ import * as fs109 from "node:fs";
 import * as path170 from "node:path";
 
 // src/mutation/engine.ts
-import { spawnSync as spawnSync12 } from "node:child_process";
-import { unlinkSync as unlinkSync24, writeFileSync as writeFileSync30 } from "node:fs";
+import { spawnSync as spawnSync13 } from "node:child_process";
+import { unlinkSync as unlinkSync27, writeFileSync as writeFileSync30 } from "node:fs";
 import * as path169 from "node:path";
 
 // src/mutation/equivalence.ts
@@ -138194,7 +138663,7 @@ var _internals106 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
-  spawnSync: spawnSync12
+  spawnSync: spawnSync13
 };
 async function executeMutation(patch, testCommand, testFiles, workingDir) {
   const startTime = Date.now();
@@ -138305,7 +138774,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
         revertError = new Error(`Failed to revert mutation ${patch.id}: ${revertErr}. Working tree may be dirty.`);
       }
       try {
-        unlinkSync24(patchFile);
+        unlinkSync27(patchFile);
       } catch (_unlinkErr) {}
     }
   }
@@ -141202,8 +141671,8 @@ async function runNpmAudit(directory) {
       clean: findings.length === 0
     };
   } catch (error93) {
-    const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
-    if (errorMessage2.includes("audit") || errorMessage2.includes("command not found") || errorMessage2.includes("'npm' is not recognized")) {
+    const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
+    if (errorMessage3.includes("audit") || errorMessage3.includes("command not found") || errorMessage3.includes("'npm' is not recognized")) {
       return {
         ecosystem: "npm",
         command,
@@ -141223,7 +141692,7 @@ async function runNpmAudit(directory) {
       highCount: 0,
       totalCount: 0,
       clean: true,
-      note: `Error running npm audit: ${errorMessage2}`
+      note: `Error running npm audit: ${errorMessage3}`
     };
   }
 }
@@ -141344,8 +141813,8 @@ async function runPipAudit(directory) {
       clean: findings.length === 0
     };
   } catch (error93) {
-    const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
-    if (errorMessage2.includes("not found") || errorMessage2.includes("not recognized") || errorMessage2.includes("pip-audit")) {
+    const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
+    if (errorMessage3.includes("not found") || errorMessage3.includes("not recognized") || errorMessage3.includes("pip-audit")) {
       return {
         ecosystem: "pip",
         command,
@@ -141365,7 +141834,7 @@ async function runPipAudit(directory) {
       highCount: 0,
       totalCount: 0,
       clean: true,
-      note: `Error running pip-audit: ${errorMessage2}`
+      note: `Error running pip-audit: ${errorMessage3}`
     };
   }
 }
@@ -141446,8 +141915,8 @@ async function runCargoAudit(directory) {
       clean: findings.length === 0
     };
   } catch (error93) {
-    const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
-    if (errorMessage2.includes("not found") || errorMessage2.includes("not recognized") || errorMessage2.includes("cargo-audit")) {
+    const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
+    if (errorMessage3.includes("not found") || errorMessage3.includes("not recognized") || errorMessage3.includes("cargo-audit")) {
       return {
         ecosystem: "cargo",
         command,
@@ -141467,7 +141936,7 @@ async function runCargoAudit(directory) {
       highCount: 0,
       totalCount: 0,
       clean: true,
-      note: `Error running cargo audit: ${errorMessage2}`
+      note: `Error running cargo audit: ${errorMessage3}`
     };
   }
 }
@@ -141594,7 +142063,7 @@ async function runGoAudit(directory) {
       clean: findings.length === 0
     };
   } catch (error93) {
-    const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
+    const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
     return {
       ecosystem: "go",
       command,
@@ -141603,7 +142072,7 @@ async function runGoAudit(directory) {
       highCount: 0,
       totalCount: 0,
       clean: true,
-      note: `Error running govulncheck: ${errorMessage2}`
+      note: `Error running govulncheck: ${errorMessage3}`
     };
   }
 }
@@ -141701,7 +142170,7 @@ async function runDotnetAudit(directory) {
       clean: findings.length === 0
     };
   } catch (error93) {
-    const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
+    const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
     return {
       ecosystem: "dotnet",
       command,
@@ -141710,7 +142179,7 @@ async function runDotnetAudit(directory) {
       highCount: 0,
       totalCount: 0,
       clean: true,
-      note: `Error running dotnet list package: ${errorMessage2}`
+      note: `Error running dotnet list package: ${errorMessage3}`
     };
   }
 }
@@ -141837,8 +142306,8 @@ async function runBundleAudit(directory) {
       clean: findings.length === 0
     };
   } catch (error93) {
-    const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
-    const isNotInstalled = errorMessage2.includes("not recognized") || errorMessage2.includes("not found") || errorMessage2.includes("No such file") || errorMessage2.includes("ENOENT");
+    const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
+    const isNotInstalled = errorMessage3.includes("not recognized") || errorMessage3.includes("not found") || errorMessage3.includes("No such file") || errorMessage3.includes("ENOENT");
     return {
       ecosystem: "ruby",
       command,
@@ -141847,7 +142316,7 @@ async function runBundleAudit(directory) {
       highCount: 0,
       totalCount: 0,
       clean: true,
-      note: isNotInstalled ? "bundle-audit not installed. Install with: gem install bundler-audit" : `Error running bundle-audit: ${errorMessage2}`
+      note: isNotInstalled ? "bundle-audit not installed. Install with: gem install bundler-audit" : `Error running bundle-audit: ${errorMessage3}`
     };
   }
 }
@@ -141976,7 +142445,7 @@ async function runDartAudit(directory) {
       note: "dart pub outdated reports outdated packages, not security vulnerabilities"
     };
   } catch (error93) {
-    const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
+    const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
     return {
       ecosystem: "dart",
       command,
@@ -141985,7 +142454,7 @@ async function runDartAudit(directory) {
       highCount: 0,
       totalCount: 0,
       clean: true,
-      note: `Error running dart pub outdated: ${errorMessage2}`
+      note: `Error running dart pub outdated: ${errorMessage3}`
     };
   }
 }
@@ -143860,11 +144329,11 @@ async function runSemgrep(options) {
       engine: "tier_a+tier_b"
     };
   } catch (error93) {
-    const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error running Semgrep";
+    const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error running Semgrep";
     return {
       available: true,
       findings: [],
-      error: errorMessage2,
+      error: errorMessage3,
       engine: "tier_a"
     };
   }
@@ -145381,13 +145850,13 @@ var pre_check_batch = createSwarmTool({
       }, workspaceAnchor, directory);
       return JSON.stringify(result, null, 2);
     } catch (error93) {
-      const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
+      const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
       const errorResult = {
         gates_passed: false,
-        lint: { ran: false, error: errorMessage2, duration_ms: 0 },
-        secretscan: { ran: false, error: errorMessage2, duration_ms: 0 },
-        sast_scan: { ran: false, error: errorMessage2, duration_ms: 0 },
-        quality_budget: { ran: false, error: errorMessage2, duration_ms: 0 },
+        lint: { ran: false, error: errorMessage3, duration_ms: 0 },
+        secretscan: { ran: false, error: errorMessage3, duration_ms: 0 },
+        sast_scan: { ran: false, error: errorMessage3, duration_ms: 0 },
+        quality_budget: { ran: false, error: errorMessage3, duration_ms: 0 },
         total_duration_ms: 0
       };
       return JSON.stringify(errorResult, null, 2);
@@ -148008,7 +148477,7 @@ var schema_drift = createSwarmTool({
       };
       return JSON.stringify(result, null, 2);
     } catch (error93) {
-      const errorMessage2 = error93 instanceof Error ? error93.message : "Unknown error";
+      const errorMessage3 = error93 instanceof Error ? error93.message : "Unknown error";
       const errorResult = {
         specFile: "",
         specPathCount: 0,
@@ -148019,7 +148488,7 @@ var schema_drift = createSwarmTool({
         phantomCount: 0,
         consistent: false
       };
-      return JSON.stringify({ ...errorResult, error: errorMessage2 }, null, 2);
+      return JSON.stringify({ ...errorResult, error: errorMessage3 }, null, 2);
     }
   }
 });
@@ -148762,11 +149231,11 @@ ${content}
 init_zod();
 init_loader();
 import {
-  existsSync as existsSync111,
+  existsSync as existsSync112,
   mkdirSync as mkdirSync49,
   readFileSync as readFileSync89,
-  renameSync as renameSync29,
-  unlinkSync as unlinkSync26,
+  renameSync as renameSync32,
+  unlinkSync as unlinkSync29,
   writeFileSync as writeFileSync36
 } from "node:fs";
 import path194 from "node:path";
@@ -149035,10 +149504,10 @@ function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
   const tempFile = `${evidenceFile}.tmp-${Date.now()}`;
   try {
     writeFileSync36(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
-    renameSync29(tempFile, evidenceFile);
+    renameSync32(tempFile, evidenceFile);
   } finally {
-    if (existsSync111(tempFile)) {
-      unlinkSync26(tempFile);
+    if (existsSync112(tempFile)) {
+      unlinkSync29(tempFile);
     }
   }
 }