opencode-swarm 7.140.4 → 7.140.5

package/dist/cli/{index-wk8s1m7b.js → index-wrb0gykj.js}

@@ -2,12 +2,13 @@
 import {
   assertProjectRoot,
   withEvidenceLock
-} from "./index-35qep0v7.js";
+} from "./index-912qz4y0.js";
 import {
   ExecutionProfileSchema,
   PlanSchema,
-  TaskStatusSchema
-} from "./index-d181x9zr.js";
+  TaskStatusSchema,
+  init_loader
+} from "./index-nwrwy8eb.js";
 import {
   criticalWarn,
   init_logger,
@@ -15,7 +16,7 @@ import {
 } from "./index-zgwm4ryv.js";
 import {
   emit
-} from "./index-bfhwtdsw.js";
+} from "./index-epvhf50h.js";
 
 // src/plan/utils.ts
 import { createHash } from "crypto";
@@ -31,6 +32,20 @@ import * as crypto from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 init_logger();
+
+// src/plan/planning-profile.ts
+init_loader();
+function normalizeExecutionProfileForHash(profile) {
+  if (!profile) {
+    return;
+  }
+  return {
+    ...profile,
+    commit_after_each_completed_task: profile.commit_after_each_completed_task === true ? true : undefined
+  };
+}
+
+// src/plan/ledger.ts
 var LEDGER_SCHEMA_VERSION = "1.1.0";
 var LEDGER_FILENAME = "plan-ledger.jsonl";
 var LEDGER_LOCK_PATH = path.join(".swarm", LEDGER_FILENAME);
@@ -58,6 +73,45 @@ function writeFileFsyncedThenRename(tempPath, targetPath, data) {
   }
   fs.renameSync(tempPath, targetPath);
 }
