opencode-swarm 7.87.1 → 7.87.3

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

@@ -11,14 +11,16 @@ import {
   quarantineEntry,
   readKnowledgeCounterRollups,
   readKnowledgeEvents,
+  regenerateSkill,
   resolveKnowledgeEventsPath,
   resolveUnactionablePath,
   restoreEntry,
+  retireSkill,
   selectCandidateEntries,
   validateActionability,
   validateActionableFields,
   validateLesson
-} from "./index-s8bj492g.js";
+} from "./index-32axfg6h.js";
 import {
   appendKnowledge,
   appendRejectedLesson,
@@ -60,6 +62,7 @@ import {
   stripKnownSwarmPrefix
 } from "./index-q9h0wb04.js";
 import {
+  MAX_TRANSIENT_RETRIES,
   PlanSchema,
   RetrospectiveEvidenceSchema,
   appendLedgerEvent,
@@ -81,6 +84,7 @@ import {
   isGlobalFile,
   isProtectedPath,
   isStateUnreadable,
+  isTransientSpawnError,
   isValidEvidenceType,
   listEvidenceTaskIds,
   loadEpicSessionState,
@@ -97,9 +101,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 +899,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.87.1",
+  version: "7.87.3",
   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 +5236,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 +5311,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 +5352,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 +5508,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 +5702,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 +6109,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 +6126,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 +6191,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 +6207,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 +6227,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 +6237,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
@@ -9900,6 +9931,9 @@ ${userInput}` : userInput;
   };
 }
 
+// src/services/skill-improver.ts
+init_logger();
+
 // src/services/trajectory-cluster.ts
 import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
 import * as path22 from "path";
@@ -10328,7 +10362,14 @@ async function gatherInventory(directory) {
       continue;
     }
     const fm = parseDraftFrontmatter(content);
-    if (!fm)
+    if (!fm) {
+      staleActiveSkills.push({
+        slug: skill.slug,
+        reasons: ["unparseable_frontmatter"]
+      });
+      continue;
+    }
+    if (fm.skillOrigin === "shim")
       continue;
     metadataReadable += 1;
     const reasons = [];
@@ -10476,6 +10517,59 @@ function buildLLMProposalFrame(args) {
   return lines.join(`
 `);
 }
+async function reconcileStaleActiveSkills(directory, options = {}) {
+  const result = {
+    regenerated: [],
+    retired: [],
+    skipped: [],
+    checked: 0
+  };
+  let skills;
+  try {
+    skills = await listSkills(directory);
+  } catch {
+    return result;
+  }
+  for (const skill of skills.active) {
+    let content;
+    try {
+      content = await readFile7(skill.path, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = parseDraftFrontmatter(content);
+    if (fm?.skillOrigin === "shim") {
+      result.skipped.push(skill.slug);
+      continue;
+    }
+    const stale = !fm || fm.sourceKnowledgeIds.length === 0 || !fm.generatedAt;
+    if (!stale)
+      continue;
+    result.checked += 1;
+    if (options.dryRun) {
+      result.retired.push(skill.slug);
+      continue;
+    }
+    try {
+      const regen = await _internals18.regenerateSkill(directory, skill.slug, {
+        evaluate: false
+      });
+      if (regen.regenerated) {
+        result.regenerated.push(skill.slug);
+      } else if (regen.retired) {
+        result.retired.push(skill.slug);
+      } else {
+        const retire = await retireSkill(directory, skill.slug, "stale_no_source_knowledge");
+        if (retire.retired)
+          result.retired.push(skill.slug);
+      }
+    } catch (err) {
+      warn(`[skill-improver] reconcileStaleActiveSkills: failed to reconcile '${skill.slug}': ${err instanceof Error ? err.message : String(err)}`);
+      result.skipped.push(skill.slug);
+    }
+  }
+  return result;
+}
 async function runSkillImprover(req) {
   const cfg = req.config;
   const now = req.now ?? new Date;
@@ -10682,6 +10776,7 @@ async function runSkillImprover(req) {
     motifs: successMotifResult.motifs,
     proposalsWritten: successMotifResult.proposalsWritten.length
   };
+  const staleSkillReconciliation = await reconcileStaleActiveSkills(req.directory, { dryRun: writeMode !== "draft_skills" });
   let autoApply;
   if (req.allowAutoApply !== false && delegate && req.sessionId && hasActiveFullAuto(req.sessionId)) {
     try {
@@ -10702,9 +10797,20 @@ async function runSkillImprover(req) {
     unactionableHardening,
     macroMotifs,
     successMotifs,
+    staleSkillReconciliation,
     autoApply
   };
 }
+var _internals18 = {
+  runSkillImprover,
+  buildDeterministicProposal,
+  buildLLMProposalFrame,
+  buildSystemPrompt,
+  buildUserPrompt,
+  gatherInventory,
+  reconcileStaleActiveSkills,
+  regenerateSkill
+};
 
 // src/tools/write-retro.ts
 async function executeWriteRetro(args, directory) {
@@ -11048,13 +11154,13 @@ var write_retro = createSwarmTool({
         task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
         metadata: args.metadata
       };
-      return await _internals18.executeWriteRetro(writeRetroArgs, directory);
+      return await _internals19.executeWriteRetro(writeRetroArgs, directory);
     } catch {
       return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
     }
   }
 });
-var _internals18 = {
+var _internals19 = {
   executeWriteRetro,
   write_retro
 };
@@ -11097,8 +11203,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 +11214,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",
@@ -11309,8 +11431,8 @@ async function runFinalizeStage(ctx) {
   ];
   ctx.curationSucceeded = false;
   try {
-    ctx.curationResult = await _internals19.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
-      llmDelegate: _internals19.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
+    ctx.curationResult = await _internals20.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
+      llmDelegate: _internals20.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
       enrichmentQuota: {
         maxCalls: ctx.config.enrichment.max_calls_per_day,
         window: ctx.config.enrichment.quota_window
@@ -11329,7 +11451,7 @@ async function runFinalizeStage(ctx) {
     if (ctx.config.hive_enabled === false) {} else {
       try {
         const entries = await readKnowledge(resolveSwarmKnowledgePath(ctx.directory));
-        const result = await _internals19.checkHivePromotions(entries, ctx.config);
+        const result = await _internals20.checkHivePromotions(entries, ctx.config);
         ctx.hivePromoted = result.new_promotions;
       } catch (hiveErr) {
         const msg = hiveErr instanceof Error ? hiveErr.message : String(hiveErr);
@@ -11350,7 +11472,7 @@ async function runFinalizeStage(ctx) {
   ctx.knowledgeSkillHint = ctx.sessionKnowledgeCreated > 0 ? `${ctx.sessionKnowledgeCreated} knowledge entries created this session. Consider running skill_improve or skill_generate to compile mature entries into skills.` : "";
   if (ctx.runSkillReview) {
     try {
-      const { config: loadedConfig } = _internals19.loadPluginConfigWithMeta(ctx.directory);
+      const { config: loadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
       const skillImproverConfig = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
       const skillReviewResult = await runAbortableSkillReview({
         directory: ctx.directory,
@@ -11401,7 +11523,7 @@ async function runFinalizeStage(ctx) {
     }
     if (!ctx.planAlreadyDone || ctx.guaranteeResult.closedPhaseIds.length > 0 || ctx.guaranteeResult.closedTaskIds.length > 0) {
       try {
-        await _internals19.closePlanTerminalState(ctx.directory, ctx.planData, {
+        await _internals20.closePlanTerminalState(ctx.directory, ctx.planData, {
           closedPhaseIds: ctx.guaranteeResult.closedPhaseIds,
           closedTaskIds: ctx.guaranteeResult.closedTaskIds,
           originalStatuses: ctx.originalStatuses
@@ -11418,11 +11540,11 @@ async function runFinalizeStage(ctx) {
   }
   try {
     const { CuratorConfigSchema: CCS } = await import("./schema-84146tvk.js");
-    const { config: pmLoadedConfig } = _internals19.loadPluginConfigWithMeta(ctx.directory);
+    const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
-      const pmResult = await _internals19.runCuratorPostMortem(ctx.directory, {
-        llmDelegate: _internals19.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID)
+      const pmResult = await _internals20.runCuratorPostMortem(ctx.directory, {
+        llmDelegate: _internals20.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID)
       });
       if (pmResult.success && pmResult.summary) {
         ctx.postMortemSummary = pmResult.summary;
@@ -11436,31 +11558,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) {
@@ -11478,7 +11714,7 @@ async function runArchiveEvidenceRetention(ctx) {
   let maxAgeDays = 30;
   let maxBundles = 10;
   try {
-    const { config: evidenceLoadedConfig } = _internals19.loadPluginConfigWithMeta(ctx.directory);
+    const { config: evidenceLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const evidenceCfg = evidenceLoadedConfig.evidence ?? {};
     if (typeof evidenceCfg.max_age_days === "number") {
       maxAgeDays = evidenceCfg.max_age_days;
@@ -11488,7 +11724,7 @@ async function runArchiveEvidenceRetention(ctx) {
     }
   } catch {}
   try {
-    await _internals19.archiveEvidence(ctx.directory, maxAgeDays, maxBundles);
+    await _internals20.archiveEvidence(ctx.directory, maxAgeDays, maxBundles);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     ctx.warnings.push(`Evidence retention archive failed: ${msg}`);
@@ -11501,14 +11737,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 +11773,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 +11825,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 +11856,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);
@@ -11601,9 +11879,9 @@ async function runAlignStage(ctx) {
   const pruneBranches = ctx.args.includes("--prune-branches");
   let gitAlignResult = "";
   const prunedBranches = [];
-  const gitStatus = _internals19.getGitRepositoryStatus(ctx.directory);
+  const gitStatus = _internals20.getGitRepositoryStatus(ctx.directory);
   if (gitStatus.isRepo) {
-    const aggressiveResult = await _internals19.resetToMainAfterMerge(ctx.directory, {
+    const aggressiveResult = await _internals20.resetToMainAfterMerge(ctx.directory, {
       pruneBranches
     });
     if (aggressiveResult.success) {
@@ -11615,7 +11893,7 @@ async function runAlignStage(ctx) {
         ctx.warnings.push("Uncommitted changes were discarded during git alignment");
       }
     } else {
-      const alignResult = await _internals19.resetToRemoteBranch(ctx.directory, {
+      const alignResult = await _internals20.resetToRemoteBranch(ctx.directory, {
         pruneBranches
       });
       gitAlignResult = alignResult.message;
@@ -11675,20 +11953,38 @@ async function handleCloseCommand(directory, args, options = {}) {
   let finalizeLock = {
     acquired: false
   };
-  finalizeLock = await _internals19.acquireFinalizeLock(directory);
+  finalizeLock = await _internals20.acquireFinalizeLock(directory);
   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 {
-    const { config: loadedConfig } = _internals19.loadPluginConfigWithMeta(directory);
+    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 } = _internals20.loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
       directory,
@@ -11724,6 +12020,7 @@ async function handleCloseCommand(directory, args, options = {}) {
       archivedFileCount: 0,
       archivedActiveStateFiles: new Set,
       archivedActiveStateDirs: new Set,
+      archiveFailureReasons: new Map,
       timestamp: "",
       archiveDir: "",
       archiveSuffix: "",
@@ -11786,14 +12083,19 @@ 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);
     }
-    _internals19.resetSwarmStatePreservingSingletons();
+    _internals20.resetSwarmStatePreservingSingletons();
     const retroWarnings = ctx.warnings.filter((w) => w.includes("Retrospective write") || w.includes("retrospective write") || w.includes("Session retrospective"));
     const otherWarnings = ctx.warnings.filter((w) => !w.includes("Retrospective write") && !w.includes("retrospective write") && !w.includes("Session retrospective"));
     let warningMsg = "";
@@ -11848,7 +12150,7 @@ async function acquireFinalizeLock(directory) {
   }
   return { acquired: false };
 }
-var _internals19 = {
+var _internals20 = {
   ACTIVE_STATE_DIRS_TO_CLEAN,
   countSessionKnowledgeEntries,
   CLOSE_SKILL_REVIEW_TIMEOUT_MS,
@@ -12129,7 +12431,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 +12462,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"));
@@ -12636,9 +12938,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals20.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals20.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
-  const staticEdges = await _internals20.getStaticEdges(directory);
+  const commitMap = await _internals21.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals21.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
+  const staticEdges = await _internals21.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -12754,11 +13056,11 @@ var co_change_analyzer = createSwarmTool({
       npmiThreshold,
       maxCommitsToAnalyze
     };
-    const pairs = await _internals20.detectDarkMatter(directory, options);
-    return _internals20.formatDarkMatterOutput(pairs);
+    const pairs = await _internals21.detectDarkMatter(directory, options);
+    return _internals21.formatDarkMatterOutput(pairs);
   }
 });
-var _internals20 = {
+var _internals21 = {
   parseGitLog,
   buildCoChangeMatrix,
   getStaticEdges,
@@ -12775,7 +13077,7 @@ var DEFAULT_MAX_COMMITS = 500;
 var cache = new Map;
 async function readGitHead(directory) {
   try {
-    const { stdout } = await _internals21.execFile("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await _internals22.execFile("git", ["rev-parse", "HEAD"], {
       cwd: directory,
       timeout: GIT_HEAD_TIMEOUT_MS
     });
@@ -12801,9 +13103,9 @@ async function getCoChangeData(directory, options) {
   let entries;
   let commitsObserved;
   try {
-    const commitMap = await _internals21.parseGitLog(directory, maxCommits);
+    const commitMap = await _internals22.parseGitLog(directory, maxCommits);
     commitsObserved = commitMap.size;
-    const matrix = _internals21.buildCoChangeMatrix(commitMap);
+    const matrix = _internals22.buildCoChangeMatrix(commitMap);
     entries = Array.from(matrix.values());
   } catch {
     return { pairs: [], commitsObserved: 0 };
@@ -12827,10 +13129,10 @@ async function getCoChangePairs(directory, options) {
   const data = await getCoChangeData(directory, options);
   return data.pairs;
 }
-var _internals21 = {
+var _internals22 = {
   execFile: execFileAsync,
-  parseGitLog: _internals20.parseGitLog,
-  buildCoChangeMatrix: _internals20.buildCoChangeMatrix
+  parseGitLog: _internals21.parseGitLog,
+  buildCoChangeMatrix: _internals21.buildCoChangeMatrix
 };
 
 // src/turbo/epic/cochange-conflict.ts
@@ -13112,7 +13414,7 @@ async function handleCouplingCommand(directory, args) {
 
 Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>] [--format markdown|json] [--persist]`;
   }
-  const plan = await _internals22.loadPlanJsonOnly(directory);
+  const plan = await _internals23.loadPlanJsonOnly(directory);
   if (plan === null) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` to create one before measuring coupling.";
   }
@@ -13136,7 +13438,7 @@ Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>
     const scope = scopeFiles ?? task.files_touched ?? [];
     return { id: task.id, scope };
   });
-  const cochangePairs = await _internals22.getCoChangePairs(directory);
+  const cochangePairs = await _internals23.getCoChangePairs(directory);
   const report = computeCouplingReport(tasks, cochangePairs, {
     npmi: parsed.threshold,
     minCoChanges: parsed.minCoChanges
@@ -13175,7 +13477,7 @@ _Warning: failed to persist report (${persistStatus.error})._`;
   }
   return `${formatCouplingReportMarkdown(report)}${persistTrailer}`;
 }
