opencode-swarm 7.114.7 → 7.114.8

package/dist/cli/{index-6ctejje2.js → index-cs5765s2.js}

@@ -68,7 +68,7 @@ import {
   savePlan,
   transientBackoff,
   validateProjectRoot
-} from "./index-f6y341yk.js";
+} from "./index-yrrqs4b0.js";
 import {
   buildOpenSpecProjectionSync,
   detectSpeckit,
@@ -111,7 +111,7 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-vjvdvjd3.js";
+} from "./index-x12hvfpf.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -121,10 +121,10 @@ import {
   validateActionability,
   validateActionableFields,
   validateLesson
-} from "./index-qrnhvhmg.js";
+} from "./index-n18yy0z1.js";
 import {
   readRecentEscalations
-} from "./index-7stsmndb.js";
+} from "./index-6f6y2rbp.js";
 import {
   effectiveRetrievalOutcomes,
   readKnowledgeCounterRollups,
@@ -132,7 +132,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-kjbfry6m.js";
+} from "./index-8f2270hc.js";
 import {
   appendKnowledge,
   appendRejectedLesson,
@@ -156,7 +156,7 @@ import {
   rewriteKnowledge,
   transactFile,
   transactKnowledge
-} from "./index-91qesget.js";
+} from "./index-rk6qhyng.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -3064,50 +3064,60 @@ class SQLiteMemoryProvider {
     mkdirSync4(path5.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
-    this.db.run("PRAGMA journal_mode = WAL;");
-    this.db.run("PRAGMA synchronous = NORMAL;");
-    const busyTimeoutMs = Math.min(60000, Math.max(0, Math.trunc(this.config.sqlite.busyTimeoutMs)));
-    this.db.run(`PRAGMA busy_timeout = ${busyTimeoutMs};`);
-    this.db.run("PRAGMA foreign_keys = ON;");
-    this.runMigrations();
-    this.backfillScopeKeys();
-    this.backfillRecallRunIds();
-    this.ftsAvailable = this.initializeFtsIndex();
-    this.initializeVecExtension();
-    if (this.config.embeddings.enabled && !this.embeddingProvider) {
-      try {
-        this.embeddingProvider = new LocalEmbeddingProvider({
-          model: this.config.embeddings.model,
-          dimension: this.config.embeddings.dimension,
-          version: this.config.embeddings.version
-        });
-      } catch (err) {
-        this.embeddingProvider = null;
-        warn("Failed to construct embedding provider \u2014 dense retrieval disabled", {
-          reason: err instanceof Error ? err.message : String(err)
-        });
+    try {
+      this.db.run("PRAGMA journal_mode = WAL;");
+      this.db.run("PRAGMA synchronous = NORMAL;");
+      const busyTimeoutMs = Math.min(60000, Math.max(0, Math.trunc(this.config.sqlite.busyTimeoutMs)));
+      this.db.run(`PRAGMA busy_timeout = ${busyTimeoutMs};`);
+      this.db.run("PRAGMA foreign_keys = ON;");
+      this.runMigrations();
+      this.backfillScopeKeys();
+      this.backfillRecallRunIds();
+      this.ftsAvailable = this.initializeFtsIndex();
+      this.initializeVecExtension();
+      if (this.config.embeddings.enabled && !this.embeddingProvider) {
+        try {
+          this.embeddingProvider = new LocalEmbeddingProvider({
+            model: this.config.embeddings.model,
+            dimension: this.config.embeddings.dimension,
+            version: this.config.embeddings.version
+          });
+        } catch (err) {
+          this.embeddingProvider = null;
+          warn("Failed to construct embedding provider \u2014 dense retrieval disabled", {
+            reason: err instanceof Error ? err.message : String(err)
+          });
+        }
+        try {
+          this.embeddingCache = new EmbeddingCache(this.config.embeddings.cacheSize);
+        } catch (err) {
+          this.embeddingCache = null;
+          warn("Failed to construct embedding cache \u2014 recall works without cache", {
+            reason: err instanceof Error ? err.message : String(err)
+          });
+        }
       }
-      try {
-        this.embeddingCache = new EmbeddingCache(this.config.embeddings.cacheSize);
-      } catch (err) {
-        this.embeddingCache = null;
-        warn("Failed to construct embedding cache \u2014 recall works without cache", {
-          reason: err instanceof Error ? err.message : String(err)
-        });
+      this.lastAutomaticJsonlMigration = null;
+      await this.migrateLegacyJsonlIfNeeded();
+      const memoryLoad = this.loadMemories();
+      const proposalLoad = this.loadProposals();
+      this.memories = new Map(memoryLoad.records.map((record) => [record.id, record]));
+      this.proposals = new Map(proposalLoad.records.map((proposal) => [proposal.id, proposal]));
+      this.initialized = true;
+      if (memoryLoad.invalidCount > 0) {
+        await this.event("invalid_load", "memory_items", `${memoryLoad.invalidCount} invalid SQLite memory row(s) skipped`);
       }
-    }
-    this.lastAutomaticJsonlMigration = null;
-    await this.migrateLegacyJsonlIfNeeded();
-    const memoryLoad = this.loadMemories();
-    const proposalLoad = this.loadProposals();
-    this.memories = new Map(memoryLoad.records.map((record) => [record.id, record]));
-    this.proposals = new Map(proposalLoad.records.map((proposal) => [proposal.id, proposal]));
-    this.initialized = true;
-    if (memoryLoad.invalidCount > 0) {
-      await this.event("invalid_load", "memory_items", `${memoryLoad.invalidCount} invalid SQLite memory row(s) skipped`);
-    }
-    if (proposalLoad.invalidCount > 0) {
-      await this.event("invalid_load", "memory_proposals", `${proposalLoad.invalidCount} invalid SQLite proposal row(s) skipped`);
+      if (proposalLoad.invalidCount > 0) {
+        await this.event("invalid_load", "memory_proposals", `${proposalLoad.invalidCount} invalid SQLite proposal row(s) skipped`);
+      }
+    } catch (err) {
+      try {
+        this.db?.close();
+      } catch {}
+      this.db = null;
+      this.ftsAvailable = false;
+      this.initialized = false;
+      throw err;
     }
   }
   async upsert(record) {
@@ -3132,7 +3142,20 @@ class SQLiteMemoryProvider {
   }
   async withTransaction(fn) {
     const db = this.requireDb();
-    return db.transaction(() => fn({}))();
+    if (db.inTransaction) {
+      return await fn({});
+    }
+    db.run("BEGIN IMMEDIATE");
+    try {
+      const result = await fn({});
+      db.run("COMMIT");
+      return result;
+    } catch (err) {
+      try {
+        db.run("ROLLBACK");
+      } catch {}
+      throw err;
+    }
   }
   async delete(id, reason) {
     await this.initialize();
@@ -9192,7 +9215,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     if (config.skill_generation_enabled === true && skillCandidates.length > 0) {
       try {
-        const skillModule = await import("./skill-generator-w6qd9mde.js");
+        const skillModule = await import("./skill-generator-tav44xpm.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -9473,7 +9496,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-qn7ew687.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-5gwp1ar8.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -10434,11 +10457,11 @@ var _internals12 = {
     return KnowledgeConfigSchema2.parse({});
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-qshyr2tc.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-qj970412.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig);
   },
   checkHivePromotions: async (entries, knowledgeConfig) => {
-    const { checkHivePromotions } = await import("./hive-promoter-5ngbmnrw.js");
+    const { checkHivePromotions } = await import("./hive-promoter-ysk5edzw.js");
     return checkHivePromotions(entries, knowledgeConfig);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -10447,7 +10470,7 @@ var _internals12 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-w6qd9mde.js");
+    } = await import("./skill-generator-tav44xpm.js");
     const result = {
       approved: [],
       rejected: [],
@@ -17599,8 +17622,8 @@ var _internals24 = {
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
       import("./schema-aymfdrsb.js"),
-      import("./curator-qshyr2tc.js"),
-      import("./curator-llm-factory-2xgznxyw.js")
+      import("./curator-qj970412.js"),
+      import("./curator-llm-factory-ez48eq02.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -18096,7 +18119,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.114.7",
+  version: "7.114.8",
   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",
@@ -20378,7 +20401,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-8g594znj.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-fehwj116.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -32992,7 +33015,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-z01r5483.js");
+    const { buildHelpText } = await import("./index-z718bgxe.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -33001,7 +33024,7 @@ async function handleHelpCommand(ctx) {
     return _internals49.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals49.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-z01r5483.js");
+  const { buildHelpText: fullHelp } = await import("./index-z718bgxe.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -33134,7 +33157,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-4t8fnysh.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-x2vaxp6s.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -33144,7 +33167,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-4t8fnysh.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-x2vaxp6s.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -34544,6 +34567,7 @@ FILE: src/auth/login.ts
 INPUT: Validate email format, password >= 8 chars
 OUTPUT: Modified file
 CONSTRAINT: Do not modify other functions
+ACCEPTANCE: Populate from the plan task's acceptance criteria / FR / SC when the task has them (one item per line, or FR-/SC-style references), so the coder can gate its implementation on each. Omit the field entirely when the task has no structured acceptance criteria.
 SKILLS: file:.claude/skills/engineering-conventions/SKILL.md
 
 {{AGENT_PREFIX}}reviewer
@@ -38293,7 +38317,6 @@ function resolveWriteTargets(command, writes, cwd) {
     };
   });
 }
-
 // src/hooks/guardrails/index.ts
 var SPEC_DRIFT_BLOCKED_TOOLS = new Set([
   "save_plan",

package/dist/cli/{index-qrnhvhmg.js → index-n18yy0z1.js}

@@ -6,7 +6,7 @@ import {
   resolveSwarmKnowledgePath,
   resolveSwarmRejectedPath,
   transactKnowledge
-} from "./index-91qesget.js";
+} from "./index-rk6qhyng.js";
 import {
   resolveKnowledgeStoreDir
 } from "./index-g40r5d08.js";
@@ -75,6 +75,25 @@ var INJECTION_PATTERNS = [
   /\bconstructor\[/,
   /\.prototype\[/
 ];
+function scanContentSafety(text) {
+  if (typeof text !== "string" || text.length === 0)
+    return null;
+  const normalized = text.normalize("NFKC").replace(INVISIBLE_FORMAT_CHARS, " ").replace(/\s+/g, " ").toLowerCase();
+  for (const pattern of DANGEROUS_COMMAND_ERROR_PATTERNS) {
+    if (pattern.test(normalized))
+      return "dangerous command pattern detected";
+  }
+  for (const pattern of SECURITY_DEGRADING_PATTERNS) {
+    if (pattern.test(normalized)) {
+      return "security-degrading instruction detected";
+    }
+  }
+  for (const pattern of INJECTION_PATTERNS) {
+    if (pattern.test(text))
+      return "injection pattern detected";
+  }
+  return null;
+}
 var VALID_CATEGORIES = new Set([
   "process",
   "architecture",
@@ -412,6 +431,11 @@ function validateActionableFields(fields) {
         errors.push(`${name} contains invalid string`);
         return;
       }
+      const unsafe = scanContentSafety(item);
+      if (unsafe) {
+        errors.push(`${name} contains unsafe content: ${unsafe}`);
+        return;
+      }
     }
   }
   function checkNameList(name, list) {
@@ -758,4 +782,4 @@ var _internals = {
   hasSignificantOverlap
 };
 
-export { DANGEROUS_COMMAND_ERROR_PATTERNS, DANGEROUS_COMMAND_WARNING_PATTERNS, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, validateLesson, ACTIONABLE_STRING_MAX, ACTIONABLE_LIST_MAX, RETIRED_SKILL_HISTORY_MAX, ALLOWED_SKILL_PATH_PREFIXES, validateSkillPath, validateSkillCandidatePath, validateActionableFields, validateActionability, resolveUnactionablePath, appendUnactionable, auditEntryHealth, quarantineEntry, restoreEntry, unarchiveEntry, _internals };
+export { DANGEROUS_COMMAND_ERROR_PATTERNS, DANGEROUS_COMMAND_WARNING_PATTERNS, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, scanContentSafety, validateLesson, ACTIONABLE_STRING_MAX, ACTIONABLE_LIST_MAX, RETIRED_SKILL_HISTORY_MAX, ALLOWED_SKILL_PATH_PREFIXES, validateSkillPath, validateSkillCandidatePath, validateActionableFields, validateActionability, resolveUnactionablePath, appendUnactionable, auditEntryHealth, quarantineEntry, restoreEntry, unarchiveEntry, _internals };

package/dist/cli/{index-91qesget.js → index-rk6qhyng.js}

@@ -595,7 +595,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
   const recovered = touched.filter((e) => e.confidence > CONFIDENCE_FLOOR + FLOOR_EPSILON && e.confidence_floor_demoted);
   if (atFloor.length === 0 && recovered.length === 0)
     return;
-  const { readKnowledgeCounterRollups, effectiveRetrievalOutcomes } = await import("./knowledge-events-k2xsz5bh.js");
+  const { readKnowledgeCounterRollups, effectiveRetrievalOutcomes } = await import("./knowledge-events-m304swh6.js");
   const rollups = await readKnowledgeCounterRollups(directory);
   const flagIds = new Set;
   for (const e of atFloor) {
@@ -662,7 +662,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
     });
   }
   if (action === "quarantine" && toQuarantine.length > 0) {
-    const { quarantineEntry } = await import("./knowledge-validator-2knz0d2t.js");
+    const { quarantineEntry } = await import("./knowledge-validator-t9sym59g.js");
     for (const { id } of toQuarantine) {
       await quarantineEntry(directory, id, "confidence_floor_negative_outcome", "auto").catch((err) => {
         log("[knowledge-store] confidence-floor quarantine failed (best-effort):", err instanceof Error ? err.message : String(err));

package/dist/cli/{index-gmjrwz34.js → index-ry8nwsq6.js}

@@ -12,7 +12,7 @@ import {
   detectPosixWrites,
   detectWindowsWrites,
   resolveWriteTargets
-} from "./index-6ctejje2.js";
+} from "./index-cs5765s2.js";
 import {
   checkFileAuthority,
   classifyFile,

package/dist/cli/{index-vjvdvjd3.js → index-x12hvfpf.js}

@@ -2,18 +2,18 @@
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-qrnhvhmg.js";
+} from "./index-n18yy0z1.js";
 import {
   effectiveRetrievalOutcomes,
   readKnowledgeCounterRollups
-} from "./index-kjbfry6m.js";
+} from "./index-8f2270hc.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-91qesget.js";
+} from "./index-rk6qhyng.js";
 import {
   isActiveStatus
 } from "./index-bfwt3abw.js";

package/dist/cli/{index-f6y341yk.js → index-yrrqs4b0.js}

@@ -845,11 +845,16 @@ var init_executor = __esm(() => {
 
 // src/plan/manager.ts
 import {
+  closeSync as closeSync2,
   copyFileSync,
   existsSync as existsSync5,
-  readdirSync,
+  fsyncSync as fsyncSync2,
+  mkdirSync as mkdirSync5,
+  openSync as openSync2,
+  readdirSync as readdirSync2,
   renameSync as renameSync4,
-  unlinkSync as unlinkSync3
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync6
 } from "fs";
 import * as fsPromises from "fs/promises";
 import * as path9 from "path";
@@ -2144,6 +2149,16 @@ function getLedgerPath(directory) {
 function getPlanJsonPath(directory) {
   return path8.join(directory, ".swarm", PLAN_JSON_FILENAME);
 }
+function writeFileFsyncedThenRename(tempPath, targetPath, data) {
+  const fd = fs5.openSync(tempPath, "w");
+  try {
+    fs5.writeFileSync(fd, data, "utf8");
+    fs5.fsyncSync(fd);
+  } finally {
+    fs5.closeSync(fd);
+  }
+  fs5.renameSync(tempPath, targetPath);
+}
 function computePlanHash(plan) {
   const normalized = {
     schema_version: plan.schema_version,
@@ -2277,8 +2292,7 @@ async function initLedger(directory, planId, initialPlanHash, initialPlan) {
   const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
-  fs5.writeFileSync(tempPath, line, "utf8");
-  fs5.renameSync(tempPath, ledgerPath);
+  writeFileFsyncedThenRename(tempPath, ledgerPath, line);
 }
 async function appendLedgerEvent(directory, eventInput, options) {
   return withEvidenceLock(directory, LEDGER_LOCK_PATH, "plan-ledger", "append-ledger-event", async () => {
@@ -2305,13 +2319,11 @@ async function appendLedgerEvent(directory, eventInput, options) {
     const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
     const line = `${JSON.stringify(event)}
 `;
-    if (fs5.existsSync(ledgerPath)) {
-      const existingContent = fs5.readFileSync(ledgerPath, "utf8");
-      fs5.writeFileSync(tempPath, existingContent + line, "utf8");
-    } else {
+    if (!fs5.existsSync(ledgerPath)) {
       throw new Error("Ledger not initialized. Call initLedger() first.");
     }
-    fs5.renameSync(tempPath, ledgerPath);
+    const existingContent = fs5.readFileSync(ledgerPath, "utf8");
+    writeFileFsyncedThenRename(tempPath, ledgerPath, existingContent + line);
     return event;
   });
 }
@@ -2358,14 +2370,22 @@ async function takeSnapshotEvent(directory, plan, options) {
     payload: snapshotPayload
   }, { planHashAfter: options?.planHashAfter });
 }
-async function replayFromLedger(directory, _options) {
+async function replayFromLedger(directory, options) {
+  const { plan } = await replayFromLedgerWithStatus(directory, options);
+  return plan;
+}
+async function replayFromLedgerWithStatus(directory, _options) {
   const { events, truncated, badSuffix } = await readLedgerEventsWithIntegrity(directory);
   if (events.length === 0) {
-    return null;
+    return { plan: null, truncated, badSuffix };
   }
   if (truncated && badSuffix !== null) {
     await quarantineLedgerSuffix(directory, badSuffix);
   }
+  const plan = reconstructPlanFromEvents(directory, events);
+  return { plan, truncated, badSuffix };
+}
+function reconstructPlanFromEvents(directory, events) {
   const targetPlanId = events[0].plan_id;
   const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
   {
@@ -2531,11 +2551,35 @@ async function readLedgerEventsWithIntegrity(directory) {
   }
 }
 async function quarantineLedgerSuffix(directory, badSuffix) {
+  let salvagedCount = 0;
+  for (const line of badSuffix.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    try {
+      JSON.parse(line);
+      salvagedCount++;
+    } catch {}
+  }
   try {
-    const quarantinePath = path8.join(directory, ".swarm", "plan-ledger.quarantine");
+    const hash = crypto2.createHash("sha256").update(badSuffix, "utf8").digest("hex").slice(0, 12);
+    const swarmDir = path8.join(directory, ".swarm");
+    try {
+      const existing = fs5.readdirSync(swarmDir).filter((name) => name.startsWith("plan-ledger.quarantine.") && name.endsWith(`.${hash}`));
+      for (const name of existing) {
+        const existingPath = path8.join(swarmDir, name);
+        if (fs5.readFileSync(existingPath, "utf8") === badSuffix) {
+          return { path: existingPath, salvagedCount };
+        }
+      }
+    } catch {}
+    const quarantinePath = path8.join(swarmDir, `plan-ledger.quarantine.${Date.now()}.${hash}`);
     fs5.writeFileSync(quarantinePath, badSuffix, "utf8");
-    console.warn(`[ledger] Corrupted suffix quarantined to ${path8.relative(directory, quarantinePath)}`);
-  } catch {}
+    console.warn(`[ledger] Corrupted suffix quarantined to ${path8.relative(directory, quarantinePath)} (salvageable events: ${salvagedCount})`);
+    return { path: quarantinePath, salvagedCount };
+  } catch {
+    return { path: null, salvagedCount };
+  }
 }
 async function loadLastApprovedPlan(directory, expectedPlanId) {
   const events = await readLedgerEvents(directory);
@@ -2868,7 +2912,15 @@ async function loadPlan(directory, cache) {
                 } else {
                   warn("[loadPlan] plan.json is stale (hash mismatch with ledger) \u2014 rebuilding from ledger. If this recurs, run /swarm reset-session to clear stale session state.");
                   try {
-                    const rebuilt = await replayFromLedger(directory);
+                    const { plan: rebuilt, truncated } = await replayFromLedgerWithStatus(directory);
+                    if (truncated) {
+                      const runtimeStale = validated;
+                      runtimeStale._ledgerReplayStale = true;
+                      runtimeStale._ledgerReplayStaleReason = "Ledger truncated: a malformed line stopped replay before the tail, so the ledger could only be reconstructed up to the corruption. plan.json was PRESERVED (not rolled back to the prefix-only projection) and the corrupted suffix was quarantined to .swarm/plan-ledger.quarantine.*. Verify state, then run /swarm reset-session if this persists.";
+                      ledgerStaleWorkspaces.add(resolvedWorkspace);
+                      criticalWarn("[loadPlan] Ledger truncated (poison line detected) \u2014 preserving plan.json instead of rolling back to the prefix-only ledger projection. Durable post-poison events remain in plan.json. Corrupted suffix quarantined to .swarm/plan-ledger.quarantine.*. Run /swarm reset-session after verifying state if this persists.");
+                      return runtimeStale;
+                    }
                     if (rebuilt) {
                       await rebuildPlan(directory, rebuilt, {
                         reason: "ledger_hash_mismatch_recovery"
@@ -3190,7 +3242,7 @@ async function savePlan(directory, plan, options) {
       }
       const MAX_ARCHIVED_SIBLINGS = 5;
       try {
-        const allFiles = readdirSync(swarmDir2);
+        const allFiles = readdirSync2(swarmDir2);
         const archivedSiblings = allFiles.filter((f) => f.startsWith("plan-ledger.archived-") && f.endsWith(".jsonl")).sort();
         if (archivedSiblings.length > MAX_ARCHIVED_SIBLINGS) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
@@ -3407,8 +3459,17 @@ async function rebuildPlan(directory, plan, options) {
   const swarmDir = path9.join(directory, ".swarm");
   const planPath = path9.join(swarmDir, "plan.json");
   const mdPath = path9.join(swarmDir, "plan.md");
+  mkdirSync5(swarmDir, { recursive: true });
   const tempPlanPath = path9.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
-  await bunWrite(tempPlanPath, JSON.stringify(targetPlan, null, 2));
+  {
+    const fd = openSync2(tempPlanPath, "w");
+    try {
+      writeFileSync6(fd, JSON.stringify(targetPlan, null, 2), "utf8");
+      fsyncSync2(fd);
+    } finally {
+      closeSync2(fd);
+    }
+  }
   renameSync4(tempPlanPath, planPath);
   try {
     const markerPath = path9.join(swarmDir, ".plan-write-marker");
@@ -3805,8 +3866,8 @@ function migrateLegacyPlan(planContent, swarmId) {
 
 // src/evidence/manager.ts
 import {
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync2,
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync3,
   realpathSync,
   rmSync,
   statSync as statSync2
@@ -4244,7 +4305,7 @@ async function saveEvidence(directory, taskId, evidence) {
     if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
-    mkdirSync5(evidenceDir, { recursive: true });
+    mkdirSync6(evidenceDir, { recursive: true });
     const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
@@ -4351,7 +4412,7 @@ async function listEvidenceTaskIds(directory) {
   }
   let entries;
   try {
-    entries = readdirSync2(evidenceBasePath);
+    entries = readdirSync3(evidenceBasePath);
   } catch {
     return [];
   }

package/dist/cli/{index-z01r5483.js → index-z718bgxe.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-gmjrwz34.js";
+} from "./index-ry8nwsq6.js";
 import {
   handleGuardrailLog
 } from "./index-7jmrbp68.js";
@@ -81,7 +81,7 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-6ctejje2.js";
+} from "./index-cs5765s2.js";
 import"./index-yfedche9.js";
 import"./index-c8s9a3zh.js";
 import"./index-9bsmzfk3.js";
@@ -90,15 +90,15 @@ import {
   ORCHESTRATOR_NAME,
   stripKnownSwarmPrefix
 } from "./index-a45jq4b7.js";
-import"./index-f6y341yk.js";
+import"./index-yrrqs4b0.js";
 import"./index-scww5b77.js";
 import"./index-ga4ta3cr.js";
 import"./index-80jkseqw.js";
-import"./index-vjvdvjd3.js";
-import"./index-qrnhvhmg.js";
-import"./index-7stsmndb.js";
-import"./index-kjbfry6m.js";
-import"./index-91qesget.js";
+import"./index-x12hvfpf.js";
+import"./index-n18yy0z1.js";
+import"./index-6f6y2rbp.js";
+import"./index-8f2270hc.js";
+import"./index-rk6qhyng.js";
 import"./index-bfwt3abw.js";
 import"./index-g40r5d08.js";
 import"./index-vxv732ex.js";