opencode-swarm 6.47.0 → 6.47.2

package/dist/cli/index.js

@@ -16208,20 +16208,22 @@ async function readLedgerEvents(directory) {
     return [];
   }
 }
-async function initLedger(directory, planId) {
+async function initLedger(directory, planId, initialPlanHash) {
   const ledgerPath = getLedgerPath(directory);
   const planJsonPath = getPlanJsonPath(directory);
   if (fs4.existsSync(ledgerPath)) {
     throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
   }
-  let planHashAfter = "";
-  try {
-    if (fs4.existsSync(planJsonPath)) {
-      const content = fs4.readFileSync(planJsonPath, "utf8");
-      const plan = JSON.parse(content);
-      planHashAfter = computePlanHash(plan);
-    }
-  } catch {}
+  let planHashAfter = initialPlanHash ?? "";
+  if (!initialPlanHash) {
+    try {
+      if (fs4.existsSync(planJsonPath)) {
+        const content = fs4.readFileSync(planJsonPath, "utf8");
+        const plan = JSON.parse(content);
+        planHashAfter = computePlanHash(plan);
+      }
+    } catch {}
+  }
   const event = {
     seq: 1,
     timestamp: new Date().toISOString(),
@@ -16233,7 +16235,7 @@ async function initLedger(directory, planId) {
     schema_version: LEDGER_SCHEMA_VERSION
   };
   fs4.mkdirSync(path7.join(directory, ".swarm"), { recursive: true });
-  const tempPath = `${ledgerPath}.tmp`;
+  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
   fs4.writeFileSync(tempPath, line, "utf8");
@@ -16260,7 +16262,7 @@ async function appendLedgerEvent(directory, eventInput, options) {
     schema_version: LEDGER_SCHEMA_VERSION
   };
   fs4.mkdirSync(path7.join(directory, ".swarm"), { recursive: true });
-  const tempPath = `${ledgerPath}.tmp`;
+  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
   if (fs4.existsSync(ledgerPath)) {
@@ -16278,10 +16280,11 @@ async function takeSnapshotEvent(directory, plan, options) {
     plan,
     payload_hash: payloadHash
   };
+  const planId = `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
   return appendLedgerEvent(directory, {
     event_type: "snapshot",
     source: "takeSnapshotEvent",
-    plan_id: plan.title,
+    plan_id: planId,
     payload: snapshotPayload
   }, options);
 }
@@ -16290,13 +16293,15 @@ async function replayFromLedger(directory, options) {
   if (events.length === 0) {
     return null;
   }
+  const targetPlanId = events[0].plan_id;
+  const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
   {
-    const snapshotEvents = events.filter((e) => e.event_type === "snapshot");
+    const snapshotEvents = relevantEvents.filter((e) => e.event_type === "snapshot");
     if (snapshotEvents.length > 0) {
       const latestSnapshotEvent = snapshotEvents[snapshotEvents.length - 1];
       const snapshotPayload = latestSnapshotEvent.payload;
       let plan2 = snapshotPayload.plan;
-      const eventsAfterSnapshot = events.filter((e) => e.seq > latestSnapshotEvent.seq);
+      const eventsAfterSnapshot = relevantEvents.filter((e) => e.seq > latestSnapshotEvent.seq);
       for (const event of eventsAfterSnapshot) {
         plan2 = applyEventToPlan(plan2, event);
         if (plan2 === null) {
@@ -16317,7 +16322,7 @@ async function replayFromLedger(directory, options) {
   } catch {
     return null;
   }
-  for (const event of events) {
+  for (const event of relevantEvents) {
     if (plan === null) {
       return null;
     }
@@ -16331,10 +16336,14 @@ function applyEventToPlan(plan, event) {
       return plan;
     case "task_status_changed":
       if (event.task_id && event.to_status) {
+        const parseResult = TaskStatusSchema.safeParse(event.to_status);
+        if (!parseResult.success) {
+          return plan;
+        }
         for (const phase of plan.phases) {
           const task = phase.tasks.find((t) => t.id === event.task_id);
           if (task) {
-            task.status = event.to_status;
+            task.status = parseResult.data;
             break;
           }
         }
@@ -16368,6 +16377,7 @@ function applyEventToPlan(plan, event) {
 }
 var LEDGER_SCHEMA_VERSION = "1.0.0", LEDGER_FILENAME = "plan-ledger.jsonl", PLAN_JSON_FILENAME = "plan.json", LedgerStaleWriterError;
 var init_ledger = __esm(() => {
+  init_plan_schema();
   LedgerStaleWriterError = class LedgerStaleWriterError extends Error {
     constructor(message) {
       super(message);
@@ -16377,7 +16387,7 @@ var init_ledger = __esm(() => {
 });
 
 // src/plan/manager.ts
-import { renameSync as renameSync3, unlinkSync } from "fs";
+import { existsSync as existsSync5, renameSync as renameSync3, unlinkSync } from "fs";
 import * as path8 from "path";
 async function loadPlanJsonOnly(directory) {
   const planJsonContent = await readSwarmFileAsync(directory, "plan.json");
@@ -16508,28 +16518,49 @@ async function loadPlan(directory) {
           const planHash = computePlanHash(validated);
           const ledgerHash = await getLatestLedgerHash(directory);
           if (ledgerHash !== "" && planHash !== ledgerHash) {
-            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);
-              if (rebuilt) {
-                await rebuildPlan(directory, rebuilt);
-                warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at SWARM_PLAN.md if it exists.");
-                return rebuilt;
+            const currentPlanId = `${validated.swarm}-${validated.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+            const ledgerEvents = await readLedgerEvents(directory);
+            const firstEvent = ledgerEvents.length > 0 ? ledgerEvents[0] : null;
+            if (firstEvent && firstEvent.plan_id !== currentPlanId) {
+              warn(`[loadPlan] Ledger identity mismatch (ledger: ${firstEvent.plan_id}, plan: ${currentPlanId}) \u2014 skipping ledger rebuild (migration detected). Use /swarm reset-session to reinitialize the ledger.`);
+            } 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);
+                if (rebuilt) {
+                  await rebuildPlan(directory, rebuilt);
+                  warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at SWARM_PLAN.md if it exists.");
+                  return rebuilt;
+                }
+              } catch (replayError) {
+                warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
               }
-            } catch (replayError) {
-              warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
             }
           }
         }
         return validated;
       } catch (error93) {
         warn(`[loadPlan] plan.json validation failed: ${error93 instanceof Error ? error93.message : String(error93)}. Attempting rebuild from ledger. If rebuild fails, check SWARM_PLAN.md for a checkpoint.`);
+        let rawPlanId = null;
+        try {
+          const rawParsed = JSON.parse(planJsonContent);
+          if (typeof rawParsed?.swarm === "string" && typeof rawParsed?.title === "string") {
+            rawPlanId = `${rawParsed.swarm}-${rawParsed.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+          }
+        } catch {}
         if (await ledgerExists(directory)) {
-          const rebuilt = await replayFromLedger(directory);
-          if (rebuilt) {
-            await rebuildPlan(directory, rebuilt);
-            warn("[loadPlan] Rebuilt plan from ledger after validation failure. Projection was stale.");
-            return rebuilt;
+          const ledgerEventsForCatch = await readLedgerEvents(directory);
+          const catchFirstEvent = ledgerEventsForCatch.length > 0 ? ledgerEventsForCatch[0] : null;
+          const identityMatch = rawPlanId === null || catchFirstEvent === null || catchFirstEvent.plan_id === rawPlanId;
+          if (!identityMatch) {
+            warn(`[loadPlan] Ledger identity mismatch in validation-failure path (ledger: ${catchFirstEvent?.plan_id}, plan: ${rawPlanId}) \u2014 skipping ledger rebuild (migration detected).`);
+          } else if (catchFirstEvent !== null && rawPlanId !== null) {
+            const rebuilt = await replayFromLedger(directory);
+            if (rebuilt) {
+              await rebuildPlan(directory, rebuilt);
+              warn("[loadPlan] Rebuilt plan from ledger after validation failure. Projection was stale.");
+              return rebuilt;
+            }
           }
         }
         const planMdContent2 = await readSwarmFileAsync(directory, "plan.md");
@@ -16597,9 +16628,28 @@ async function savePlan(directory, plan, options) {
     }
   }
   const currentPlan = await loadPlanJsonOnly(directory);
+  const planId = `${validated.swarm}-${validated.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const planHashForInit = computePlanHash(validated);
   if (!await ledgerExists(directory)) {
-    const planId = `${validated.swarm}-${validated.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
-    await initLedger(directory, planId);
+    await initLedger(directory, planId, planHashForInit);
+  } else {
+    const existingEvents = await readLedgerEvents(directory);
+    if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
+      const swarmDir2 = path8.resolve(directory, ".swarm");
+      const oldLedgerPath = path8.join(swarmDir2, "plan-ledger.jsonl");
+      const archivePath = path8.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+      if (existsSync5(oldLedgerPath)) {
+        renameSync3(oldLedgerPath, archivePath);
+        warn(`[savePlan] Ledger identity mismatch (was "${existingEvents[0].plan_id}", now "${planId}") \u2014 archived old ledger to ${archivePath} and reinitializing.`);
+      }
+      try {
+        await initLedger(directory, planId, planHashForInit);
+      } catch (initErr) {
+        if (!(initErr instanceof Error && initErr.message.includes("already initialized"))) {
+          throw initErr;
+        }
+      }
+    }
   }
   const currentHash = computeCurrentPlanHash(directory);
   const hashAfter = computePlanHash(validated);
@@ -16692,10 +16742,24 @@ async function rebuildPlan(directory, plan) {
   const tempPlanPath = path8.join(swarmDir, `plan.json.rebuild.${Date.now()}`);
   await Bun.write(tempPlanPath, JSON.stringify(targetPlan, null, 2));
   renameSync3(tempPlanPath, planPath);
+  const contentHash = computePlanContentHash(targetPlan);
   const markdown = derivePlanMarkdown(targetPlan);
+  const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
   const tempMdPath = path8.join(swarmDir, `plan.md.rebuild.${Date.now()}`);
-  await Bun.write(tempMdPath, markdown);
+  await Bun.write(tempMdPath, markdownWithHash);
   renameSync3(tempMdPath, mdPath);
+  try {
+    const markerPath = path8.join(swarmDir, ".plan-write-marker");
+    const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+    const marker = JSON.stringify({
+      source: "plan_manager",
+      timestamp: new Date().toISOString(),
+      phases_count: targetPlan.phases.length,
+      tasks_count: tasksCount
+    });
+    await Bun.write(markerPath, marker);
+  } catch {}
   return targetPlan;
 }
 function derivePlanMarkdown(plan) {
@@ -33996,7 +34060,7 @@ async function handleDarkMatterCommand(directory, args) {
 
 // src/services/diagnose-service.ts
 import * as child_process3 from "child_process";
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
 import path15 from "path";
 import { fileURLToPath } from "url";
 init_manager();
@@ -34233,7 +34297,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync5(directory) || !statSync3(directory).isDirectory()) {
+    if (!existsSync6(directory) || !statSync3(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -34298,7 +34362,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path15.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync5(configPath)) {
+  if (!existsSync6(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -34348,11 +34412,11 @@ async function checkGrammarWasmFiles() {
   const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/services");
   const grammarDir = isSource ? path15.join(thisDir, "..", "lang", "grammars") : path15.join(thisDir, "lang", "grammars");
   const missing = [];
-  if (!existsSync5(path15.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync6(path15.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync5(path15.join(grammarDir, file3))) {
+    if (!existsSync6(path15.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -34371,7 +34435,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path15.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync5(manifestPath)) {
+  if (!existsSync6(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -34423,7 +34487,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path15.join(directory, ".swarm/events.jsonl");
-  if (!existsSync5(eventsPath)) {
+  if (!existsSync6(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -34464,7 +34528,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path15.join(directory, ".swarm/events.jsonl");
-  if (!existsSync5(eventsPath)) {
+  if (!existsSync6(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -34520,7 +34584,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path15.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync5(summaryPath)) {
+    if (!existsSync6(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -35414,14 +35478,14 @@ async function handleHistoryCommand(directory, _args) {
 }
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import * as path17 from "path";
 async function migrateContextToKnowledge(directory, config3) {
   const sentinelPath = path17.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path17.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync7(sentinelPath)) {
+  if (existsSync8(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -35430,7 +35494,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync7(contextPath)) {
+  if (!existsSync8(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -35616,7 +35680,7 @@ function truncateLesson(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path17.join(directory, "package.json");
-  if (existsSync7(packageJsonPath)) {
+  if (existsSync8(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {

package/dist/commands/sync-plan.d.ts

@@ -3,6 +3,8 @@
  * Maps to: plan service (loadPlan which triggers auto-heal/sync)
  *
  * This command ensures plan.json and plan.md are in sync.
- * The loadPlan function automatically regenerates plan.md from plan.json if needed.
+ * loadPlan() is safe here: the migration-aware ledger guard in loadPlan()
+ * now prevents false reverts caused by swarm identity changes, so the
+ * full auto-heal path (including legacy plan.md migration) is correct.
  */
 export declare function handleSyncPlanCommand(directory: string, _args: string[]): Promise<string>;

package/dist/hooks/curator-types.d.ts

@@ -2,6 +2,7 @@
  * Curator types — phase context consolidation and drift detection.
  * No runtime logic. Types only.
  */
+import type { KnowledgeCategory } from './knowledge-types.js';
 /** Curator summary — anchored iterative format. Persisted to .swarm/curator-summary.json */
 export interface CuratorSummary {
     schema_version: 1;
@@ -39,6 +40,8 @@ export interface KnowledgeRecommendation {
     entry_id?: string;
     lesson: string;
     reason: string;
+    category?: KnowledgeCategory;
+    confidence?: number;
 }
 /** Drift report — produced by critic after curator phase run */
 export interface DriftReport {

package/dist/hooks/curator.d.ts

@@ -83,7 +83,7 @@ export declare function runCuratorPhase(directory: string, phase: number, agents
  * @param knowledgeConfig - Knowledge configuration (for path resolution)
  * @returns Counts of applied and skipped recommendations
  */
-export declare function applyCuratorKnowledgeUpdates(directory: string, recommendations: KnowledgeRecommendation[], _knowledgeConfig: KnowledgeConfig): Promise<{
+export declare function applyCuratorKnowledgeUpdates(directory: string, recommendations: KnowledgeRecommendation[], knowledgeConfig: KnowledgeConfig): Promise<{
     applied: number;
     skipped: number;
 }>;

package/dist/index.js

@@ -16046,20 +16046,22 @@ async function readLedgerEvents(directory) {
     return [];
   }
 }
-async function initLedger(directory, planId) {
+async function initLedger(directory, planId, initialPlanHash) {
   const ledgerPath = getLedgerPath(directory);
   const planJsonPath = getPlanJsonPath(directory);
   if (fs6.existsSync(ledgerPath)) {
     throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
   }
-  let planHashAfter = "";
-  try {
-    if (fs6.existsSync(planJsonPath)) {
-      const content = fs6.readFileSync(planJsonPath, "utf8");
-      const plan = JSON.parse(content);
-      planHashAfter = computePlanHash(plan);
-    }
-  } catch {}
+  let planHashAfter = initialPlanHash ?? "";
+  if (!initialPlanHash) {
+    try {
+      if (fs6.existsSync(planJsonPath)) {
+        const content = fs6.readFileSync(planJsonPath, "utf8");
+        const plan = JSON.parse(content);
+        planHashAfter = computePlanHash(plan);
+      }
+    } catch {}
+  }
   const event = {
     seq: 1,
     timestamp: new Date().toISOString(),
@@ -16071,7 +16073,7 @@ async function initLedger(directory, planId) {
     schema_version: LEDGER_SCHEMA_VERSION
   };
   fs6.mkdirSync(path6.join(directory, ".swarm"), { recursive: true });
-  const tempPath = `${ledgerPath}.tmp`;
+  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
   fs6.writeFileSync(tempPath, line, "utf8");
@@ -16098,7 +16100,7 @@ async function appendLedgerEvent(directory, eventInput, options) {
     schema_version: LEDGER_SCHEMA_VERSION
   };
   fs6.mkdirSync(path6.join(directory, ".swarm"), { recursive: true });
-  const tempPath = `${ledgerPath}.tmp`;
+  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   const line = `${JSON.stringify(event)}
 `;
   if (fs6.existsSync(ledgerPath)) {
@@ -16116,10 +16118,11 @@ async function takeSnapshotEvent(directory, plan, options) {
     plan,
     payload_hash: payloadHash
   };
+  const planId = `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
   return appendLedgerEvent(directory, {
     event_type: "snapshot",
     source: "takeSnapshotEvent",
-    plan_id: plan.title,
+    plan_id: planId,
     payload: snapshotPayload
   }, options);
 }
@@ -16128,13 +16131,15 @@ async function replayFromLedger(directory, options) {
   if (events.length === 0) {
     return null;
   }
+  const targetPlanId = events[0].plan_id;
+  const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
   {
-    const snapshotEvents = events.filter((e) => e.event_type === "snapshot");
+    const snapshotEvents = relevantEvents.filter((e) => e.event_type === "snapshot");
     if (snapshotEvents.length > 0) {
       const latestSnapshotEvent = snapshotEvents[snapshotEvents.length - 1];
       const snapshotPayload = latestSnapshotEvent.payload;
       let plan2 = snapshotPayload.plan;
-      const eventsAfterSnapshot = events.filter((e) => e.seq > latestSnapshotEvent.seq);
+      const eventsAfterSnapshot = relevantEvents.filter((e) => e.seq > latestSnapshotEvent.seq);
       for (const event of eventsAfterSnapshot) {
         plan2 = applyEventToPlan(plan2, event);
         if (plan2 === null) {
@@ -16155,7 +16160,7 @@ async function replayFromLedger(directory, options) {
   } catch {
     return null;
   }
-  for (const event of events) {
+  for (const event of relevantEvents) {
     if (plan === null) {
       return null;
     }
@@ -16169,10 +16174,14 @@ function applyEventToPlan(plan, event) {
       return plan;
     case "task_status_changed":
       if (event.task_id && event.to_status) {
+        const parseResult = TaskStatusSchema.safeParse(event.to_status);
+        if (!parseResult.success) {
+          return plan;
+        }
         for (const phase of plan.phases) {
           const task = phase.tasks.find((t) => t.id === event.task_id);
           if (task) {
-            task.status = event.to_status;
+            task.status = parseResult.data;
             break;
           }
         }
@@ -16206,6 +16215,7 @@ function applyEventToPlan(plan, event) {
 }
 var LEDGER_SCHEMA_VERSION = "1.0.0", LEDGER_FILENAME = "plan-ledger.jsonl", PLAN_JSON_FILENAME = "plan.json", LedgerStaleWriterError;
 var init_ledger = __esm(() => {
+  init_plan_schema();
   LedgerStaleWriterError = class LedgerStaleWriterError extends Error {
     constructor(message) {
       super(message);
@@ -16215,7 +16225,7 @@ var init_ledger = __esm(() => {
 });
 
 // src/plan/manager.ts
-import { renameSync as renameSync3, unlinkSync } from "fs";
+import { existsSync as existsSync4, renameSync as renameSync3, unlinkSync } from "fs";
 import * as path7 from "path";
 async function loadPlanJsonOnly(directory) {
   const planJsonContent = await readSwarmFileAsync(directory, "plan.json");
@@ -16346,28 +16356,49 @@ async function loadPlan(directory) {
           const planHash = computePlanHash(validated);
           const ledgerHash = await getLatestLedgerHash(directory);
           if (ledgerHash !== "" && planHash !== ledgerHash) {
-            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);
-              if (rebuilt) {
-                await rebuildPlan(directory, rebuilt);
-                warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at SWARM_PLAN.md if it exists.");
-                return rebuilt;
+            const currentPlanId = `${validated.swarm}-${validated.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+            const ledgerEvents = await readLedgerEvents(directory);
+            const firstEvent = ledgerEvents.length > 0 ? ledgerEvents[0] : null;
+            if (firstEvent && firstEvent.plan_id !== currentPlanId) {
+              warn(`[loadPlan] Ledger identity mismatch (ledger: ${firstEvent.plan_id}, plan: ${currentPlanId}) \u2014 skipping ledger rebuild (migration detected). Use /swarm reset-session to reinitialize the ledger.`);
+            } 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);
+                if (rebuilt) {
+                  await rebuildPlan(directory, rebuilt);
+                  warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at SWARM_PLAN.md if it exists.");
+                  return rebuilt;
+                }
+              } catch (replayError) {
+                warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
               }
-            } catch (replayError) {
-              warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
             }
           }
         }
         return validated;
       } catch (error49) {
         warn(`[loadPlan] plan.json validation failed: ${error49 instanceof Error ? error49.message : String(error49)}. Attempting rebuild from ledger. If rebuild fails, check SWARM_PLAN.md for a checkpoint.`);
+        let rawPlanId = null;
+        try {
+          const rawParsed = JSON.parse(planJsonContent);
+          if (typeof rawParsed?.swarm === "string" && typeof rawParsed?.title === "string") {
+            rawPlanId = `${rawParsed.swarm}-${rawParsed.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+          }
+        } catch {}
         if (await ledgerExists(directory)) {
-          const rebuilt = await replayFromLedger(directory);
-          if (rebuilt) {
-            await rebuildPlan(directory, rebuilt);
-            warn("[loadPlan] Rebuilt plan from ledger after validation failure. Projection was stale.");
-            return rebuilt;
+          const ledgerEventsForCatch = await readLedgerEvents(directory);
+          const catchFirstEvent = ledgerEventsForCatch.length > 0 ? ledgerEventsForCatch[0] : null;
+          const identityMatch = rawPlanId === null || catchFirstEvent === null || catchFirstEvent.plan_id === rawPlanId;
+          if (!identityMatch) {
+            warn(`[loadPlan] Ledger identity mismatch in validation-failure path (ledger: ${catchFirstEvent?.plan_id}, plan: ${rawPlanId}) \u2014 skipping ledger rebuild (migration detected).`);
+          } else if (catchFirstEvent !== null && rawPlanId !== null) {
+            const rebuilt = await replayFromLedger(directory);
+            if (rebuilt) {
+              await rebuildPlan(directory, rebuilt);
+              warn("[loadPlan] Rebuilt plan from ledger after validation failure. Projection was stale.");
+              return rebuilt;
+            }
           }
         }
         const planMdContent2 = await readSwarmFileAsync(directory, "plan.md");
@@ -16435,9 +16466,28 @@ async function savePlan(directory, plan, options) {
     }
   }
   const currentPlan = await loadPlanJsonOnly(directory);
+  const planId = `${validated.swarm}-${validated.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const planHashForInit = computePlanHash(validated);
   if (!await ledgerExists(directory)) {
-    const planId = `${validated.swarm}-${validated.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
-    await initLedger(directory, planId);
+    await initLedger(directory, planId, planHashForInit);
+  } else {
+    const existingEvents = await readLedgerEvents(directory);
+    if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
+      const swarmDir2 = path7.resolve(directory, ".swarm");
+      const oldLedgerPath = path7.join(swarmDir2, "plan-ledger.jsonl");
+      const archivePath = path7.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+      if (existsSync4(oldLedgerPath)) {
+        renameSync3(oldLedgerPath, archivePath);
+        warn(`[savePlan] Ledger identity mismatch (was "${existingEvents[0].plan_id}", now "${planId}") \u2014 archived old ledger to ${archivePath} and reinitializing.`);
+      }
+      try {
+        await initLedger(directory, planId, planHashForInit);
+      } catch (initErr) {
+        if (!(initErr instanceof Error && initErr.message.includes("already initialized"))) {
+          throw initErr;
+        }
+      }
+    }
   }
   const currentHash = computeCurrentPlanHash(directory);
   const hashAfter = computePlanHash(validated);
@@ -16530,10 +16580,24 @@ async function rebuildPlan(directory, plan) {
   const tempPlanPath = path7.join(swarmDir, `plan.json.rebuild.${Date.now()}`);
   await Bun.write(tempPlanPath, JSON.stringify(targetPlan, null, 2));
   renameSync3(tempPlanPath, planPath);
+  const contentHash = computePlanContentHash(targetPlan);
   const markdown = derivePlanMarkdown(targetPlan);
+  const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
+${markdown}`;
   const tempMdPath = path7.join(swarmDir, `plan.md.rebuild.${Date.now()}`);
-  await Bun.write(tempMdPath, markdown);
+  await Bun.write(tempMdPath, markdownWithHash);
   renameSync3(tempMdPath, mdPath);
+  try {
+    const markerPath = path7.join(swarmDir, ".plan-write-marker");
+    const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+    const marker = JSON.stringify({
+      source: "plan_manager",
+      timestamp: new Date().toISOString(),
+      phases_count: targetPlan.phases.length,
+      tasks_count: tasksCount
+    });
+    await Bun.write(markerPath, marker);
+  } catch {}
   return targetPlan;
 }
 async function updateTaskStatus(directory, taskId, status) {
@@ -17134,11 +17198,11 @@ __export(exports_evidence_summary_integration, {
   createEvidenceSummaryIntegration: () => createEvidenceSummaryIntegration,
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
 import * as path8 from "path";
 function persistSummary(swarmDir, artifact, filename) {
   const swarmPath = path8.join(swarmDir, ".swarm");
-  if (!existsSync4(swarmPath)) {
+  if (!existsSync5(swarmPath)) {
     mkdirSync4(swarmPath, { recursive: true });
   }
   const artifactPath = path8.join(swarmPath, filename);
@@ -32356,7 +32420,7 @@ var require_proper_lockfile = __commonJS((exports, module2) => {
 });
 
 // src/hooks/knowledge-store.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { appendFile, mkdir, readFile as readFile2, writeFile } from "fs/promises";
 import * as os3 from "os";
 import * as path12 from "path";
@@ -32384,7 +32448,7 @@ function resolveHiveRejectedPath() {
   return path12.join(path12.dirname(hivePath), "shared-learnings-rejected.jsonl");
 }
 async function readKnowledge(filePath) {
-  if (!existsSync8(filePath))
+  if (!existsSync9(filePath))
     return [];
   const content = await readFile2(filePath, "utf-8");
   const results = [];
@@ -41867,8 +41931,8 @@ async function loadGrammar(languageId) {
   const parser = new Parser;
   const wasmFileName = getWasmFileName(normalizedId);
   const wasmPath = path56.join(getGrammarsDirAbsolute(), wasmFileName);
-  const { existsSync: existsSync33 } = await import("fs");
-  if (!existsSync33(wasmPath)) {
+  const { existsSync: existsSync34 } = await import("fs");
+  if (!existsSync34(wasmPath)) {
     throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
 Make sure to run 'bun run build' to copy grammar files to dist/lang/grammars/`);
   }
@@ -46021,8 +46085,9 @@ class PlanSyncWorker {
     try {
       log("[PlanSyncWorker] Syncing plan...");
       this.checkForUnauthorizedWrite();
-      const plan = await this.withTimeout(loadPlan(this.directory), this.syncTimeoutMs, "Sync operation timed out");
+      const plan = await this.withTimeout(loadPlanJsonOnly(this.directory), this.syncTimeoutMs, "Sync operation timed out");
       if (plan) {
+        await regeneratePlanMarkdown(this.directory, plan);
         log("[PlanSyncWorker] Sync complete", {
           title: plan.title,
           phase: plan.current_phase
@@ -46686,7 +46751,7 @@ import path17 from "path";
 
 // src/hooks/knowledge-reader.ts
 init_knowledge_store();
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import * as path13 from "path";
 var JACCARD_THRESHOLD = 0.6;
@@ -46739,7 +46804,7 @@ async function recordLessonsShown(directory, lessonIds, currentPhase) {
   const shownFile = path13.join(directory, ".swarm", ".knowledge-shown.json");
   try {
     let shownData = {};
-    if (existsSync9(shownFile)) {
+    if (existsSync10(shownFile)) {
       const content = await readFile3(shownFile, "utf-8");
       shownData = JSON.parse(content);
     }
@@ -46845,7 +46910,7 @@ async function readMergedKnowledge(directory, config3, context) {
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
   const shownFile = path13.join(directory, ".swarm", ".knowledge-shown.json");
   try {
-    if (!existsSync9(shownFile)) {
+    if (!existsSync10(shownFile)) {
       return;
     }
     const content = await readFile3(shownFile, "utf-8");
@@ -48791,7 +48856,7 @@ ${phaseDigest.summary}`,
     };
   }
 }
-async function applyCuratorKnowledgeUpdates(directory, recommendations, _knowledgeConfig) {
+async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledgeConfig) {
   let applied = 0;
   let skipped = 0;
   if (recommendations.length === 0) {
@@ -48853,6 +48918,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, _knowled
   if (modified) {
     await rewriteKnowledge(knowledgePath, updatedEntries);
   }
+  const existingLessons = entries.map((e) => e.lesson);
   for (const rec of recommendations) {
     if (rec.entry_id !== undefined)
       continue;
@@ -48860,20 +48926,35 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, _knowled
       skipped++;
       continue;
     }
-    const lesson = rec.lesson?.trim() ?? "";
+    const lesson = (rec.lesson?.trim() ?? "").slice(0, 280);
     if (lesson.length < 15) {
       skipped++;
       continue;
     }
+    if (existingLessons.some((el) => el.toLowerCase() === lesson.toLowerCase())) {
+      skipped++;
+      continue;
+    }
+    if (knowledgeConfig.validation_enabled !== false) {
+      const validation = validateLesson(lesson, existingLessons, {
+        category: rec.category ?? "other",
+        scope: "global",
+        confidence: rec.confidence ?? 0.5
+      });
+      if (!validation.valid) {
+        skipped++;
+        continue;
+      }
+    }
     const now = new Date().toISOString();
     const newEntry = {
       id: randomUUID(),
       tier: "swarm",
-      lesson: lesson.slice(0, 280),
-      category: "other",
+      lesson,
+      category: rec.category ?? "other",
       tags: [],
       scope: "global",
-      confidence: 0.5,
+      confidence: rec.confidence ?? 0.5,
       status: "candidate",
       confirmed_by: [],
       retrieval_outcomes: {
@@ -48889,6 +48970,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, _knowled
     };
     await appendKnowledge(knowledgePath, newEntry);
     applied++;
+    existingLessons.push(lesson);
   }
   return { applied, skipped };
 }
@@ -49150,7 +49232,7 @@ init_manager();
 init_utils2();
 init_manager2();
 import * as child_process3 from "child_process";
-import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
 import path22 from "path";
 import { fileURLToPath } from "url";
 function validateTaskDag(plan) {
@@ -49384,7 +49466,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync10(directory) || !statSync5(directory).isDirectory()) {
+    if (!existsSync11(directory) || !statSync5(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -49449,7 +49531,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path22.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync10(configPath)) {
+  if (!existsSync11(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -49499,11 +49581,11 @@ async function checkGrammarWasmFiles() {
   const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/services");
   const grammarDir = isSource ? path22.join(thisDir, "..", "lang", "grammars") : path22.join(thisDir, "lang", "grammars");
   const missing = [];
-  if (!existsSync10(path22.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync11(path22.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync10(path22.join(grammarDir, file3))) {
+    if (!existsSync11(path22.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -49522,7 +49604,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path22.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync10(manifestPath)) {
+  if (!existsSync11(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -49574,7 +49656,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path22.join(directory, ".swarm/events.jsonl");
-  if (!existsSync10(eventsPath)) {
+  if (!existsSync11(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -49615,7 +49697,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path22.join(directory, ".swarm/events.jsonl");
-  if (!existsSync10(eventsPath)) {
+  if (!existsSync11(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -49671,7 +49753,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path22.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync10(summaryPath)) {
+    if (!existsSync11(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -50570,14 +50652,14 @@ init_schema();
 // src/hooks/knowledge-migrator.ts
 init_knowledge_store();
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
 import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import * as path24 from "path";
 async function migrateContextToKnowledge(directory, config3) {
   const sentinelPath = path24.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path24.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync12(sentinelPath)) {
+  if (existsSync13(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -50586,7 +50668,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync12(contextPath)) {
+  if (!existsSync13(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -50772,7 +50854,7 @@ function truncateLesson(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path24.join(directory, "package.json");
-  if (existsSync12(packageJsonPath)) {
+  if (existsSync13(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -60698,7 +60780,19 @@ var curator_analyze = createSwarmTool({
       ]),
       entry_id: tool.schema.string().optional(),
       lesson: tool.schema.string(),
-      reason: tool.schema.string()
+      reason: tool.schema.string(),
+      category: tool.schema.enum([
+        "process",
+        "architecture",
+        "tooling",
+        "security",
+        "testing",
+        "debugging",
+        "performance",
+        "integration",
+        "other"
+      ]).optional(),
+      confidence: tool.schema.number().min(0).max(1).optional()
     })).optional().describe("Knowledge recommendations to apply. If omitted, only collects digest data.")
   },
   execute: async (args2, directory, ctx) => {
@@ -60717,6 +60811,16 @@ var curator_analyze = createSwarmTool({
           }
         }
       }
+      if (typedArgs.recommendations) {
+        const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        for (const rec of typedArgs.recommendations) {
+          if (rec.entry_id !== undefined && !UUID_V4.test(rec.entry_id)) {
+            return JSON.stringify({
+              error: `Invalid entry_id '${rec.entry_id}': must be a UUID v4 or omitted. ` + `Use undefined/omit entry_id to create a new entry.`
+            }, null, 2);
+          }
+        }
+      }
       const { config: config3 } = loadPluginConfigWithMeta(directory);
       const curatorConfig = CuratorConfigSchema.parse(config3.curator ?? {});
       const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
@@ -60757,12 +60861,7 @@ var curator_analyze = createSwarmTool({
       let applied = 0;
       let skipped = 0;
       if (typedArgs.recommendations && typedArgs.recommendations.length > 0) {
-        const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-        const sanitizedRecs = typedArgs.recommendations.map((rec) => ({
-          ...rec,
-          entry_id: rec.entry_id === undefined || UUID_V4.test(rec.entry_id) ? rec.entry_id : undefined
-        }));
-        const result = await applyCuratorKnowledgeUpdates(directory, sanitizedRecs, knowledgeConfig);
+        const result = await applyCuratorKnowledgeUpdates(directory, typedArgs.recommendations, knowledgeConfig);
         applied = result.applied;
         skipped = result.skipped;
       }
@@ -62573,7 +62672,7 @@ init_dist();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -62642,14 +62741,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync36(swarmPath)) {
+  if (!existsSync37(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync36(hivePath)) {
+  if (!existsSync37(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);

package/dist/plan/ledger.d.ts

@@ -4,7 +4,7 @@
  * Provides durable, immutable audit trail of plan evolution events.
  * Each event is written as a JSON line to .swarm/plan-ledger.jsonl
  */
-import type { Plan } from '../config/plan-schema';
+import { type Plan } from '../config/plan-schema';
 /**
  * Ledger schema version
  */
@@ -108,7 +108,7 @@ export declare function readLedgerEvents(directory: string): Promise<LedgerEvent
  * @param directory - The working directory
  * @param planId - Unique identifier for the plan
  */
-export declare function initLedger(directory: string, planId: string): Promise<void>;
+export declare function initLedger(directory: string, planId: string, initialPlanHash?: string): Promise<void>;
 /**
  * Append a new event to the ledger.
  * Uses atomic write: write to temp file then rename.

package/dist/plan/manager.d.ts

@@ -5,6 +5,10 @@ import { type Plan, type TaskStatus } from '../config/plan-schema';
  * Use this when you want to check for structured plans without triggering migration.
  */
 export declare function loadPlanJsonOnly(directory: string): Promise<Plan | null>;
+/**
+ * Regenerate plan.md from valid plan.json (auto-heal case 1).
+ */
+export declare function regeneratePlanMarkdown(directory: string, plan: Plan): Promise<void>;
 /**
  * Load and validate plan from .swarm/plan.json with auto-heal sync.
  *
@@ -38,6 +42,14 @@ export declare function rebuildPlan(directory: string, plan?: Plan): Promise<Pla
 /**
  * Load plan → find task by ID → update status → save → return updated plan.
  * Throw if plan not found or task not found.
+ *
+ * Uses loadPlan() (not loadPlanJsonOnly) so that legitimate same-identity ledger
+ * drift is detected and healed before the status update is applied. Without this,
+ * a stale plan.json would silently overwrite ledger-ahead task state with only the
+ * one targeted status change applied on top.
+ *
+ * The migration guard in loadPlan() (plan_id identity check) prevents destructive
+ * revert after a swarm rename — so this is safe even in post-migration scenarios.
  */
 export declare function updateTaskStatus(directory: string, taskId: string, status: TaskStatus): Promise<Plan>;
 /**

package/dist/plan/manager.loadplan-validation-guard.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Tests for the migration-aware identity guard in loadPlan()'s validation-failure
+ * catch path (lines ~299-323 of manager.ts).
+ *
+ * When plan.json fails schema validation, the old code unconditionally called
+ * replayFromLedger(). This allowed a post-migration ledger (old identity) to
+ * overwrite a schema-invalid but correctly migrated plan.json.
+ *
+ * The fix: extract swarm+title from the raw JSON (even if schema validation
+ * fails), compare against the first ledger event's plan_id, and only replay
+ * when identities match.
+ */
+export {};

package/dist/plan/migration-revert.regression.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Regression tests for GitHub issues #383/#384:
+ * PlanSyncWorker Aggressively Reverts Plan Files
+ *
+ * These tests verify that the fixes introduced in the debug-issues-383-384 branch
+ * prevent the destructive revert behavior and related edge cases.
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "6.47.0",
+	"version": "6.47.2",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",