opencode-swarm 7.87.1 → 7.87.2

package/dist/cli/{index-gwzpy671.js → index-6qkwgdsg.js}

@@ -60,6 +60,7 @@ import {
   stripKnownSwarmPrefix
 } from "./index-q9h0wb04.js";
 import {
+  MAX_TRANSIENT_RETRIES,
   PlanSchema,
   RetrospectiveEvidenceSchema,
   appendLedgerEvent,
@@ -81,6 +82,7 @@ import {
   isGlobalFile,
   isProtectedPath,
   isStateUnreadable,
+  isTransientSpawnError,
   isValidEvidenceType,
   listEvidenceTaskIds,
   loadEpicSessionState,
@@ -97,9 +99,10 @@ import {
   sanitizeTaskId,
   saveEvidence,
   savePlan,
+  transientBackoff,
   validateProjectRoot,
   writeProjectedSpecSync
-} from "./index-89xjr3h4.js";
+} from "./index-8y7qetpg.js";
 import {
   _internals as _internals2,
   _internals1 as _internals3,
@@ -894,7 +897,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.87.1",
+  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",
@@ -5231,6 +5234,7 @@ function createSwarmTool(opts) {
 var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json";
 var MAX_LABEL_LENGTH = 100;
 var GIT_TIMEOUT_MS = 30000;
+var GIT_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
 var SHELL_METACHARACTERS = /[;|&$`(){}<>!'"]/;
 var SAFE_LABEL_PATTERN = /^[a-zA-Z0-9_ -]+$/;
 var CONTROL_CHAR_PATTERN = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/;
@@ -5305,20 +5309,31 @@ function writeCheckpointLog(log2, directory) {
   fs7.renameSync(tempPath, logPath);
 }
 function gitExec(args, cwd) {
-  const result = child_process.spawnSync("git", args, {
-    cwd,
-    encoding: "utf-8",
-    timeout: GIT_TIMEOUT_MS,
-    stdio: ["ignore", "pipe", "pipe"],
-    windowsHide: true
-  });
-  if (result.error) {
-    throw new Error(`git failed to start: ${result.error.code ?? "unknown"} \u2014 ${result.error.message}`);
-  }
-  if (result.status !== 0) {
+  for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
+    const result = child_process.spawnSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      maxBuffer: GIT_MAX_BUFFER_BYTES
+    });
+    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"} \u2014 ${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 {
@@ -5335,9 +5350,20 @@ function getCurrentSha(directory) {
 function isGitRepo2(directory) {
   try {
     gitExec(["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 \u2014 treating as not a git repository"
+      };
+    }
+    return {
+      isRepo: false,
+      warning: "git probe failed \u2014 directory may not be a git repository"
+    };
   }
 }
 function handleSave(label, directory) {
@@ -5480,11 +5506,12 @@ var checkpoint = createSwarmTool({
     label: exports_external.string().optional().describe("Checkpoint label (required for save, restore, delete)")
   },
   execute: async (args, 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"} \u2014 checkpoint tools require a git repository`
       }, null, 2);
     }
     let action;
@@ -5673,6 +5700,7 @@ async function handleClarifyCommand(_directory, args) {
 }
 
 // src/commands/close.ts
+import { spawnSync as spawnSync5 } from "child_process";
 import * as fsSync2 from "fs";
 import { promises as fs11 } from "fs";
 import path24 from "path";
@@ -6079,7 +6107,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);
@@ -6095,22 +6124,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 _internals13.acquirePostMortemLock(directory, planId);
+  const lock = await _internals13.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.`
       ]
     };
   }
@@ -6160,7 +6189,7 @@ async function runCuratorPostMortem(directory, options = {}) {
     if (options.llmDelegate) {
       try {
         const { CURATOR_POSTMORTEM_PROMPT: CURATOR_POSTMORTEM_PROMPT2 } = await import("./explorer-gz70sm9b.js");
-        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;
@@ -6176,17 +6205,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 (err) {
         const msg = err instanceof Error ? err.message : String(err);
         warnings.push(`LLM delegate failed, falling back to data-only report: ${msg}`);
-        reportContent = _internals13.buildDataOnlyReport(planId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
+        reportContent = _internals13.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
       }
     } else {
-      reportContent = _internals13.buildDataOnlyReport(planId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
+      reportContent = _internals13.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
     }
     try {
       const { mkdirSync: mkdirSync6 } = await import("fs");
@@ -6196,7 +6225,7 @@ ${llmOutput}`;
       const msg = err instanceof Error ? err.message : String(err);
       return {
         success: false,
-        planId,
+        planId: effectivePlanId,
         reportPath: null,
         summary: null,
         warnings: [...warnings, `Failed to write report: ${msg}`]
@@ -6206,13 +6235,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
@@ -11097,8 +11126,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 fs11.readdir(src);
   await fs11.mkdir(dest, { recursive: true });
   for (const entry of entries) {
@@ -11107,17 +11137,32 @@ async function copyDirRecursive(src, dest) {
     try {
       const stat4 = await fs11.stat(srcEntry);
       if (stat4.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 fs11.copyFile(srcEntry, destEntry);
           count++;
-        } catch {}
+        } catch (err) {
+          const errno = err?.code;
+          if (errno !== "ENOENT") {
+            failures.push(`${srcEntry}: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
       }
-    } catch {}
+    } catch (err) {
+      const errno = err?.code;
+      if (errno !== "ENOENT") {
+        failures.push(`${srcEntry}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
   }
-  return count;
+  return { copied: count, failures };
+}
+async function copyDirRecursive(src, dest) {
+  const result = await copyDirRecursiveWithFailures(src, dest);
+  return result.copied;
 }
 var ARCHIVE_ARTIFACTS = [
   "plan.json",
@@ -11436,31 +11481,145 @@ async function runFinalizeStage(ctx) {
     ctx.warnings.push(`Post-mortem failed: ${msg}`);
   }
 }
+async function copySqliteSafe(srcPath, destPath) {
+  if (!fsSync2.existsSync(srcPath)) {
+    return {
+      success: true,
+      skipped: true,
+      reason: "source does not exist (ENOENT)"
+    };
+  }
+  let checkpointVerified = false;
+  try {
+    const result = spawnSync5("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
+      cwd: path24.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 fs11.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 (err) {
+    return {
+      success: false,
+      reason: `wal_checkpoint error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    await fs11.copyFile(srcPath, destPath);
+    if (checkpointVerified) {
+      return { success: true };
+    }
+    return {
+      success: true,
+      reason: "WAL checkpoint incomplete (busy) \u2014 archive copy may be stale, original preserved"
+    };
+  } catch (err) {
+    return {
+      success: false,
+      reason: `copy failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
 async function runArchiveStage(ctx) {
   ctx.timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   ctx.archiveSuffix = Math.random().toString(36).slice(2, 8);
   ctx.archiveDir = path24.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
   try {
     await fs11.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 = path24.join(ctx.swarmDir, artifact);
       const destPath = path24.join(ctx.archiveDir, artifact);
-      try {
-        await fs11.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 fs11.copyFile(srcPath, destPath);
+          ctx.archivedFileCount++;
+          if (ACTIVE_STATE_TO_CLEAN.includes(artifact)) {
+            ctx.archivedActiveStateFiles.add(artifact);
+          }
+        } catch (err) {
+          const errno = err?.code;
+          if (errno === "ENOENT") {} else {
+            const reason = err instanceof Error ? err.message : String(err);
+            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 = path24.join(ctx.swarmDir, dirName);
       const destDir = path24.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 (err) {
+        const code = err.code;
+        if (code !== "ENOENT") {
+          ctx.warnings.push(`Failed to archive directory ${dirName} [${code ?? "unknown"}]: ${err.message}. Source preserved.`);
+        }
+      }
     }
     ctx.archiveResult = `Archived ${ctx.archivedFileCount} artifact(s) to .swarm/archive/swarm-${ctx.timestamp}-${ctx.archiveSuffix}/`;
   } catch (archiveError) {
@@ -11501,14 +11660,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 = path24.join(ctx.swarmDir, artifact);
       try {
         await fs11.unlink(filePath);
         cleanedFiles.push(artifact);
-      } catch {}
+      } catch (err) {
+        const errno = err?.code;
+        if (errno === "ENOENT") {} else {
+          const reason = err instanceof Error ? err.message : String(err);
+          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.");
@@ -11530,15 +11696,33 @@ async function runCleanStage(ctx) {
       try {
         await fs11.unlink(path24.join(ctx.swarmDir, backup));
         configBackupsRemoved++;
-      } catch {}
+      } catch (err) {
+        const errno = err?.code;
+        if (errno === "ENOENT") {} else {
+          const reason = err instanceof Error ? err.message : String(err);
+          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 fs11.unlink(path24.join(ctx.swarmDir, sibling));
-      } catch {}
+      } catch (err) {
+        const errno = err?.code;
+        if (errno === "ENOENT") {} else {
+          const reason = err instanceof Error ? err.message : String(err);
+          ctx.warnings.push(`Failed to clean ledger sibling ${sibling} [${errno ?? "unknown"}]: ${reason}`);
+        }
+      }
     }
-  } catch {}
+  } catch (err) {
+    const errno = err?.code;
+    if (errno === "ENOENT") {} else {
+      const reason = err instanceof Error ? err.message : String(err);
+      ctx.warnings.push(`Failed to read ${ctx.swarmDir} for stale-file cleanup [${errno ?? "unknown"}]: ${reason}`);
+    }
+  }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
     path24.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
@@ -11564,9 +11748,21 @@ async function runCleanStage(ctx) {
       try {
         await fs11.unlink(path24.join(ctx.swarmDir, tmp));
         tmpFilesRemoved++;
-      } catch {}
+      } catch (err) {
+        const errno = err?.code;
+        if (errno === "ENOENT") {} else {
+          const reason = err instanceof Error ? err.message : String(err);
+          ctx.warnings.push(`Failed to clean tmp file ${tmp} [${errno ?? "unknown"}]: ${reason}`);
+        }
+      }
     }
-  } catch {}
+  } catch (err) {
+    const errno = err?.code;
+    if (errno === "ENOENT") {} else {
+      const reason = err instanceof Error ? err.message : String(err);
+      ctx.warnings.push(`Failed to read ${ctx.swarmDir} for tmp-file cleanup [${errno ?? "unknown"}]: ${reason}`);
+    }
+  }
   if (tmpFilesRemoved > 0) {
     cleanedFiles.push(`${tmpFilesRemoved} .tmp.* file(s)`);
   }
@@ -11583,9 +11779,14 @@ async function runCleanStage(ctx) {
     ""
   ].join(`
 `);
+  const contextTempPath = path24.join(path24.dirname(contextPath), `${path24.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await fs11.writeFile(contextPath, contextContent, "utf-8");
+    await fs11.writeFile(contextTempPath, contextContent, "utf-8");
+    fsSync2.renameSync(contextTempPath, contextPath);
   } catch (error2) {
+    try {
+      fsSync2.unlinkSync(contextTempPath);
+    } catch {}
     const msg = error2 instanceof Error ? error2.message : String(error2);
     ctx.warnings.push(`Failed to reset context.md: ${msg}`);
     console.warn("[close-command] Failed to write context.md:", error2);
@@ -11679,15 +11880,33 @@ async function handleCloseCommand(directory, args, options = {}) {
   if (!finalizeLock.acquired) {
     return `\u274C 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 = args.includes("--force");
-  const runSkillReview = args.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 = path24.join(swarmDir, "archive");
+      try {
+        const archiveEntries = await fs11.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) => fsSync2.existsSync(path24.join(swarmDir, entry)));
+          if (!hasActiveState) {
+            return `\u2705 Already finalized \u2014 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 = args.includes("--force");
+    const runSkillReview = args.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 } = _internals19.loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
@@ -11724,6 +11943,7 @@ async function handleCloseCommand(directory, args, options = {}) {
       archivedFileCount: 0,
       archivedActiveStateFiles: new Set,
       archivedActiveStateDirs: new Set,
+      archiveFailureReasons: new Map,
       timestamp: "",
       archiveDir: "",
       archiveSuffix: "",
@@ -11786,9 +12006,14 @@ async function handleCloseCommand(directory, args, options = {}) {
       ...ctx.warnings.length > 0 ? ["## Warnings", ...ctx.warnings.map((w) => `- ${w}`), ""] : []
     ].join(`
 `);
+    const closeSummaryTempPath = path24.join(path24.dirname(closeSummaryPath), `${path24.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs11.writeFile(closeSummaryPath, summaryContent, "utf-8");
+      await fs11.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
+      fsSync2.renameSync(closeSummaryTempPath, closeSummaryPath);
     } catch (error2) {
+      try {
+        fsSync2.unlinkSync(closeSummaryTempPath);
+      } catch {}
       const msg = error2 instanceof Error ? error2.message : String(error2);
       ctx.warnings.push(`Failed to write close-summary.md: ${msg}`);
       console.warn("[close-command] Failed to write close-summary.md:", error2);
@@ -12129,7 +12354,7 @@ async function handleConfigCommand(directory, _args) {
 }
 
 // src/services/skill-consolidation.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { mkdir as mkdir8, readFile as readFile8, rename as rename4, writeFile as writeFile8 } from "fs/promises";
 import * as path26 from "path";
 
@@ -12160,7 +12385,7 @@ function consolidationStatePath(directory) {
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
-  if (!existsSync13(filePath))
+  if (!existsSync14(filePath))
     return {};
   try {
     const parsed = JSON.parse(await readFile8(filePath, "utf-8"));
@@ -13607,7 +13832,7 @@ ${USAGE5}`;
 
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
-import { existsSync as existsSync16, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
 import path31 from "path";
 import { fileURLToPath } from "url";
 
@@ -13660,11 +13885,11 @@ init_capability_probe();
 init_executor();
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { readFile as readFile10 } from "fs/promises";
 
 // src/services/version-check.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join25 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -13679,7 +13904,7 @@ function cacheFile() {
 function readVersionCache() {
   try {
     const path31 = cacheFile();
-    if (!existsSync14(path31))
+    if (!existsSync15(path31))
       return null;
     const raw = readFileSync8(path31, "utf-8");
     const parsed = JSON.parse(raw);
@@ -13720,7 +13945,7 @@ var SEVEN_DAYS_MS2 = 7 * 24 * 60 * 60 * 1000;
 var UNACTIONABLE_BACKLOG_WARN = 100;
 var INSIGHT_BACKLOG_WARN = 50;
 async function readRawLines(filePath) {
-  if (!existsSync15(filePath))
+  if (!existsSync16(filePath))
     return { entries: [], corrupt: 0 };
   const content = await readFile10(filePath, "utf-8");
   const entries = [];
@@ -13845,7 +14070,7 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync15(filePath))
+  if (!filePath || !existsSync16(filePath))
     return 0;
   try {
     const content = await readFile10(filePath, "utf-8");
@@ -14166,7 +14391,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync16(directory) || !statSync6(directory).isDirectory()) {
+    if (!existsSync17(directory) || !statSync6(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -14231,7 +14456,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path31.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync16(configPath)) {
+  if (!existsSync17(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -14286,11 +14511,11 @@ async function checkGrammarWasmFiles() {
   const thisDir = path31.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync16(path31.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync17(path31.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file of grammarFiles) {
-    if (!existsSync16(path31.join(grammarDir, file))) {
+    if (!existsSync17(path31.join(grammarDir, file))) {
       missing.push(file);
     }
   }
@@ -14309,7 +14534,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path31.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync16(manifestPath)) {
+  if (!existsSync17(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -14361,7 +14586,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path31.join(directory, ".swarm/events.jsonl");
-  if (!existsSync16(eventsPath)) {
+  if (!existsSync17(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -14402,7 +14627,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path31.join(directory, ".swarm/events.jsonl");
-  if (!existsSync16(eventsPath)) {
+  if (!existsSync17(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -14458,7 +14683,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path31.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync16(summaryPath)) {
+    if (!existsSync17(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -14660,7 +14885,7 @@ async function getDiagnoseData(directory) {
   checks.push(await checkKnowledgeHealth(directory));
   try {
     const evidenceDir = path31.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync16(evidenceDir) ? readdirSync3(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const snapshotFiles = existsSync17(evidenceDir) ? readdirSync3(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks.push({
@@ -14693,7 +14918,7 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync16(cachePath)) {
+      if (!existsSync17(cachePath)) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
@@ -15731,7 +15956,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-gg5m9z57.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-5me91eq8.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -16235,7 +16460,7 @@ function buildStatusReport(directory, sessionID, sessionFlag) {
 
 // src/commands/handoff.ts
 import crypto4 from "crypto";
-import { renameSync as renameSync8, unlinkSync as unlinkSync4 } from "fs";
+import { renameSync as renameSync9, unlinkSync as unlinkSync5 } from "fs";
 
 // src/services/handoff-service.ts
 var RTL_OVERRIDE_PATTERN = /[\u202e\u202d\u202c\u200f]/g;
@@ -16615,7 +16840,7 @@ var _internals26 = {
 };
 
 // src/session/snapshot-writer.ts
-import { closeSync as closeSync6, fsyncSync as fsyncSync2, mkdirSync as mkdirSync14, openSync as openSync6, renameSync as renameSync7 } from "fs";
+import { closeSync as closeSync6, fsyncSync as fsyncSync2, mkdirSync as mkdirSync14, openSync as openSync6, renameSync as renameSync8 } from "fs";
 import * as path36 from "path";
 var _writeInFlight = Promise.resolve();
 function serializeAgentSession(s) {
@@ -16735,7 +16960,7 @@ async function writeSnapshot(directory, state) {
         closeSync6(fd);
       }
     } catch {}
-    renameSync7(tempPath, resolvedPath);
+    renameSync8(tempPath, resolvedPath);
   } catch (error2) {
     log("[snapshot-writer] write failed", {
       error: error2 instanceof Error ? error2.message : String(error2)
@@ -16767,10 +16992,10 @@ async function handleHandoffCommand(directory, _args) {
     const tempPath = `${resolvedPath}.tmp.${crypto4.randomUUID()}`;
     await bunWrite(tempPath, markdown);
     try {
-      renameSync8(tempPath, resolvedPath);
+      renameSync9(tempPath, resolvedPath);
     } catch (renameErr) {
       try {
-        unlinkSync4(tempPath);
+        unlinkSync5(tempPath);
       } catch {}
       throw renameErr;
     }
@@ -16779,10 +17004,10 @@ async function handleHandoffCommand(directory, _args) {
     const promptTempPath = `${promptPath}.tmp.${crypto4.randomUUID()}`;
     await bunWrite(promptTempPath, continuationPrompt);
     try {
-      renameSync8(promptTempPath, promptPath);
+      renameSync9(promptTempPath, promptPath);
     } catch (renameErr) {
       try {
-        unlinkSync4(promptTempPath);
+        unlinkSync5(promptTempPath);
       } catch {}
       throw renameErr;
     }
@@ -16942,7 +17167,7 @@ async function handleHistoryCommand(directory, _args) {
   return formatHistoryMarkdown(historyData);
 }
 // src/commands/_shared/url-security.ts
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 var MAX_URL_LEN = 2048;
 var IPV4_PRIVATE = /^10\./;
 var IPV4_LOOPBACK = /^127\./;
@@ -16952,7 +17177,7 @@ var IPV4_PRIVATE_192 = /^192\.168\./;
 var IPV4_ZERO_NETWORK = /^0\./;
 var IPV6_LINK_LOCAL = /^fe80:/i;
 var IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-var _internals28 = { spawnSync: spawnSync5 };
+var _internals28 = { spawnSync: spawnSync6 };
 function sanitizeUrl(raw) {
   let urlStr = raw.trim();
   urlStr = urlStr.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
@@ -17231,7 +17456,7 @@ import { join as join30 } from "path";
 // src/hooks/knowledge-migrator.ts
 init_logger();
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync21, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync14 } from "fs";
 import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
 import * as os8 from "os";
 import * as path37 from "path";
@@ -17267,7 +17492,7 @@ async function migrateContextToKnowledge(directory, config) {
   const sentinelPath = path37.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path37.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync21(sentinelPath)) {
+  if (existsSync22(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -17276,7 +17501,7 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync21(contextPath)) {
+  if (!existsSync22(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -17368,7 +17593,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   const legacyHivePath = _internals29.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path37.join(path37.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync21(sentinelPath)) {
+  if (existsSync22(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -17377,7 +17602,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync21(legacyHivePath)) {
+  if (!existsSync22(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -17579,7 +17804,7 @@ function truncateLesson2(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path37.join(directory, "package.json");
-  if (existsSync21(packageJsonPath)) {
+  if (existsSync22(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync14(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -18032,7 +18257,7 @@ ${USAGE7}`;
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import * as path42 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -18130,7 +18355,7 @@ import * as path41 from "path";
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import {
   appendFile as appendFile3,
   mkdir as mkdir10,
@@ -19297,7 +19522,7 @@ function validateLoadedProposals(values, config) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync22(filePath))
+  if (!existsSync23(filePath))
     return [];
   const content = await readFile12(filePath, "utf-8");
   const records = [];
@@ -19374,7 +19599,7 @@ import { createRequire as createRequire2 } from "module";
 import * as path40 from "path";
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24, renameSync as renameSync10, unlinkSync as unlinkSync6 } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir11, readFile as readFile13, stat as stat5, writeFile as writeFile11 } from "fs/promises";
 import * as path39 from "path";
 var LEGACY_JSONL_MIGRATION_VERSION = 2;
@@ -19408,10 +19633,10 @@ async function backupLegacyJsonl(rootDirectory, config = {}) {
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
     const source = path39.join(storageDir, filename);
-    if (!existsSync23(source))
+    if (!existsSync24(source))
       continue;
     const backup = path39.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync23(backup)) {
+    if (existsSync24(backup)) {
       results.push({ source, backup, created: false });
       continue;
     }
@@ -19425,20 +19650,47 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
   await mkdir11(exportDir, { recursive: true });
   const memoriesPath = path39.join(exportDir, "memories.jsonl");
   const proposalsPath = path39.join(exportDir, "proposals.jsonl");
-  await writeFile11(memoriesPath, toJsonl(memories), "utf-8");
-  await writeFile11(proposalsPath, toJsonl(proposals), "utf-8");
+  const memoriesTempPath = path39.join(path39.dirname(memoriesPath), `${path39.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  try {
+    await writeFile11(memoriesTempPath, toJsonl(memories), "utf-8");
+    renameSync10(memoriesTempPath, memoriesPath);
+  } catch (err) {
+    try {
+      unlinkSync6(memoriesTempPath);
+    } catch {}
+    throw err;
+  }
+  const proposalsTempPath = path39.join(path39.dirname(proposalsPath), `${path39.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  try {
+    await writeFile11(proposalsTempPath, toJsonl(proposals), "utf-8");
+    renameSync10(proposalsTempPath, proposalsPath);
+  } catch (err) {
+    try {
+      unlinkSync6(proposalsTempPath);
+    } catch {}
+    throw err;
+  }
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config = {}) {
   const reportPath = path39.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
   await mkdir11(path39.dirname(reportPath), { recursive: true });
-  await writeFile11(reportPath, `${JSON.stringify(report, null, 2)}
+  const reportTempPath = path39.join(path39.dirname(reportPath), `${path39.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  try {
+    await writeFile11(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
+    renameSync10(reportTempPath, reportPath);
+  } catch (err) {
+    try {
+      unlinkSync6(reportTempPath);
+    } catch {}
+    throw err;
+  }
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config = {}) {
   const reportPath = path39.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
-  if (!existsSync23(reportPath))
+  if (!existsSync24(reportPath))
     return null;
   try {
     return JSON.parse(await readFile13(reportPath, "utf-8"));
@@ -19452,13 +19704,13 @@ async function getLegacyJsonlFileStatus(rootDirectory, config = {}) {
   for (const file of ["memories.jsonl", "proposals.jsonl"]) {
     const filePath = path39.join(storageDir, file);
     let sizeBytes = 0;
-    if (existsSync23(filePath)) {
+    if (existsSync24(filePath)) {
       sizeBytes = (await stat5(filePath)).size;
     }
     statuses.push({
       file,
       path: filePath,
-      exists: existsSync23(filePath),
+      exists: existsSync24(filePath),
       sizeBytes
     });
   }
@@ -19539,7 +19791,7 @@ async function readProposalJsonl(filePath, config) {
   return { records, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync23(filePath)) {
+  if (!existsSync24(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile13(filePath, "utf-8");
@@ -20929,7 +21181,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync24(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync25(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -24477,19 +24729,19 @@ function hasCompoundTestExtension(filename) {
   const lower = filename.toLowerCase();
   return COMPOUND_TEST_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-function isLanguageSpecificTestFile(basename8) {
-  const lower = basename8.toLowerCase();
+function isLanguageSpecificTestFile(basename9) {
+  const lower = basename9.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(basename8) || basename8.endsWith("Test.java") || basename8.endsWith("Tests.java") || lower.endsWith("it.java")))
+  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename9) || basename9.endsWith("Test.java") || basename9.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(basename8) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
+  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename9) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
     return true;
   if (lower.endsWith(".tests.ps1"))
     return true;
@@ -24497,23 +24749,23 @@ function isLanguageSpecificTestFile(basename8) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename8 = path48.basename(filePath);
-  return hasCompoundTestExtension(basename8) || basename8.includes(".spec.") || basename8.includes(".test.") || isLanguageSpecificTestFile(basename8) || isTestDirectoryPath(normalizedPath);
+  const basename9 = path48.basename(filePath);
+  return hasCompoundTestExtension(basename9) || basename9.includes(".spec.") || basename9.includes(".test.") || isLanguageSpecificTestFile(basename9) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
     const relativeFile = path48.relative(workingDir, absoluteFile);
-    const basename8 = path48.basename(absoluteFile);
+    const basename9 = path48.basename(absoluteFile);
     const dirname23 = path48.dirname(absoluteFile);
     const preferRelativeOutput = !path48.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
-    const nameWithoutExt = basename8.replace(/\.[^.]+$/, "");
-    const ext = path48.extname(basename8);
+    const nameWithoutExt = basename9.replace(/\.[^.]+$/, "");
+    const ext = path48.extname(basename9);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -24524,7 +24776,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
       ...languageSpecificTestNames
     ].map((candidateName) => path48.join(dirname23, candidateName));
     const testDirectoryNames = [
-      basename8,
+      basename9,
       ...genericTestNames,
       ...languageSpecificTestNames
     ];
@@ -27362,7 +27614,9 @@ async function handleResetCommand(directory, args) {
         fs25.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
       }
-    } catch {}
+    } catch (err) {
+      results.push(`- \u274C Failed to delete ${filename}: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
   try {
     resetAutomationManager();
@@ -27885,6 +28139,11 @@ function resetPrmSessionState(session, sessionId) {
 }
 
 // src/commands/reset-session.ts
+function errorMessage(err) {
+  if (err instanceof Error)
+    return err.message;
+  return String(err);
+}
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -27898,22 +28157,30 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  try {
-    const sessionDir = path52.dirname(validateSwarmPath(directory, "session/state.json"));
-    if (fs27.existsSync(sessionDir)) {
-      const files = fs27.readdirSync(sessionDir);
-      const otherFiles = files.filter((f) => f !== "state.json");
-      let deletedCount = 0;
-      for (const file of otherFiles) {
-        const filePath = path52.join(sessionDir, file);
-        if (fs27.lstatSync(filePath).isFile()) {
-          fs27.unlinkSync(filePath);
-          deletedCount++;
-        }
-      }
-      results.push(`\u2705 Cleaned ${deletedCount} additional session file(s)`);
+  const sessionDir = path52.dirname(validateSwarmPath(directory, "session/state.json"));
+  let sessionFiles = [];
+  if (fs27.existsSync(sessionDir)) {
+    try {
+      sessionFiles = fs27.readdirSync(sessionDir);
+    } catch (err) {
+      results.push(`\u274C Failed to read session directory: ${errorMessage(err)}`);
     }
-  } catch {}
+  }
+  for (const file of sessionFiles) {
+    if (file === "state.json")
+      continue;
+    const filePath = path52.join(sessionDir, file);
+    try {
+      if (!fs27.existsSync(filePath))
+        continue;
+      if (!fs27.lstatSync(filePath).isFile())
+        continue;
+      fs27.unlinkSync(filePath);
+      results.push(`\u2713 Deleted ${file}`);
+    } catch (err) {
+      results.push(`\u274C Failed to delete ${file}: ${errorMessage(err)}`);
+    }
+  }
   const sessionCount = swarmState.agentSessions.size;
   for (const [sessionId, session] of swarmState.agentSessions) {
     resetPrmSessionState(session, sessionId);
@@ -28075,6 +28342,7 @@ async function handleRollbackCommand(directory, args) {
   ]);
   const successes = [];
   const failures = [];
+  const warnings = [];
   for (const file of checkpointFiles) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
@@ -28100,30 +28368,39 @@ async function handleRollbackCommand(directory, args) {
 `);
   }
   const existingLedgerPath = path54.join(swarmDir, "plan-ledger.jsonl");
+  let ledgerDeletionFailed = false;
   if (fs28.existsSync(existingLedgerPath)) {
-    fs28.unlinkSync(existingLedgerPath);
-  }
-  try {
-    const planJsonPath = path54.join(swarmDir, "plan.json");
-    if (fs28.existsSync(planJsonPath)) {
-      const planRaw = fs28.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 {
+      fs28.unlinkSync(existingLedgerPath);
+    } catch (err) {
+      ledgerDeletionFailed = true;
+      const errMsg = err instanceof Error ? err.message : String(err);
+      warnings.push(`\u26A0\uFE0F 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 = path54.join(swarmDir, "plan.json");
+      if (fs28.existsSync(planJsonPath)) {
+        const planRaw = fs28.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 = {
@@ -28138,6 +28415,14 @@ async function handleRollbackCommand(directory, args) {
   } catch (error2) {
     console.error("Failed to write rollback event:", error2 instanceof Error ? error2.message : String(error2));
   }
+  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"}`;
 }
 
@@ -28307,6 +28592,7 @@ async function handleSddCommand(_directory, _args) {
 }
 
 // src/commands/simulate.ts
+import { renameSync as renameSync11, unlinkSync as unlinkSync11 } from "fs";
 async function handleSimulateCommand(directory, args) {
   const thresholdIndex = args.indexOf("--threshold");
   const minCommitsIndex = args.indexOf("--min-commits");
@@ -28358,7 +28644,16 @@ Ensure this is a git repository with commit history.`;
     const path55 = await import("path");
     const reportPath = path55.join(directory, ".swarm", "simulate-report.md");
     await fs29.mkdir(path55.dirname(reportPath), { recursive: true });
-    await fs29.writeFile(reportPath, report, "utf-8");
+    const reportTempPath = path55.join(path55.dirname(reportPath), `${path55.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    try {
+      await fs29.writeFile(reportTempPath, report, "utf-8");
+      renameSync11(reportTempPath, reportPath);
+    } catch (err) {
+      try {
+        unlinkSync11(reportTempPath);
+      } catch {}
+      throw err;
+    }
   } catch (err) {
     const writeErr = err instanceof Error ? err.message : String(err);
     warn(`simulate: failed to write report to ${directory}/.swarm/simulate-report.md`, writeErr);
@@ -29255,7 +29550,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-dsjyfd3g.js");
+    const { buildHelpText } = await import("./index-gjdq4na6.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -29264,7 +29559,7 @@ async function handleHelpCommand(ctx) {
     return _internals44.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals44.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-dsjyfd3g.js");
+  const { buildHelpText: fullHelp } = await import("./index-gjdq4na6.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -29397,7 +29692,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-scym5r5y.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-9fngqx80.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",