-var _internals22 = {
+var _internals23 = {
   loadPlanJsonOnly,
   getCoChangePairs
 };
@@ -13229,7 +13531,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals20.detectDarkMatter(directory, options);
+    pairs = await _internals21.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -13607,7 +13909,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 +13962,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 +13981,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 +14022,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 +14147,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");
@@ -13917,7 +14219,7 @@ async function checkKnowledgeHealth(directory) {
 // src/services/diagnose-service.ts
 var { version: version2 } = package_default;
 var sandboxCapabilityProbe = new SandboxCapabilityProbe;
-var _internals23 = {
+var _internals24 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
   getSandboxExecutor: getExecutor
 };
@@ -14166,7 +14468,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 +14533,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 +14588,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 +14611,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 +14663,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 +14704,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 +14760,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",
@@ -14501,9 +14803,9 @@ async function checkCurator(directory) {
 }
 async function getSandboxStatus() {
   try {
-    const capability = await _internals23.detectSandboxCapability();
+    const capability = await _internals24.detectSandboxCapability();
     const mechanism = capability.mechanism ?? "none";
-    const executor = await _internals23.getSandboxExecutor();
+    const executor = await _internals24.getSandboxExecutor();
     const hasExecutor = executor !== null;
     if (hasExecutor) {
       return {
@@ -14660,7 +14962,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 +14995,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;
       }
@@ -15239,7 +15541,7 @@ function readPromotionEvidence(directory) {
 }
 
 // src/commands/epic.ts
-var _internals24 = {
+var _internals25 = {
   loadPluginConfigWithMeta,
   loadPlanJsonOnly,
   getCoChangeData,
@@ -15261,7 +15563,7 @@ async function handleEpicCommand(directory, args, sessionID) {
   if (!sessionID || sessionID.trim() === "") {
     return "Error: No active session context. Epic Mode requires an active session. Use /swarm epic from within an OpenCode session.";
   }
-  const session = _internals24.ensureAgentSession(sessionID, undefined, directory);
+  const session = _internals25.ensureAgentSession(sessionID, undefined, directory);
   const arg0 = args[0]?.toLowerCase();
   switch (arg0) {
     case "status":
@@ -15288,7 +15590,7 @@ Usage:
 }
 function enableAndAck(directory, sessionID, session) {
   try {
-    _internals24.enableEpicMode(directory, sessionID);
+    _internals25.enableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error enabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -15304,7 +15606,7 @@ function enableAndAck(directory, sessionID, session) {
 }
 function disableAndAck(directory, sessionID, session) {
   try {
-    _internals24.disableEpicMode(directory, sessionID);
+    _internals25.disableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error disabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -15313,12 +15615,12 @@ function disableAndAck(directory, sessionID, session) {
 }
 function renderStatus(directory, sessionID) {
   const lines = ["## Epic Mode \u2014 Status", ""];
-  if (_internals24.isStateUnreadable(directory)) {
+  if (_internals25.isStateUnreadable(directory)) {
     lines.push("**Epic Mode state is unreadable** (`.swarm/epic-state.json` is corrupt or has an unexpected shape). Status cannot be reported until the file is repaired or removed. The fail-closed marker means `epic_decide_phase` will refuse to compute a verdict in this state.");
     return lines.join(`
 `);
   }
-  const state = _internals24.loadEpicSessionState(directory, sessionID);
+  const state = _internals25.loadEpicSessionState(directory, sessionID);
   if (!state) {
     lines.push("Epic Mode has not been toggled for this session.");
     return lines.join(`
@@ -15370,7 +15672,7 @@ function formatGreenfieldDetail(input) {
 function renderLast(directory) {
   let records;
   try {
-    records = _internals24.readPromotionEvidence(directory);
+    records = _internals25.readPromotionEvidence(directory);
   } catch (err) {
     return `Error reading epic-promotions.jsonl: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -15425,7 +15727,7 @@ function renderLast(directory) {
 `);
 }
 function renderCalibration(directory) {
-  if (_internals24.isCalibrationStateUnreadable(directory)) {
+  if (_internals25.isCalibrationStateUnreadable(directory)) {
     return [
       "## Epic Mode \u2014 Calibration",
       "",
@@ -15437,11 +15739,11 @@ function renderCalibration(directory) {
   }
   let state;
   try {
-    state = _internals24.loadCalibrationState(directory);
+    state = _internals25.loadCalibrationState(directory);
   } catch (err) {
     return `Error reading calibration state: ${err instanceof Error ? err.message : String(err)}`;
   }
-  const { config } = _internals24.loadPluginConfigWithMeta(directory);
+  const { config } = _internals25.loadPluginConfigWithMeta(directory);
   const staticThreshold = config.turbo?.epic?.mode?.activation_threshold ?? 0.3;
   const calibrationCfg = config.turbo?.epic?.calibration;
   const loosenWindow = calibrationCfg?.loosen_window ?? 10;
@@ -15489,7 +15791,7 @@ function renderCalibration(directory) {
   lines.push("");
   let recentDivergent = [];
   try {
-    const all = _internals24.readDivergenceHistory(directory, { limit: 50 });
+    const all = _internals25.readDivergenceHistory(directory, { limit: 50 });
     recentDivergent = all.filter((r) => !r.isClean).slice(-5);
   } catch {}
   lines.push("### Recent divergent tasks (tightened the threshold)");
@@ -15506,11 +15808,11 @@ function renderCalibration(directory) {
 `);
 }
 async function renderDecide(directory) {
-  const plan = await _internals24.loadPlanJsonOnly(directory);
+  const plan = await _internals25.loadPlanJsonOnly(directory);
   if (!plan) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` first.";
   }
-  const { config } = _internals24.loadPluginConfigWithMeta(directory);
+  const { config } = _internals25.loadPluginConfigWithMeta(directory);
   const modeCfg = config.turbo?.epic?.mode;
   const cochangeCfg = config.turbo?.epic?.cochange;
   const activationThreshold = modeCfg?.activation_threshold ?? 0.3;
@@ -15520,20 +15822,20 @@ async function renderDecide(directory) {
   const tasks = [];
   for (const phase of plan.phases) {
     for (const task of phase.tasks) {
-      const scopeFiles = _internals24.readTaskScopes(directory, task.id);
+      const scopeFiles = _internals25.readTaskScopes(directory, task.id);
       const scope = scopeFiles ?? task.files_touched ?? [];
       tasks.push({ id: task.id, scope });
     }
   }
-  const { pairs, commitsObserved } = await _internals24.getCoChangeData(directory);
+  const { pairs, commitsObserved } = await _internals25.getCoChangeData(directory);
   const isGitProject = (() => {
     try {
-      return _internals24.isGitRepo(directory);
+      return _internals25.isGitRepo(directory);
     } catch {
       return false;
     }
   })();
-  const verdict = _internals24.decideEpicActivation(tasks, pairs, commitsObserved, {
+  const verdict = _internals25.decideEpicActivation(tasks, pairs, commitsObserved, {
     activationThreshold,
     minCommitsForSignal,
     cochangeNpmiThreshold,
@@ -15577,7 +15879,7 @@ function formatVerdict(verdict) {
 }
 
 // src/services/evidence-service.ts
-var _internals25 = {
+var _internals26 = {
   loadEvidence,
   listEvidenceTaskIds
 };
@@ -15622,7 +15924,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals25.loadEvidence(directory, taskId);
+  const result = await _internals26.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -15645,13 +15947,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals25.listEvidenceTaskIds(directory);
+  const taskIds = await _internals26.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals25.loadEvidence(directory, taskId);
+    const result = await _internals26.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -15731,7 +16033,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 +16537,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;
@@ -16273,7 +16575,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals26.validatePlanPhases(plan)) {
+  if (!_internals27.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -16415,9 +16717,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals26.parseSessionState(sessionContent);
+  const sessionState = _internals27.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals26.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals27.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -16436,8 +16738,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals26.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals26.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals27.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals27.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -16601,7 +16903,7 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var _internals26 = {
+var _internals27 = {
   getHandoffData,
   formatHandoffMarkdown,
   formatContinuationPrompt,
@@ -16615,7 +16917,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 +17037,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)
@@ -16744,15 +17046,15 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals27.writeSnapshot(directory, swarmState), () => _internals27.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals28.writeSnapshot(directory, swarmState), () => _internals28.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals27.writeSnapshot(directory, swarmState), () => _internals27.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals28.writeSnapshot(directory, swarmState), () => _internals28.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _internals27 = {
+var _internals28 = {
   writeSnapshot,
   createSnapshotWriterHook,
   flushPendingSnapshot
@@ -16767,10 +17069,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 +17081,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 +17244,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 +17254,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 _internals29 = { spawnSync: spawnSync6 };
 function sanitizeUrl(raw) {
   let urlStr = raw.trim();
   urlStr = urlStr.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
@@ -17062,7 +17364,7 @@ function validateAndSanitizeGithubUrl(rawUrl, resource) {
 }
 function detectGitRemote(cwd) {
   try {
-    const result = _internals28.spawnSync("git", ["remote", "get-url", "origin"], {
+    const result = _internals29.spawnSync("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 5000,
@@ -17231,7 +17533,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";
@@ -17249,7 +17551,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
     skippedReason: "no-context-file"
   };
 }
-var _internals29 = {
+var _internals30 = {
   appendKnowledge,
   migrateContextToKnowledge,
   migrateKnowledgeToExternal,
@@ -17267,7 +17569,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 +17578,7 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync21(contextPath)) {
+  if (!existsSync22(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -17295,9 +17597,9 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals29.parseContextMd(contextContent);
+  const rawEntries = _internals30.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals29.writeSentinel(sentinelPath, 0, 0);
+    await _internals30.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -17308,10 +17610,10 @@ async function migrateContextToKnowledge(directory, config) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals29.inferProjectName(directory);
+  const projectName = _internals30.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals29.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals30.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -17331,8 +17633,8 @@ async function migrateContextToKnowledge(directory, config) {
     const entry = {
       id: randomUUID4(),
       tier: "swarm",
-      lesson: _internals29.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals29.inferCategoryFromText(raw.text),
+      lesson: _internals30.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals30.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -17355,7 +17657,7 @@ async function migrateContextToKnowledge(directory, config) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals29.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals30.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -17365,10 +17667,10 @@ async function migrateContextToKnowledge(directory, config) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config) {
-  const legacyHivePath = _internals29.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals30.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 +17679,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync21(legacyHivePath)) {
+  if (!existsSync22(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -17388,7 +17690,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals29.writeSentinel(sentinelPath, 0, 0);
+    await _internals30.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -17436,7 +17738,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals29.truncateLesson(lesson),
+        lesson: _internals30.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -17455,7 +17757,7 @@ async function migrateHiveKnowledgeLegacy(config) {
         encounter_score: 1
       };
       try {
-        await _internals29.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals30.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -17471,7 +17773,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       dropped++;
     }
   }
-  await _internals29.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals30.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -17482,7 +17784,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals29.splitIntoSections(content);
+  const sections = _internals30.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -17498,7 +17800,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals29.extractBullets(section.body);
+    const bullets = _internals30.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -17507,9 +17809,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals29.truncateLesson(bullet),
+        text: _internals30.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals29.inferCategoryFromText(bullet)
+        categoryHint: _internals30.inferCategoryFromText(bullet)
       });
     }
   }
@@ -17579,7 +17881,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") {
@@ -17856,7 +18158,7 @@ function timeoutMessage(timeoutMs) {
 async function computeWithTimeout(directory, currentPhase, timeoutMs) {
   const controller = new AbortController;
   let timeout;
-  const metricsPromise = _internals30.computeLearningMetrics(directory, {
+  const metricsPromise = _internals31.computeLearningMetrics(directory, {
     currentPhase,
     signal: controller.signal
   });
@@ -17913,7 +18215,7 @@ ${JSON.stringify({
     return `Error computing learning metrics: ${message}. Run /swarm diagnose to check .swarm/ health.`;
   }
 }
-var _internals30 = {
+var _internals31 = {
   computeLearningMetrics
 };
 
@@ -18032,7 +18334,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 +18432,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 +19599,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 +19676,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 +19710,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 +19727,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 +19781,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 +19868,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 +21258,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"
@@ -21349,15 +21678,15 @@ function truncate(value, maxLength) {
 }
 
 // src/services/plan-service.ts
-var _internals31 = {
+var _internals32 = {
   loadPlanJsonOnly,
   derivePlanMarkdown,
   readSwarmFileAsync
 };
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals31.loadPlanJsonOnly(directory);
+  const plan = await _internals32.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals31.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals32.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -21400,7 +21729,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals31.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals32.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -21497,7 +21826,7 @@ async function handlePlanCommand(directory, args) {
   return formatPlanMarkdown(planData);
 }
 // src/commands/post-mortem.ts
-var _internals32 = {
+var _internals33 = {
   createCuratorLLMDelegate,
   runCuratorPostMortem
 };
@@ -21509,10 +21838,10 @@ async function handlePostMortemCommand(directory, args, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals32.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals33.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals32.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals33.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -21667,12 +21996,12 @@ function formatRelativeTime(epochMs) {
   const diffDays = Math.floor(diffHours / 24);
   return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
 }
-var _internals33 = {
+var _internals34 = {
   formatRelativeTime,
   listActive
 };
 async function handlePrMonitorStatusCommand(directory, _args, sessionID) {
-  const allActive = await _internals33.listActive(directory);
+  const allActive = await _internals34.listActive(directory);
   const sessionSubs = allActive.filter((record) => record.sessionID === sessionID);
   if (sessionSubs.length === 0) {
     return "No active PR subscriptions for this session.";
@@ -21797,7 +22126,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const config = _internals34.loadPluginConfig(directory);
+    const config = _internals35.loadPluginConfig(directory);
     const prMonitorConfig = config.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -21807,7 +22136,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals34.subscribe(directory, {
+    await _internals35.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -21831,7 +22160,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals34 = {
+var _internals35 = {
   loadPluginConfig,
   subscribe
 };
@@ -21854,9 +22183,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals35.parsePrRef(refToken, directory);
+  const prInfo = _internals36.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals35.looksLikePrRef(refToken)) {
+    if (_internals36.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -21877,8 +22206,8 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const correlationId = _internals35.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals35.unsubscribe(directory, correlationId);
+    const correlationId = _internals36.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals36.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -21905,7 +22234,7 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals35 = {
+var _internals36 = {
   unsubscribe,
   buildCorrelationId,
   parsePrRef,
@@ -22339,15 +22668,15 @@ var lint = createSwarmTool({
     }
     const { mode } = args;
     const cwd = directory;
-    const linter = await _internals36.detectAvailableLinter(directory);
+    const linter = await _internals37.detectAvailableLinter(directory);
     if (linter) {
-      const result = await _internals36.runLint(linter, mode, directory);
+      const result = await _internals37.runLint(linter, mode, directory);
       return JSON.stringify(result, null, 2);
     }
-    const additionalLinter = _internals36.detectAdditionalLinter(cwd);
+    const additionalLinter = _internals37.detectAdditionalLinter(cwd);
     if (additionalLinter) {
       warn(`[lint] Using ${additionalLinter} linter for this project`);
-      const result = await _internals36.runAdditionalLint(additionalLinter, mode, cwd);
+      const result = await _internals37.runAdditionalLint(additionalLinter, mode, cwd);
       return JSON.stringify(result, null, 2);
     }
     const errorResult = {
@@ -22361,7 +22690,7 @@ For Rust: rustup component add clippy`
     return JSON.stringify(errorResult, null, 2);
   }
 });
-var _internals36 = {
+var _internals37 = {
   detectAvailableLinter,
   runLint,
   detectAdditionalLinter,
@@ -23049,7 +23378,7 @@ var secretscan = createSwarmTool({
 });
 async function runSecretscan(directory) {
   try {
-    const result = await _internals37.secretscan.execute({ directory }, {});
+    const result = await _internals38.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -23064,7 +23393,7 @@ async function runSecretscan(directory) {
     return errorResult;
   }
 }
-var _internals37 = {
+var _internals38 = {
   secretscan,
   runSecretscan
 };
@@ -23337,7 +23666,7 @@ async function buildImpactMapInternal(cwd) {
   }
   return impactMap;
 }
-var _internals38 = {
+var _internals39 = {
   validateProjectRoot,
   normalizePath: normalizePath2,
   isCacheStale,
@@ -23352,8 +23681,8 @@ var _internals38 = {
   _clearGoModuleCache
 };
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals38.buildImpactMapInternal(cwd);
-  await _internals38.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals39.buildImpactMapInternal(cwd);
+  await _internals39.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
@@ -23367,7 +23696,7 @@ async function loadImpactMap(cwd, options) {
         const hasValidValues = Object.values(map).every((v) => Array.isArray(v) && v.every((item) => typeof item === "string"));
         if (hasValidValues) {
           const generatedAt = new Date(data.generatedAt).getTime();
-          if (!_internals38.isCacheStale(map, generatedAt)) {
+          if (!_internals39.isCacheStale(map, generatedAt)) {
             return map;
           }
           if (options?.skipRebuild) {
@@ -23387,13 +23716,13 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals38.buildImpactMap(cwd);
+  return _internals39.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
   if (!path45.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals38.validateProjectRoot(cwd);
+  _internals39.validateProjectRoot(cwd);
   const cacheDir2 = path45.join(cwd, ".swarm", "cache");
   const cachePath = path45.join(cacheDir2, "impact-map.json");
   if (!fs20.existsSync(cacheDir2)) {
@@ -23417,7 +23746,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals38.loadImpactMap(cwd);
+  const impactMap = await _internals39.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -23882,7 +24211,7 @@ function batchAppendTestRuns(records, workingDir) {
   }
   const historyPath = getHistoryPath(workingDir);
   const historyDir = path46.dirname(historyPath);
-  _internals39.validateProjectRoot(workingDir);
+  _internals40.validateProjectRoot(workingDir);
   if (!fs21.existsSync(historyDir)) {
     fs21.mkdirSync(historyDir, { recursive: true });
   }
@@ -24005,7 +24334,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var _internals39 = {
+var _internals40 = {
   validateProjectRoot
 };
 
@@ -24477,19 +24806,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 +24826,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 +24853,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
       ...languageSpecificTestNames
     ].map((candidateName) => path48.join(dirname23, candidateName));
     const testDirectoryNames = [
-      basename8,
+      basename9,
       ...genericTestNames,
       ...languageSpecificTestNames
     ];
@@ -25918,9 +26247,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals40.getPackageVersion(dir);
-    const changelogVersion = _internals40.getChangelogVersion(dir);
-    const versionFileVersion = _internals40.getVersionFileVersion(dir);
+    const packageVersion = _internals41.getPackageVersion(dir);
+    const changelogVersion = _internals41.getChangelogVersion(dir);
+    const versionFileVersion = _internals41.getVersionFileVersion(dir);
     const versions = [];
     if (packageVersion)
       versions.push(`package.json: ${packageVersion}`);
@@ -26284,7 +26613,7 @@ async function runPreflight(dir, phase, config) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals40.validateDirectoryPath(dir);
+    validatedDir = _internals41.validateDirectoryPath(dir);
   } catch (error2) {
     return {
       id: reportId,
@@ -26304,7 +26633,7 @@ async function runPreflight(dir, phase, config) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals40.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals41.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error2) {
     return {
       id: reportId,
@@ -26345,12 +26674,12 @@ async function runPreflight(dir, phase, config) {
   });
   const checks = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals40.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals41.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals40.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals41.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -26362,7 +26691,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals40.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals41.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -26374,7 +26703,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals40.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals41.runEvidenceCheck(validatedDir);
     checks.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -26385,12 +26714,12 @@ async function runPreflight(dir, phase, config) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals40.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals41.runRequirementCoverageCheck(validatedDir, phase);
   checks.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals40.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals41.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -26453,10 +26782,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals40.runPreflight(directory, phase);
-  return _internals40.formatPreflightMarkdown(report);
+  const report = await _internals41.runPreflight(directory, phase);
+  return _internals41.formatPreflightMarkdown(report);
 }
-var _internals40 = {
+var _internals41 = {
   runPreflight,
   formatPreflightMarkdown,
   handlePreflightCommand,
@@ -27362,7 +27691,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();
@@ -27857,7 +28188,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
 }
 
 // src/prm/index.ts
-var _internals41 = {
+var _internals42 = {
   getAgentSession,
   readTrajectory,
   getInMemoryTrajectory,
@@ -27880,11 +28211,16 @@ function resetPrmSessionState(session, sessionId) {
   session.prmTrajectoryStep = 0;
   session.replayArtifactPath = null;
   if (sessionId) {
-    _internals41.clearTrajectoryCache(sessionId);
+    _internals42.clearTrajectoryCache(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 +28234,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 +28419,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 +28445,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 +28492,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 +28669,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");
@@ -28325,7 +28688,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals20.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals21.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -28358,7 +28721,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);
@@ -28581,7 +28953,7 @@ var DEFAULT_CONTEXT_BUDGET_CONFIG = {
 };
 
 // src/services/status-service.ts
-var _internals42 = {
+var _internals43 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto
@@ -28686,7 +29058,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals42.hasActiveLeanTurbo();
+  const leanActive = _internals43.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -28705,7 +29077,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals42.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals43.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -28737,7 +29109,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals42.hasActiveFullAuto();
+  status.fullAutoActive = _internals43.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -28891,7 +29263,7 @@ No active swarm plan found. Nothing to sync.`;
 
 // src/commands/turbo.ts
 init_logger();
-var _internals43 = {
+var _internals44 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -28951,7 +29323,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals43.loadPluginConfigWithMeta(directory);
+      const { config } = _internals44.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -29048,7 +29420,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals43.loadPluginConfigWithMeta(directory);
+    const { config } = _internals44.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -29204,7 +29576,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals44.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals45.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -29217,7 +29589,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals44.levenshteinDistance(qt, ct);
+          const dist = _internals45.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -29227,7 +29599,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals44.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals45.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -29255,16 +29627,16 @@ 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-r3f47swm.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals44.resolveCommand(tokens);
+  const resolved = _internals45.resolveCommand(tokens);
   if (resolved) {
-    return _internals44.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals45.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals44.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-dsjyfd3g.js");
+  const similar = _internals45.findSimilarCommands(targetCommand);
+  const { buildHelpText: fullHelp } = await import("./index-r3f47swm.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -29328,7 +29700,7 @@ var COMMAND_REGISTRY = {
     toolNoArgs: true
   },
   help: {
-    handler: (ctx) => _internals44.handleHelpCommand(ctx),
+    handler: (ctx) => _internals45.handleHelpCommand(ctx),
     description: "Show help for swarm commands",
     category: "core",
     args: "[command]",
@@ -29397,7 +29769,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-scym5r5y.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-2q9myk7c.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -30178,7 +30550,7 @@ function validateToolPolicy() {
   }
   return { valid: warnings.length === 0, warnings };
 }
-var _internals44 = {
+var _internals45 = {
   handleHelpCommand,
   validateAliases,
   validateToolPolicy,
@@ -30187,7 +30559,7 @@ var _internals44 = {
   findSimilarCommands,
   buildDetailedHelp
 };
-var validation = _internals44.validateAliases();
+var validation = _internals45.validateAliases();
 if (!validation.valid) {
   throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
@@ -30199,7 +30571,7 @@ ${validation.warnings.join(`
 `)}`);
 }
 try {
-  const toolPolicyValidation = _internals44.validateToolPolicy();
+  const toolPolicyValidation = _internals45.validateToolPolicy();
   if (toolPolicyValidation.warnings.length > 0) {
     console.warn(`COMMAND_REGISTRY toolPolicy warnings:
 ${toolPolicyValidation.warnings.join(`
@@ -30263,7 +30635,7 @@ function formatCommandNotFound(tokens) {
   const attemptedCommand = tokens[0] || "";
   const MAX_DISPLAY = 100;
   const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals44.findSimilarCommands(attemptedCommand);
+  const similar = _internals45.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -30320,4 +30692,4 @@ ${text}`;
   };
 }
 
-export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals44 as _internals, resolveCommand };
+export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals45 as _internals, resolveCommand };