opencode-swarm 7.183.1 → 7.184.1

package/dist/cli/{index-z425p51d.js → index-7hvy33gc.js}

@@ -3,10 +3,10 @@ import {
   EvaluationRunV1Schema,
   GateAuditResultV1Schema,
   getProtectedEvaluationRunIds
-} from "./index-ydefv5fn.js";
+} from "./index-ya32wfkp.js";
 import {
   readEffectiveSpecSync
-} from "./index-4xr4gtwd.js";
+} from "./index-7p4ym4q3.js";
 import {
   validateWorkspaceRoot
 } from "./index-6b295cas.js";
@@ -16,20 +16,23 @@ import {
 import {
   GitBinaryMissingError,
   GitSpawnCwdError,
+  TASK_WORKFLOW_SCHEMA_MARKER,
+  deriveApplicableGateSet,
   isGitBinaryMissing,
   isSpawnCwdMissing,
   isSpawnCwdUnreadable,
   isValidTaskId,
+  readCurrentTaskDeclaredFiles,
   readTaskEvidence,
   readTaskEvidenceRaw,
   sanitizeTaskId
-} from "./index-908k7jhw.js";
+} from "./index-depfky1j.js";
 import {
   estimateCharsForTokens,
   estimateTokens,
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-nmh0s6dg.js";
+} from "./index-wy3zpwjy.js";
 import {
   bunHash,
   bunWrite,
@@ -58,10 +61,10 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-bqphhrwf.js";
+} from "./index-wfdx7yw2.js";
 import {
   appendCoreEventSync
-} from "./index-wpn7ftw1.js";
+} from "./index-jvk95e6y.js";
 import {
   derivePlanId,
   derivePlanIdentityHash,
@@ -69,23 +72,25 @@ import {
   importCoordinationOnce,
   listCoordinationStates,
   transitionCoordinationState
-} from "./index-3rb5gs4w.js";
+} from "./index-f0nj3d8z.js";
 import {
   DURABILITY_CLASSES,
   getProjectDb,
   projectDbExists,
   withDurabilityClass
-} from "./index-08x7gsnf.js";
+} from "./index-w9hxzcz4.js";
 import {
-  assertProjectRoot,
   withEvidenceLock
-} from "./index-dg3f2sqq.js";
+} from "./index-xf69xty9.js";
+import {
+  assertProjectRoot
+} from "./index-t7hmqgjy.js";
 import {
   emit
-} from "./index-tt705bap.js";
+} from "./index-x1gyqgze.js";
 import {
   canonicalRootKeyFresh
-} from "./index-1xnse449.js";
+} from "./index-mc72pk74.js";
 import {
   tryAcquireLock
 } from "./index-ejhxgyvm.js";
@@ -93,7 +98,7 @@ import {
   atomicWriteSwarmFileSync,
   invalidateCachedArtifact,
   readCachedParsedFile
-} from "./index-5cve9g2b.js";
+} from "./index-k53a69vb.js";
 import {
   PlanSchema,
   normalizeCurrentPhaseInPlace,
@@ -1723,6 +1728,13 @@ class PlanConcurrentModificationError extends Error {
   }
 }
 