+function fsyncRecoveryDirectory(directory) {
+  let fd;
+  try {
+    fd = fs.openSync(directory, "r");
+    fs.fsyncSync(fd);
+  } catch (error) {
+    const code = error.code;
+    const unsupportedOnWindows = process.platform === "win32" && ["EPERM", "EACCES", "EINVAL", "EBADF", "EISDIR", "ENOTSUP"].includes(code ?? "");
+    if (unsupportedOnWindows) {
+      log(`[ledger] Directory fsync unavailable for recovery archive ${directory}: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    throw new Error(`Failed to fsync recovery archive directory before canonical replacement: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    if (fd !== undefined)
+      fs.closeSync(fd);
+  }
+}
+function findRawMalformedSuffix(content) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let lineStart = 0;
+  for (let index = 0;index <= content.length; index++) {
+    if (index < content.length && content[index] !== 10)
+      continue;
+    let lineEnd = index;
+    if (lineEnd > lineStart && content[lineEnd - 1] === 13)
+      lineEnd--;
+    const line = content.subarray(lineStart, lineEnd);
+    if (line.length > 0) {
+      try {
+        JSON.parse(decoder.decode(line));
+      } catch {
+        return content.subarray(lineStart);
+      }
+    }
+    lineStart = index + 1;
+  }
+  return Buffer.alloc(0);
+}
 function computePlanHash(plan) {
   const normalized = {
     schema_version: plan.schema_version,
@@ -65,10 +119,7 @@ function computePlanHash(plan) {
     swarm: plan.swarm,
     current_phase: plan.current_phase,
     migration_status: plan.migration_status,
-    execution_profile: plan.execution_profile ? {
-      ...plan.execution_profile,
-      commit_after_each_completed_task: plan.execution_profile.commit_after_each_completed_task === true ? true : undefined
-    } : undefined,
+    execution_profile: normalizeExecutionProfileForHash(plan.execution_profile),
     phases: plan.phases.map((phase) => ({
       id: phase.id,
       name: phase.name,
@@ -98,10 +149,7 @@ function computePlanStructureHash(plan) {
     swarm: plan.swarm,
     current_phase: plan.current_phase,
     migration_status: plan.migration_status,
-    execution_profile: plan.execution_profile ? {
-      ...plan.execution_profile,
-      commit_after_each_completed_task: plan.execution_profile.commit_after_each_completed_task === true ? true : undefined
-    } : undefined,
+    execution_profile: normalizeExecutionProfileForHash(plan.execution_profile),
     phases: plan.phases.map((phase) => ({
       id: phase.id,
       name: phase.name,
@@ -232,8 +280,20 @@ async function appendLedgerEvent(directory, eventInput, options) {
   assertProjectRoot(directory);
   return withEvidenceLock(directory, LEDGER_LOCK_PATH, "plan-ledger", "append-ledger-event", async () => {
     const ledgerPath = getLedgerPath(directory);
+    if (options?.expectedLedgerHash !== undefined && options.expectedSeq === undefined) {
+      throw new Error("expectedLedgerHash requires expectedSeq so stale-projection recovery is bound to one exact ledger tail");
+    }
     const latestSeq = await getLatestLedgerSeq(directory);
     const nextSeq = latestSeq + 1;
+    let ledgerHashBefore;
+    if (options?.expectedLedgerHash !== undefined) {
+      const events = await readLedgerEvents(directory);
+      const tail = events[events.length - 1];
+      if (!tail || tail.plan_hash_after !== options.expectedLedgerHash) {
+        throw new LedgerStaleWriterError(`Stale writer: expected ledger hash ${options.expectedLedgerHash} but found ${tail?.plan_hash_after ?? "<missing>"}`);
+      }
+      ledgerHashBefore = tail.plan_hash_after;
+    }
     const planHashBefore = computeCurrentPlanHash(directory);
     if (options?.expectedSeq !== undefined && options.expectedSeq !== latestSeq) {
       throw new LedgerStaleWriterError(`Stale writer: expected seq ${options.expectedSeq} but found ${latestSeq}`);
@@ -246,7 +306,7 @@ async function appendLedgerEvent(directory, eventInput, options) {
       ...eventInput,
       seq: nextSeq,
       timestamp: new Date().toISOString(),
-      plan_hash_before: planHashBefore,
+      plan_hash_before: ledgerHashBefore ?? planHashBefore,
       plan_hash_after: planHashAfter,
       schema_version: LEDGER_SCHEMA_VERSION
     };
@@ -262,6 +322,34 @@ async function appendLedgerEvent(directory, eventInput, options) {
     return event;
   });
 }
+async function appendLedgerEventWithRetry(directory, eventInput, options) {
+  const maxRetries = options.maxRetries ?? 3;
+  const backoffBase = options.backoffMs ?? 10;
+  let currentExpected = options.expectedHash;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await appendLedgerEvent(directory, eventInput, {
+        expectedHash: currentExpected,
+        planHashAfter: options.planHashAfter
+      });
+    } catch (error) {
+      if (!(error instanceof LedgerStaleWriterError) || attempt >= maxRetries) {
+        throw error;
+      }
+      attempt++;
+      const delayMs = backoffBase * 2 ** (attempt - 1);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      if (options.verifyValid) {
+        const stillValid = await options.verifyValid();
+        if (!stillValid) {
+          return null;
+        }
+      }
+      currentExpected = computeCurrentPlanHash(directory);
+    }
+  }
+}
 async function takeSnapshotWithRetry(directory, plan, options) {
   const MAX_RETRIES = 3;
   const TOTAL_ATTEMPTS = 1 + MAX_RETRIES;
@@ -303,7 +391,94 @@ async function takeSnapshotEvent(directory, plan, options) {
     source: options?.source ?? "takeSnapshotEvent",
     plan_id: planId,
     payload: snapshotPayload
-  }, { planHashAfter: options?.planHashAfter });
+  }, {
+    planHashAfter: options?.planHashAfter,
+    expectedSeq: options?.expectedSeq,
+    expectedLedgerHash: options?.expectedLedgerHash
+  });
+}
+async function replaceTruncatedLedgerWithRecoveryRoot(directory, plan, expected) {
+  assertProjectRoot(directory);
+  const validated = PlanSchema.parse(plan);
+  return withEvidenceLock(directory, LEDGER_LOCK_PATH, "plan-ledger", "reconcile-truncated-ledger", async () => {
+    const ledgerPath = getLedgerPath(directory);
+    if (!fs.existsSync(ledgerPath)) {
+      throw new LedgerStaleWriterError("Stale writer: canonical ledger disappeared before truncated-ledger recovery");
+    }
+    const events = await readLedgerEvents(directory);
+    const tail = events[events.length - 1];
+    if (!tail || tail.seq !== expected.seq || tail.plan_hash_after !== expected.ledgerHash || events[0]?.plan_id !== derivePlanId(validated)) {
+      throw new LedgerStaleWriterError("Stale writer: ledger identity or tail changed before truncated-ledger recovery");
+    }
+    const integrity = await readLedgerEventsWithIntegrity(directory);
+    if (!integrity.truncated || integrity.badSuffix === null) {
+      throw new LedgerStaleWriterError("Stale writer: ledger is no longer truncated; retry against its current tail");
+    }
+    const originalBytes = fs.readFileSync(ledgerPath);
+    const archiveSha256 = crypto.createHash("sha256").update(originalBytes).digest("hex");
+    const swarmDir = path.dirname(ledgerPath);
+    const archiveSuffix = `.${archiveSha256.slice(0, 12)}.jsonl`;
+    let archiveName = `plan-ledger.reconcile-archive.${Date.now()}.${Math.floor(Math.random() * 1e9)}${archiveSuffix}`;
+    let archivePath = path.join(swarmDir, archiveName);
+    let archiveNeedsWrite = true;
+    for (const candidate of fs.readdirSync(swarmDir)) {
+      if (!candidate.startsWith("plan-ledger.reconcile-archive.") || !candidate.endsWith(archiveSuffix)) {
+        continue;
+      }
+      const candidatePath = path.join(swarmDir, candidate);
+      if (fs.readFileSync(candidatePath).equals(originalBytes)) {
+        archiveName = candidate;
+        archivePath = candidatePath;
+        archiveNeedsWrite = false;
+        break;
+      }
+    }
+    const archiveTempPath = `${archivePath}.tmp`;
+    const canonicalTempPath = `${ledgerPath}.reconcile.${Date.now()}.${Math.floor(Math.random() * 1e9)}.tmp`;
+    const planHash = computePlanHash(validated);
+    const rawBadSuffix = findRawMalformedSuffix(originalBytes);
+    if (rawBadSuffix.length === 0) {
+      throw new LedgerStaleWriterError("Stale writer: raw ledger bytes no longer contain the malformed suffix detected during replay");
+    }
+    const badSuffixSha256 = crypto.createHash("sha256").update(rawBadSuffix).digest("hex");
+    const recoveryRoot = {
+      seq: 1,
+      timestamp: new Date().toISOString(),
+      plan_id: derivePlanId(validated),
+      event_type: "plan_created",
+      source: "save_plan_truncated_ledger_reconcile",
+      plan_hash_before: "",
+      plan_hash_after: planHash,
+      schema_version: LEDGER_SCHEMA_VERSION,
+      payload: {
+        plan: validated,
+        payload_hash: planHash,
+        recovery: {
+          kind: "truncated_ledger_reconcile",
+          archived_ledger: `.swarm/${archiveName}`,
+          archived_sha256: archiveSha256,
+          bad_suffix_sha256: badSuffixSha256,
+          prior_tail_seq: expected.seq,
+          prior_tail_hash: expected.ledgerHash
+        }
+      }
+    };
+    try {
+      if (archiveNeedsWrite) {
+        _internals.writeFileFsyncedThenRename(archiveTempPath, archivePath, originalBytes);
+      }
+      _internals.fsyncRecoveryDirectory(swarmDir);
+      _internals.writeFileFsyncedThenRename(canonicalTempPath, ledgerPath, `${JSON.stringify(recoveryRoot)}
+`);
+    } finally {
+      for (const tempPath of [archiveTempPath, canonicalTempPath]) {
+        try {
+          fs.unlinkSync(tempPath);
+        } catch {}
+      }
+    }
+    return { archivePath, archiveSha256, recoveryRoot };
+  });
 }
 async function replayFromLedger(directory, options) {
   const { plan } = await replayFromLedgerWithStatus(directory, options);
@@ -521,6 +696,10 @@ async function loadLastApprovedPlan(directory, expectedPlanId) {
   const events = await readLedgerEvents(directory);
   return findLastApprovedSnapshot(events, expectedPlanId);
 }
+async function loadLastPlanCriticApprovedSnapshot(directory, expectedPlanId) {
+  const events = await readLedgerEvents(directory);
+  return findLastApprovedSnapshot(events, expectedPlanId, (payload) => payload.approval?.source === "plan_critic_gate");
+}
 function findLastApprovedSnapshot(events, expectedPlanId, extraFilter) {
   if (events.length === 0) {
     return null;
@@ -557,5 +736,28 @@ function findLastApprovedSnapshot(events, expectedPlanId, extraFilter) {
   }
   return null;
 }
+var _internals = {
+  computePlanHash,
+  computePlanStructureHash,
+  computeCurrentPlanHash,
+  ledgerExists,
+  getLatestLedgerSeq,
+  readLedgerEvents,
+  initLedger,
+  appendLedgerEvent,
+  appendLedgerEventWithRetry,
+  takeSnapshotEvent,
+  replayFromLedger,
+  replayFromLedgerWithStatus,
+  applyEventToPlan,
+  readLedgerEventsWithIntegrity,
+  quarantineLedgerSuffix,
+  loadLastApprovedPlan,
+  loadLastPlanCriticApprovedSnapshot,
+  getLedgerPath,
+  getPlanJsonPath,
+  writeFileFsyncedThenRename,
+  fsyncRecoveryDirectory
+};
 
-export { derivePlanId, derivePlanIdentityHash, LedgerStaleWriterError, computePlanHash, computePlanStructureHash, computeCurrentPlanHash, ledgerExists, getLatestLedgerSeq, readLedgerEvents, initLedger, appendLedgerEvent, takeSnapshotWithRetry, takeSnapshotEvent, replayFromLedger, replayFromLedgerWithStatus, loadLastApprovedPlan };
+export { normalizeExecutionProfileForHash, derivePlanId, derivePlanIdentityHash, LedgerStaleWriterError, computePlanHash, computePlanStructureHash, computeCurrentPlanHash, ledgerExists, getLatestLedgerSeq, readLedgerEvents, initLedger, appendLedgerEvent, takeSnapshotWithRetry, takeSnapshotEvent, replaceTruncatedLedgerWithRecoveryRoot, replayFromLedger, replayFromLedgerWithStatus, readLedgerEventsWithIntegrity, loadLastApprovedPlan };

package/dist/cli/{index-arza4m4j.js → index-z7h37d63.js}

@@ -9,11 +9,11 @@ import {
   PluginConfigSchema,
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-tj04dj06.js";
+} from "./index-jm4cpp4n.js";
 import {
   ALL_AGENT_NAMES,
   init_constants
-} from "./index-hxvkfx6t.js";
+} from "./index-jqsfsqbx.js";
 
 // src/services/config-doctor.ts
 init_constants();