+class PlanRecoverySupersededError extends Error {
+  constructor(message = "plan recovery superseded by a newer generation") {
+    super(message);
+    this.name = "PlanRecoverySupersededError";
+  }
+}
+
 class PlanTaskRemovalNotAcknowledgedError extends Error {
   missingTasks;
   constructor(missingTasks) {
@@ -1742,6 +1754,7 @@ var _internals5 = {
   readPlanJsonUtf8,
   readPlanFileUtf8,
   verifyWrittenPlanJson,
+  writeRebuildPlanMarkdown,
   ledgerExists,
   replayFromLedger,
   loadLastApprovedPlan,
@@ -1825,7 +1838,8 @@ async function retryCasWithBackoff(directory, eventInput, options) {
     try {
       return await appendLedgerEvent(directory, eventInput, {
         expectedHash: currentExpected,
-        planHashAfter: options.planHashAfter
+        planHashAfter: options.planHashAfter,
+        preCommitCheck: options.preCommitCheck
       });
     } catch (error2) {
       if (!(error2 instanceof LedgerStaleWriterError) || attempt >= maxRetries) {
@@ -1882,7 +1896,7 @@ async function getLatestLedgerHash(directory) {
     return "";
   }
 }
-async function surfaceLedgerStaleIfPersisted(directory, plan) {
+async function surfaceLedgerStaleIfPersisted(directory, plan, options) {
   const resolvedWorkspace = canonicalRootKeyFresh(directory);
   if (!ledgerStaleWorkspaces.has(resolvedWorkspace)) {
     return plan;
@@ -1891,10 +1905,14 @@ async function surfaceLedgerStaleIfPersisted(directory, plan) {
     const planHash = computePlanLedgerHash(plan);
     const ledgerHash = await getLatestLedgerHash(directory);
     if (ledgerHash !== "" && planHash === ledgerHash) {
+      options?.preCommitCheck?.();
       ledgerStaleWorkspaces.delete(resolvedWorkspace);
       return plan;
     }
-  } catch {}
+  } catch (error2) {
+    if (error2 instanceof PlanRecoverySupersededError)
+      throw error2;
+  }
   plan._ledgerReplayStale = true;
   if (typeof plan._ledgerReplayStaleReason !== "string" || plan._ledgerReplayStaleReason.length === 0) {
     plan._ledgerReplayStaleReason = "plan.json still hash-mismatches the ledger after a startup ledger-replay failure (replay could not be applied and no critic-approved snapshot was available). Run /swarm reset-session if this persists.";
@@ -1968,7 +1986,7 @@ async function isPlanMdInSync(directory, plan, cache) {
   }
   return false;
 }
-async function regeneratePlanMarkdown(directory, plan) {
+async function regeneratePlanMarkdown(directory, plan, options) {
   assertProjectRoot(directory);
   const swarmDir = path3.resolve(directory, ".swarm");
   const contentHash = computePlanContentHash(plan);
@@ -1979,6 +1997,7 @@ ${markdown}`;
   const mdTempPath = path3.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(mdTempPath, markdownWithHash);
+    options?.preCommitCheck?.();
     renameSync2(mdTempPath, mdPath);
   } finally {
     try {
@@ -1987,8 +2006,10 @@ ${markdown}`;
   }
   invalidateCachedArtifact(mdPath);
 }
-async function loadPlan(directory, cache) {
+async function loadPlan(directory, cache, options) {
+  options?.preCommitCheck?.();
   let planJsonContent = null;
+  let claimedStartupWorkspace = null;
   try {
     planJsonContent = await _internals5.readPlanJsonUtf8(directory);
   } catch (error2) {
@@ -2006,8 +2027,12 @@ async function loadPlan(directory, cache) {
           const inSync = await isPlanMdInSync(directory, validated, cache);
           if (!inSync) {
             try {
-              await _internals5.regeneratePlanMarkdown(directory, validated);
+              await _internals5.regeneratePlanMarkdown(directory, validated, {
+                preCommitCheck: options?.preCommitCheck
+              });
             } catch (regenError) {
+              if (regenError instanceof PlanRecoverySupersededError)
+                throw regenError;
               warn(`Failed to regenerate plan.md: ${regenError instanceof Error ? regenError.message : String(regenError)}. Proceeding with plan.json only.`);
             }
           }
@@ -2016,7 +2041,9 @@ async function loadPlan(directory, cache) {
             const ledgerHash = await getLatestLedgerHash(directory);
             const resolvedWorkspace = canonicalRootKeyFresh(directory);
             if (!startupLedgerCheckedWorkspaces.has(resolvedWorkspace)) {
+              options?.preCommitCheck?.();
               startupLedgerCheckedWorkspaces.add(resolvedWorkspace);
+              claimedStartupWorkspace = resolvedWorkspace;
               if (ledgerHash !== "" && planHash !== ledgerHash) {
                 const currentPlanId = derivePlanId(validated);
                 const ledgerEvents = await readLedgerEvents(directory);
@@ -2026,46 +2053,60 @@ 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 { plan: rebuilt, truncated } = await replayFromLedgerWithStatus(directory);
+                    const { plan: rebuilt, truncated } = await replayFromLedgerWithStatus(directory, {
+                      preCommitCheck: options?.preCommitCheck
+                    });
                     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.";
+                      options?.preCommitCheck?.();
                       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"
+                        reason: "ledger_hash_mismatch_recovery",
+                        preCommitCheck: options?.preCommitCheck
                       });
                       warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/plan-export/SWARM_PLAN.md if it exists.");
                       return rebuilt;
                     }
                   } catch (replayError) {
+                    if (replayError instanceof PlanRecoverySupersededError)
+                      throw replayError;
                     try {
                       const approved = await loadLastApprovedPlan(directory, currentPlanId);
                       if (approved) {
                         await rebuildPlan(directory, approved.plan, {
-                          reason: "approved_snapshot_fallback"
+                          reason: "approved_snapshot_fallback",
+                          preCommitCheck: options?.preCommitCheck
                         });
                         try {
                           await takeSnapshotEvent(directory, approved.plan, {
                             source: "recovery_from_approved_snapshot",
-                            approvalMetadata: approved.approval
+                            approvalMetadata: approved.approval,
+                            preCommitCheck: options?.preCommitCheck
                           });
                         } catch (healError) {
+                          if (healError instanceof PlanRecoverySupersededError)
+                            throw healError;
                           warn(`[loadPlan] Recovery-heal snapshot append failed: ${healError instanceof Error ? healError.message : String(healError)}. Next loadPlan may re-enter recovery path.`);
                         }
                         const approvedPhase = approved.approval && typeof approved.approval === "object" && "phase" in approved.approval ? approved.approval.phase : undefined;
                         warn(`[loadPlan] Ledger replay failed (${replayError instanceof Error ? replayError.message : String(replayError)}) \u2014 recovered from critic-approved snapshot seq=${approved.seq} (approval phase=${approvedPhase ?? "unknown"}, timestamp=${approved.timestamp}). This may roll the plan back to an earlier phase \u2014 verify before continuing.`);
                         return approved.plan;
                       }
-                    } catch {}
+                    } catch (recoveryError) {
+                      if (recoveryError instanceof PlanRecoverySupersededError)
+                        throw recoveryError;
+                    }
                     {
                       const runtimeStale = validated;
                       runtimeStale._ledgerReplayStale = true;
                       runtimeStale._ledgerReplayStaleReason = `Ledger replay failed during hash-mismatch rebuild and no approved snapshot was available: ${replayError instanceof Error ? replayError.message : String(replayError)}`;
+                      options?.preCommitCheck?.();
                       ledgerStaleWorkspaces.add(resolvedWorkspace);
                     }
                     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-export/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
@@ -2090,7 +2131,7 @@ async function loadPlan(directory, cache) {
                   assertProjectRoot(directory);
                   const diffInfo = computeSpecDiff(directory);
                   const specStalenessPath = path3.join(directory, ".swarm", "spec-staleness.json");
-                  await fsPromises.writeFile(specStalenessPath, JSON.stringify({
+                  await commitAsyncPreparedFile(specStalenessPath, JSON.stringify({
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
                     phase: validated.current_phase ?? 1,
@@ -2100,9 +2141,12 @@ async function loadPlan(directory, cache) {
                     planTitle: validated.title,
                     diff: diffInfo?.diff ?? null,
                     changedSections: diffInfo?.changedSections ?? []
-                  }, null, 2), "utf-8");
+                  }, null, 2), options?.preCommitCheck, "spec-staleness");
                   invalidateCachedArtifact(specStalenessPath);
-                } catch {}
+                } catch (error2) {
+                  if (error2 instanceof PlanRecoverySupersededError)
+                    throw error2;
+                }
                 try {
                   assertProjectRoot(directory);
                   const event = {
@@ -2114,22 +2158,35 @@ async function loadPlan(directory, cache) {
                     reason: staleResult.reason ?? "unknown",
                     planTitle: validated.title
                   };
+                  options?.preCommitCheck?.();
                   appendCoreEventSync(directory, { ...event });
-                } catch {}
+                } catch (error2) {
+                  if (error2 instanceof PlanRecoverySupersededError)
+                    throw error2;
+                }
               }
             }
           }
-          return await surfaceLedgerStaleIfPersisted(directory, validated);
+          return await surfaceLedgerStaleIfPersisted(directory, validated, options);
         }
       } catch (error2) {
+        if (error2 instanceof PlanRecoverySupersededError) {
+          if (claimedStartupWorkspace !== null) {
+            startupLedgerCheckedWorkspaces.delete(claimedStartupWorkspace);
+          }
+          throw error2;
+        }
         warn(`[loadPlan] plan.json validation failed: ${error2 instanceof Error ? error2.message : String(error2)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/plan-export/SWARM_PLAN.md for a checkpoint.`);
         let rawPlanId = null;
+        let rawPlanJsonParseFailed = false;
         try {
           const rawParsed = JSON.parse(planJsonContent);
           if (typeof rawParsed?.swarm === "string" && typeof rawParsed?.title === "string") {
             rawPlanId = derivePlanId(rawParsed);
           }
-        } catch {}
+        } catch {
+          rawPlanJsonParseFailed = true;
+        }
         if (await _internals5.ledgerExists(directory)) {
           const catchIntegrity = await _internals5.readLedgerEventsWithIntegrity(directory);
           const ledgerEventsForCatch = catchIntegrity.events;
@@ -2137,16 +2194,21 @@ async function loadPlan(directory, cache) {
           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) {
+          } else if (catchFirstEvent !== null && (rawPlanId !== null || rawPlanJsonParseFailed && !catchIntegrity.truncated)) {
             let rebuilt = null;
             try {
-              rebuilt = await _internals5.replayFromLedger(directory);
+              rebuilt = await _internals5.replayFromLedger(directory, {
+                preCommitCheck: options?.preCommitCheck
+              });
             } catch (replayError) {
+              if (replayError instanceof PlanRecoverySupersededError)
+                throw replayError;
               warn(`[loadPlan] Ledger replay threw in validation-failure path: ${replayError instanceof Error ? replayError.message : String(replayError)}. Falling back to critic-approved snapshot before legacy migration.`);
             }
             if (rebuilt) {
               await rebuildPlan(directory, rebuilt, {
-                reason: "validation_failure_recovery"
+                reason: "validation_failure_recovery",
+                preCommitCheck: options?.preCommitCheck
               });
               warn("[loadPlan] Rebuilt plan from ledger after validation failure. Projection was stale.");
               return rebuilt;
@@ -2154,7 +2216,7 @@ async function loadPlan(directory, cache) {
             try {
               const approved = await _internals5.loadLastApprovedPlan(directory, catchFirstEvent.plan_id);
               if (approved) {
-                const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, approved.plan, "load_plan_recovery_from_approved_snapshot", "restore from critic-approved snapshot");
+                const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, approved.plan, "load_plan_recovery_from_approved_snapshot", "restore from critic-approved snapshot", { preCommitCheck: options?.preCommitCheck });
                 if (removedCount > 0) {
                   approved.plan._midLoadRemovals = {
                     count: removedCount,
@@ -2164,15 +2226,20 @@ async function loadPlan(directory, cache) {
                 try {
                   await takeSnapshotEvent(directory, approved.plan, {
                     source: "recovery_from_approved_snapshot",
-                    approvalMetadata: approved.approval
+                    approvalMetadata: approved.approval,
+                    preCommitCheck: options?.preCommitCheck
                   });
                 } catch (healError) {
+                  if (healError instanceof PlanRecoverySupersededError)
+                    throw healError;
                   warn(`[loadPlan] Recovery-heal snapshot append failed: ${healError instanceof Error ? healError.message : String(healError)}. Next loadPlan may re-enter recovery path.`);
                 }
                 warn(`[loadPlan] Recovered from critic-approved snapshot seq=${approved.seq} after validation failure with exhausted ledger replay (approved snapshot beats lossy Markdown migration).`);
                 return approved.plan;
               }
             } catch (approvedError) {
+              if (approvedError instanceof PlanRecoverySupersededError)
+                throw approvedError;
               warn(`[loadPlan] Approved-snapshot recovery failed in validation-failure path: ${approvedError instanceof Error ? approvedError.message : String(approvedError)}`);
             }
           }
@@ -2180,14 +2247,14 @@ async function loadPlan(directory, cache) {
         const planMdContent2 = await readSwarmFileAsync(directory, "plan.md", cache);
         if (planMdContent2 !== null) {
           const migrated = migrateLegacyPlan(planMdContent2);
-          const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, migrated, "load_plan_migration_from_md", "migrate legacy plan.md to plan.json");
+          const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, migrated, "load_plan_migration_from_md", "migrate legacy plan.md to plan.json", { preCommitCheck: options?.preCommitCheck });
           if (removedCount > 0) {
             migrated._midLoadRemovals = {
               count: removedCount,
               source: "load_plan_migration_from_md"
             };
           }
-          await appendMigrationProvenanceEvent(directory, migrated);
+          await appendMigrationProvenanceEvent(directory, migrated, options?.preCommitCheck);
           return migrated;
         }
       }
@@ -2210,12 +2277,16 @@ async function loadPlan(directory, cache) {
     try {
       let rebuilt = null;
       try {
-        rebuilt = await _internals5.replayFromLedger(directory);
+        rebuilt = await _internals5.replayFromLedger(directory, {
+          preCommitCheck: options?.preCommitCheck
+        });
       } catch (replayError) {
+        if (replayError instanceof PlanRecoverySupersededError)
+          throw replayError;
         warn(`[loadPlan] Ledger replay threw in missing-projection path: ${replayError instanceof Error ? replayError.message : String(replayError)}. Falling back to critic-approved snapshot before legacy migration.`);
       }
       if (rebuilt) {
-        const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, rebuilt, "load_plan_rebuild_from_ledger", "rebuild plan from ledger replay");
+        const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, rebuilt, "load_plan_rebuild_from_ledger", "rebuild plan from ledger replay", { preCommitCheck: options?.preCommitCheck });
         if (removedCount > 0) {
           rebuilt._midLoadRemovals = {
             count: removedCount,
@@ -2236,7 +2307,7 @@ async function loadPlan(directory, cache) {
         if (approved) {
           const approvedPhase = approved.approval && typeof approved.approval === "object" && "phase" in approved.approval ? approved.approval.phase : undefined;
           warn(`[loadPlan] Ledger replay returned no plan \u2014 recovered from critic-approved snapshot seq=${approved.seq} timestamp=${approved.timestamp} (approval phase=${approvedPhase ?? "unknown"}). This may roll the plan back to an earlier phase \u2014 verify before continuing.`);
-          const { removedCount: snapshotRemovedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, approved.plan, "load_plan_recovery_from_approved_snapshot", "restore from critic-approved snapshot");
+          const { removedCount: snapshotRemovedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, approved.plan, "load_plan_recovery_from_approved_snapshot", "restore from critic-approved snapshot", { preCommitCheck: options?.preCommitCheck });
           if (snapshotRemovedCount > 0) {
             approved.plan._midLoadRemovals = {
               count: snapshotRemovedCount,
@@ -2246,14 +2317,19 @@ async function loadPlan(directory, cache) {
           try {
             await takeSnapshotEvent(directory, approved.plan, {
               source: "recovery_from_approved_snapshot",
-              approvalMetadata: approved.approval
+              approvalMetadata: approved.approval,
+              preCommitCheck: options?.preCommitCheck
             });
           } catch (healError) {
+            if (healError instanceof PlanRecoverySupersededError)
+              throw healError;
             warn(`[loadPlan] Recovery-heal snapshot append failed: ${healError instanceof Error ? healError.message : String(healError)}. Next loadPlan may re-enter recovery path.`);
           }
           return approved.plan;
         }
       } catch (recoveryError) {
+        if (recoveryError instanceof PlanRecoverySupersededError)
+          throw recoveryError;
         warn(`[loadPlan] Approved-snapshot recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
       }
     } finally {
@@ -2264,14 +2340,14 @@ async function loadPlan(directory, cache) {
   const planMdContent = await readSwarmFileAsync(directory, "plan.md", cache);
   if (planMdContent !== null) {
     const migrated = migrateLegacyPlan(planMdContent);
-    const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, migrated, "load_plan_migration_from_md", "migrate legacy plan.md to plan.json");
+    const { removedCount } = await savePlanWithAutoAcknowledgedRemovals(directory, migrated, "load_plan_migration_from_md", "migrate legacy plan.md to plan.json", { preCommitCheck: options?.preCommitCheck });
     if (removedCount > 0) {
       migrated._midLoadRemovals = {
         count: removedCount,
         source: "load_plan_migration_from_md"
       };
     }
-    await appendMigrationProvenanceEvent(directory, migrated);
+    await appendMigrationProvenanceEvent(directory, migrated, options?.preCommitCheck);
     return migrated;
   }
   return null;
@@ -2347,8 +2423,9 @@ async function verifyWrittenPlanJson(directory, expected) {
     throw new PlanWriteVerificationError("PLAN_WRITE_VERIFICATION_FAILED: plan.json read-back content differs from the projected plan");
   }
 }
-async function appendMigrationProvenanceEvent(directory, plan) {
+async function appendMigrationProvenanceEvent(directory, plan, preCommitCheck) {
   try {
+    preCommitCheck?.();
     await appendLedgerEvent(directory, {
       event_type: "plan_rebuilt",
       source: "load_plan_migration_from_md",
@@ -2358,8 +2435,10 @@ async function appendMigrationProvenanceEvent(directory, plan) {
         phases_count: plan.phases.length,
         tasks_count: plan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0)
       }
-    });
+    }, { preCommitCheck });
   } catch (error2) {
+    if (error2 instanceof PlanRecoverySupersededError)
+      throw error2;
     warn(`[loadPlan] Markdown-migration provenance event append failed (plan remains migrated): ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
 }
@@ -2420,7 +2499,9 @@ async function savePlan(directory, plan, options) {
   if (!await ledgerExists(directory)) {
     try {
       options?.preCommitCheck?.();
-      await initLedger(directory, planId, planHashForInit, validated);
+      await initLedger(directory, planId, planHashForInit, validated, {
+        preCommitCheck: options?.preCommitCheck
+      });
     } catch (initErr) {
       const msg = initErr instanceof Error ? initErr.message : String(initErr);
       if (!/already initialized/i.test(msg)) {
@@ -2431,7 +2512,7 @@ async function savePlan(directory, plan, options) {
     const existingEvents = await readLedgerEvents(directory);
     if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
       options?.preCommitCheck?.();
-      await replacePlanLedgerWithRoot(directory, validated, "savePlan_identity_migration");
+      await replacePlanLedgerWithRoot(directory, validated, "savePlan_identity_migration", { preCommitCheck: options?.preCommitCheck });
       warn(`[savePlan] Ledger identity mismatch (was "${existingEvents[0].plan_id}", now "${planId}") \u2014 archived the prior exact history and committed a new root.`);
     }
   }
@@ -2530,6 +2611,7 @@ async function savePlan(directory, plan, options) {
           await retryCasWithBackoff(directory, eventInput, {
             expectedHash: currentHash,
             planHashAfter: hashAfter,
+            preCommitCheck: options?.preCommitCheck,
             verifyValid: async () => {
               const onDisk = await _internals5.loadPlanJsonOnly(directory);
               if (!onDisk)
@@ -2569,6 +2651,7 @@ async function savePlan(directory, plan, options) {
             await retryCasWithBackoff(directory, eventInput, {
               expectedHash: currentHash,
               planHashAfter: hashAfter,
+              preCommitCheck: options?.preCommitCheck,
               verifyValid: async () => {
                 const onDisk = await _internals5.loadPlanJsonOnly(directory);
                 if (!onDisk)
@@ -2593,13 +2676,16 @@ async function savePlan(directory, plan, options) {
     }
   }
   const ledgerStatusTaskIds = collectLedgerStatusTaskIds(await readLedgerEvents(directory));
-  const replayedBeforeProjection = await _internals5.replayFromLedger(directory);
+  const replayedBeforeProjection = await _internals5.replayFromLedger(directory, {
+    preCommitCheck: options?.preCommitCheck
+  });
   const projectionCandidate = replayedBeforeProjection ? mergeStatusesTakingPrecedence(validated, replayedBeforeProjection, ledgerStatusTaskIds) : validated;
   if (replayedBeforeProjection && computePlanLedgerHash(replayedBeforeProjection) !== computePlanLedgerHash(projectionCandidate)) {
     options?.preCommitCheck?.();
     await takeSnapshotEvent(directory, projectionCandidate, {
       planHashAfter: computePlanLedgerHash(projectionCandidate),
-      source: "savePlan_structural_projection"
+      source: "savePlan_structural_projection",
+      preCommitCheck: options?.preCommitCheck
     });
   }
   const projectedPlan = projectionCandidate;
@@ -2634,8 +2720,11 @@ async function savePlan(directory, plan, options) {
       tasks_count: projectedPlan.phases.reduce((sum, p) => sum + p.tasks.length, 0),
       in_progress: true
     });
-    await bunWrite(markerPath, inProgressMarker);
-  } catch {}
+    await commitAsyncPreparedFile(markerPath, inProgressMarker, options?.preCommitCheck, "plan-write-marker");
+  } catch (error2) {
+    if (error2 instanceof PlanRecoverySupersededError)
+      throw error2;
+  }
   let mdWriteError;
   try {
     const contentHash = computePlanContentHash(projectedPlan);
@@ -2646,6 +2735,7 @@ ${markdown}`;
     const mdTempPath = path3.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await bunWrite(mdTempPath, markdownWithHash);
+      options?.preCommitCheck?.();
       renameSync2(mdTempPath, mdPath);
     } finally {
       try {
@@ -2654,6 +2744,8 @@ ${markdown}`;
     }
     invalidateCachedArtifact(mdPath);
   } catch (mdError) {
+    if (mdError instanceof PlanRecoverySupersededError)
+      throw mdError;
     const message = mdError instanceof Error ? mdError.message : String(mdError);
     mdWriteError = message;
     warn(`[savePlan] plan.md write failed (non-fatal, plan.json is authoritative): ${message}`);
@@ -2675,8 +2767,11 @@ ${markdown}`;
       tasks_count: tasksCount,
       in_progress: false
     });
-    await bunWrite(markerPath, marker);
-  } catch {}
+    await commitAsyncPreparedFile(markerPath, marker, options?.preCommitCheck, "plan-write-marker");
+  } catch (error2) {
+    if (error2 instanceof PlanRecoverySupersededError)
+      throw error2;
+  }
   if (currentPlan) {
     try {
       const oldIdentityHash = derivePlanIdentityHash(currentPlan);
@@ -2695,16 +2790,20 @@ ${markdown}`;
         for (const [taskId, oldStatus] of oldStatuses) {
           const newStatus = newStatuses.get(taskId);
           if (oldStatus === "completed" && newStatus !== "completed") {
+            options?.preCommitCheck?.();
             advanceTaskCheckpointReceiptGeneration(directory, oldIdentityHash, taskId);
           }
         }
         for (const [taskId, newStatus] of newStatuses) {
           if (newStatus === "completed" && oldStatuses.get(taskId) !== "completed") {
+            options?.preCommitCheck?.();
             repairTaskCheckpointReceiptForCompletion(directory, newIdentityHash, taskId);
           }
         }
       }
     } catch (receiptError) {
+      if (receiptError instanceof PlanRecoverySupersededError)
+        throw receiptError;
       warn(`[savePlan] task checkpoint receipt lifecycle sync failed (plan remains authoritative): ${receiptError instanceof Error ? receiptError.message : String(receiptError)}`);
     }
   }
@@ -2717,27 +2816,53 @@ ${markdown}`;
   }
   return { durability: "complete", degraded_surfaces: [] };
 }
+async function commitAsyncPreparedFile(targetPath, content, preCommitCheck, tempLabel = "atomic") {
+  const tempPath = `${targetPath}.${tempLabel}.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+  try {
+    await bunWrite(tempPath, content);
+    preCommitCheck?.();
+    renameSync2(tempPath, targetPath);
+  } catch (error2) {
+    try {
+      unlinkSync(tempPath);
+    } catch {}
+    throw error2;
+  }
+}
+async function writeRebuildPlanMarkdown(tempPath, content) {
+  await bunWrite(tempPath, content);
+}
 async function rebuildPlan(directory, plan, options) {
   assertProjectRoot(directory);
-  const targetPlan = plan ?? await replayFromLedger(directory);
+  const targetPlan = plan ?? await replayFromLedger(directory, {
+    preCommitCheck: options?.preCommitCheck
+  });
   if (!targetPlan)
     return null;
+  options?.preCommitCheck?.();
   const swarmDir = path3.join(directory, ".swarm");
   const planPath = path3.join(swarmDir, "plan.json");
   const mdPath = path3.join(swarmDir, "plan.md");
   mkdirSync2(swarmDir, { recursive: true });
   const tempPlanPath = path3.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
-  {
-    const fd = openSync(tempPlanPath, "w");
-    try {
-      writeFileSync(fd, JSON.stringify(targetPlan, null, 2), "utf8");
-      fsyncSync(fd);
-    } finally {
-      closeSync(fd);
+  try {
+    {
+      const fd = openSync(tempPlanPath, "w");
+      try {
+        writeFileSync(fd, JSON.stringify(targetPlan, null, 2), "utf8");
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
     }
+    options?.preCommitCheck?.();
+    renameSync2(tempPlanPath, planPath);
+    invalidateCachedArtifact(planPath);
+  } finally {
+    try {
+      unlinkSync(tempPlanPath);
+    } catch {}
   }
-  renameSync2(tempPlanPath, planPath);
-  invalidateCachedArtifact(planPath);
   try {
     const markerPath = path3.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
@@ -2747,17 +2872,33 @@ async function rebuildPlan(directory, plan, options) {
       tasks_count: targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0),
       in_progress: true
     });
-    await bunWrite(markerPath, inProgressMarker);
-  } catch {}
+    await commitAsyncPreparedFile(markerPath, inProgressMarker, options?.preCommitCheck, "rebuild");
+  } catch (error2) {
+    if (error2 instanceof PlanRecoverySupersededError)
+      throw error2;
+  }
+  let markdownWriteFailed = false;
+  let markdownWriteError;
+  let markerSupersededError;
   try {
     const contentHash = computePlanContentHash(targetPlan);
     const markdown = derivePlanMarkdown(targetPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
     const tempMdPath = path3.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
-    await bunWrite(tempMdPath, markdownWithHash);
-    renameSync2(tempMdPath, mdPath);
-    invalidateCachedArtifact(mdPath);
+    try {
+      await _internals5.writeRebuildPlanMarkdown(tempMdPath, markdownWithHash);
+      options?.preCommitCheck?.();
+      renameSync2(tempMdPath, mdPath);
+      invalidateCachedArtifact(mdPath);
+    } finally {
+      try {
+        unlinkSync(tempMdPath);
+      } catch {}
+    }
+  } catch (error2) {
+    markdownWriteFailed = true;
+    markdownWriteError = error2;
   } finally {
     try {
       const markerPath = path3.join(swarmDir, ".plan-write-marker");
@@ -2769,10 +2910,23 @@ ${markdown}`;
         tasks_count: tasksCount,
         in_progress: false
       });
-      await bunWrite(markerPath, marker);
-    } catch {}
+      await commitAsyncPreparedFile(markerPath, marker, options?.preCommitCheck, "rebuild");
+    } catch (error2) {
+      if (error2 instanceof PlanRecoverySupersededError) {
+        markerSupersededError = error2;
+      }
+    }
+  }
+  if (markerSupersededError)
+    throw markerSupersededError;
+  if (markdownWriteFailed) {
+    if (markdownWriteError instanceof PlanRecoverySupersededError)
+      throw markdownWriteError;
+    const message = markdownWriteError instanceof Error ? markdownWriteError.message : String(markdownWriteError);
+    warn(`[rebuildPlan] plan.md projection write failed (non-fatal; plan.json is authoritative): ${message}`.slice(0, 512));
   }
   try {
+    options?.preCommitCheck?.();
     const planId = derivePlanId(targetPlan);
     const planHashAfter = computePlanLedgerHash(targetPlan);
     await appendLedgerEvent(directory, {
@@ -2784,8 +2938,11 @@ ${markdown}`;
         phases_count: targetPlan.phases.length,
         tasks_count: targetPlan.phases.reduce((sum, p) => sum + p.tasks.length, 0)
       }
-    }, { planHashAfter });
-  } catch {}
+    }, { planHashAfter, preCommitCheck: options?.preCommitCheck });
+  } catch (error2) {
+    if (error2 instanceof PlanRecoverySupersededError)
+      throw error2;
+  }
   return targetPlan;
 }
 async function closePlanTerminalState(directory, plan, options) {
@@ -2940,7 +3097,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
       if (status === "completed") {
         try {
           const completedTask = updatedPlan.phases.flatMap((phase) => phase.tasks).find((candidate) => candidate.id === taskId);
-          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-vkqn317p.js");
+          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-j407j8ew.js");
           await maybePropagateSpeckitCheckoff(directory, {
             taskId,
             frRefs: completedTask?.fr_refs ?? [],
@@ -2965,7 +3122,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
               break;
             }
           }
-          const { readDeclaredScopeFilesFromBindings } = await import("./scope-persistence-sc2zhr15.js");
+          const { readDeclaredScopeFilesFromBindings } = await import("./scope-persistence-rmt56rma.js");
           const canonicalScope = readDeclaredScopeFilesFromBindings({
             directory,
             taskId,
@@ -4082,7 +4239,7 @@ function getDurableGateEvidenceStatus(evidence) {
       invalid: false
     };
   }
-  if (!Array.isArray(evidence.required_gates) || evidence.required_gates.length === 0) {
+  if (!Array.isArray(evidence.required_gates)) {
     return {
       isComplete: false,
       missingGates: ["required_gates"],
@@ -4090,10 +4247,10 @@ function getDurableGateEvidenceStatus(evidence) {
       invalid: false
     };
   }
-  const missingGates = evidence.required_gates.filter((gate) => evidence.gates[gate] == null);
+  const derivedGates = deriveApplicableGateSet(evidence);
   return {
-    isComplete: missingGates.length === 0,
-    missingGates,
+    isComplete: derivedGates.missingGates.length === 0,
+    missingGates: derivedGates.missingGates,
     evidenceExists: true,
     invalid: false
   };
@@ -4108,7 +4265,7 @@ async function getDurableGateEvidenceStatusForTask(directory, taskId) {
     };
   }
   try {
-    return getDurableGateEvidenceStatus(readTaskEvidenceRaw(directory, taskId));
+    return getDurableGateEvidenceStatusWithCurrentScope(readTaskEvidenceRaw(directory, taskId), directory, taskId);
   } catch {
     return {
       isComplete: false,
@@ -4118,6 +4275,40 @@ async function getDurableGateEvidenceStatusForTask(directory, taskId) {
     };
   }
 }
+function getDurableGateEvidenceStatusWithCurrentScope(evidence, directory, taskId) {
+  if (!evidence?.gates || typeof evidence.gates !== "object") {
+    return getDurableGateEvidenceStatus(evidence);
+  }
+  if (!Array.isArray(evidence.required_gates)) {
+    return getDurableGateEvidenceStatus(evidence);
+  }
+  if (!evidence.workflow || evidence.workflow.schema !== TASK_WORKFLOW_SCHEMA_MARKER) {
+    if (evidence.required_gates.length === 0) {
+      return {
+        isComplete: false,
+        missingGates: ["required_gates"],
+        evidenceExists: true,
+        invalid: false
+      };
+    }
+    const missingGates = evidence.required_gates.filter((gate) => evidence.gates[gate] == null);
+    return {
+      isComplete: missingGates.length === 0,
+      missingGates,
+      evidenceExists: true,
+      invalid: false
+    };
+  }
+  const derivedGates = deriveApplicableGateSet(evidence, {
+    currentDeclaredFiles: readCurrentTaskDeclaredFiles(directory, taskId)
+  });
+  return {
+    isComplete: derivedGates.missingGates.length === 0,
+    missingGates: derivedGates.missingGates,
+    evidenceExists: true,
+    invalid: false
+  };
+}
 function gateEvidenceToEntry(taskId, gate, type, evidence) {
   const gateRecord = evidence.gates[gate];
   if (!gateRecord) {
@@ -4171,4 +4362,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, readLaneEnvFileFromDiskSync, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, detectDefaultRemoteBranch, resetToRemoteBranch, resetToMainAfterMerge, sanitizeContextText, getRunMemorySummary, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, loadPlanJsonOnly, loadPlan, withPlanLifecycleLock, savePlan, closePlanTerminalState, updateTaskStatus, derivePlanMarkdown, getCurrentTaskId, isValidEvidenceType, isSecretscanEvidence, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, _internals7 as _internals, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, readLaneEnvFileFromDiskSync, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, detectDefaultRemoteBranch, resetToRemoteBranch, resetToMainAfterMerge, sanitizeContextText, getRunMemorySummary, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, PlanRecoverySupersededError, loadPlanJsonOnly, loadPlan, withPlanLifecycleLock, savePlan, closePlanTerminalState, updateTaskStatus, derivePlanMarkdown, getCurrentTaskId, isValidEvidenceType, isSecretscanEvidence, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, _internals7 as _internals, readDurableGateEvidence, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };