opencode-swarm 7.167.1 → 7.168.0

package/dist/cli/index-fenasyvr.js

@@ -1,967 +0,0 @@
-// @bun
-import {
-  derivePlanId,
-  derivePlanIdentityHash
-} from "./index-6d4dc99f.js";
-import {
-  assertProjectRoot,
-  withEvidenceLock
-} from "./index-2w0beg3s.js";
-import {
-  emit
-} from "./index-f6zgz02s.js";
-import {
-  ExecutionProfileSchema,
-  PlanSchema,
-  TaskStatusSchema,
-  init_loader
-} from "./index-emwezg3y.js";
-import {
-  criticalWarn,
-  init_logger,
-  log
-} from "./index-zgwm4ryv.js";
-
-// src/plan/ledger.ts
-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";
-function resolvePlanEpochIdentity(events, authoritativePlan) {
-  const planId = derivePlanId(authoritativePlan);
-  const planIdentityHash = derivePlanIdentityHash(authoritativePlan);
-  const payloadHash = computePlanLedgerHash(authoritativePlan);
-  const candidates = extractPlanEpochCandidates(events, planId);
-  const distinctCandidateKeys = new Set(candidates.map((candidate) => `${candidate.planEpoch}:${candidate.rootEventHash}`));
-  if (distinctCandidateKeys.size > 1) {
-    throw new Error(`Conflicting plan epoch metadata detected for ${planId}; refusing to continue.`);
-  }
-  if (candidates.length === 0) {
-    return null;
-  }
-  const existing = candidates[0];
-  return {
-    planId,
-    planIdentityHash,
-    planEpoch: existing.planEpoch,
-    rootEventHash: existing.rootEventHash,
-    payloadHash,
-    source: existing.source
-  };
-}
-var LEDGER_FILENAME = "plan-ledger.jsonl";
-var LEDGER_LOCK_PATH = path.join(".swarm", LEDGER_FILENAME);
-var PLAN_JSON_FILENAME = "plan.json";
-
-class LedgerStaleWriterError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LedgerStaleWriterError";
-  }
-}
-function getLedgerPath(directory) {
-  return path.join(directory, ".swarm", LEDGER_FILENAME);
-}
-function getPlanJsonPath(directory) {
-  return path.join(directory, ".swarm", PLAN_JSON_FILENAME);
-}
-function compareCodeUnits(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-function readLedgerDirectory(directory) {
-  return fs.readdirSync(directory);
-}
-function asRecord(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    return value;
-  }
-  return null;
-}
-function isSha256Hex(value) {
-  return /^[a-f0-9]{64}$/i.test(value);
-}
-function isUuid(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
-}
-function serializeLedgerEvent(event) {
-  return JSON.stringify(event);
-}
-function computeLedgerEventHash(event) {
-  return crypto.createHash("sha256").update(serializeLedgerEvent(event), "utf8").digest("hex");
-}
-function extractPlanEpochCandidates(events, expectedPlanId) {
-  if (events.length === 0) {
-    throw new Error("Plan ledger is empty; missing plan_created root.");
-  }
-  const rootEvent = events[0];
-  if (rootEvent.event_type !== "plan_created") {
-    throw new Error(`Plan ledger root must be plan_created; found ${rootEvent.event_type} at seq ${rootEvent.seq}.`);
-  }
-  if (rootEvent.plan_id !== expectedPlanId) {
-    throw new Error(`Plan ledger identity mismatch: expected ${expectedPlanId} but found ${rootEvent.plan_id}.`);
-  }
-  const rootEventHash = computeLedgerEventHash(rootEvent);
-  const candidates = [];
-  const rootPayload = asRecord(rootEvent.payload);
-  const rootPlanEpoch = rootPayload?.plan_epoch;
-  if (typeof rootPlanEpoch === "string" && rootPlanEpoch.length > 0) {
-    if (!isUuid(rootPlanEpoch)) {
-      throw new Error("Plan ledger root carries an invalid plan_epoch.");
-    }
-    candidates.push({
-      planEpoch: rootPlanEpoch,
-      rootEventHash,
-      source: "root"
-    });
-  }
-  for (const event of events) {
-    if (event.event_type !== "snapshot" || event.source !== "plan_epoch_adopted") {
-      continue;
-    }
-    if (event.plan_id !== expectedPlanId) {
-      throw new Error(`Plan epoch adoption snapshot at seq ${event.seq} belongs to ${event.plan_id}, expected ${expectedPlanId}.`);
-    }
-    const payload = asRecord(event.payload);
-    const planEpoch = payload?.plan_epoch;
-    const rootHash = payload?.root_event_hash;
-    const embeddedPlan = PlanSchema.safeParse(payload?.plan);
-    if (!embeddedPlan.success) {
-      throw new Error(`Plan epoch adoption snapshot at seq ${event.seq} carries an invalid embedded plan.`);
-    }
-    const payloadHash = payload?.payload_hash;
-    if (typeof planEpoch !== "string" || !isUuid(planEpoch)) {
-      throw new Error(`Plan epoch adoption snapshot at seq ${event.seq} has an invalid plan_epoch.`);
-    }
-    if (typeof rootHash !== "string" || !isSha256Hex(rootHash)) {
-      throw new Error(`Plan epoch adoption snapshot at seq ${event.seq} has an invalid root_event_hash.`);
-    }
-    if (rootHash !== rootEventHash) {
-      throw new Error(`Plan epoch adoption snapshot at seq ${event.seq} does not match the canonical ledger root.`);
-    }
-    if (typeof payloadHash !== "string") {
-      throw new Error(`Plan epoch adoption snapshot at seq ${event.seq} is missing payload_hash.`);
-    }
-    if (derivePlanId(embeddedPlan.data) !== expectedPlanId) {
-      throw new Error(`Plan epoch adoption snapshot at seq ${event.seq} embeds a different plan identity.`);
-    }
-    if (computePlanLedgerHash(embeddedPlan.data) !== payloadHash) {
-      throw new Error(`Plan epoch adoption snapshot at seq ${event.seq} has a mismatched payload_hash.`);
-    }
-    candidates.push({
-      planEpoch,
-      rootEventHash: rootHash,
-      source: "plan_epoch_adopted"
-    });
-  }
-  return candidates;
-}
-function writeFileFsyncedThenRename(tempPath, targetPath, data) {
-  const fd = fs.openSync(tempPath, "w");
-  try {
-    fs.writeFileSync(fd, data, "utf8");
-    fs.fsyncSync(fd);
-  } finally {
-    fs.closeSync(fd);
-  }
-  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 computePlanLedgerHash(plan) {
-  const normalized = {
-    schema_version: plan.schema_version,
-    title: plan.title,
-    swarm: plan.swarm,
-    current_phase: plan.current_phase,
-    migration_status: plan.migration_status,
-    execution_profile: normalizeExecutionProfileForHash(plan.execution_profile),
-    phases: plan.phases.map((phase) => ({
-      id: phase.id,
-      name: phase.name,
-      status: phase.status,
-      required_agents: phase.required_agents ? [...phase.required_agents].sort() : undefined,
-      tasks: phase.tasks.map((task) => ({
-        id: task.id,
-        phase: task.phase,
-        status: task.status,
-        size: task.size,
-        description: task.description,
-        depends: [...task.depends].sort(),
-        acceptance: task.acceptance,
-        files_touched: [...task.files_touched].sort(),
-        evidence_path: task.evidence_path,
-        blocked_reason: task.blocked_reason
-      }))
-    }))
-  };
-  const jsonString = JSON.stringify(normalized);
-  return crypto.createHash("sha256").update(jsonString, "utf8").digest("hex");
-}
-function computePlanStructureHash(plan) {
-  const normalized = {
-    schema_version: plan.schema_version,
-    title: plan.title,
-    swarm: plan.swarm,
-    current_phase: plan.current_phase,
-    migration_status: plan.migration_status,
-    execution_profile: normalizeExecutionProfileForHash(plan.execution_profile),
-    phases: plan.phases.map((phase) => ({
-      id: phase.id,
-      name: phase.name,
-      required_agents: phase.required_agents ? [...phase.required_agents].sort() : undefined,
-      tasks: phase.tasks.map((task) => ({
-        id: task.id,
-        phase: task.phase,
-        size: task.size,
-        description: task.description,
-        depends: [...task.depends].sort(),
-        acceptance: task.acceptance,
-        files_touched: [...task.files_touched].sort(),
-        evidence_path: task.evidence_path,
-        blocked_reason: task.blocked_reason
-      }))
-    }))
-  };
-  const jsonString = JSON.stringify(normalized);
-  return crypto.createHash("sha256").update(jsonString, "utf8").digest("hex");
-}
-function computeCurrentPlanHash(directory) {
-  const planPath = getPlanJsonPath(directory);
-  try {
-    const content = fs.readFileSync(planPath, "utf8");
-    const plan = JSON.parse(content);
-    return computePlanLedgerHash(plan);
-  } catch {
-    return "";
-  }
-}
-async function ledgerExists(directory) {
-  const ledgerPath = getLedgerPath(directory);
-  return fs.existsSync(ledgerPath);
-}
-async function getLatestLedgerSeq(directory) {
-  const ledgerPath = getLedgerPath(directory);
-  if (!fs.existsSync(ledgerPath)) {
-    return 0;
-  }
-  try {
-    const content = fs.readFileSync(ledgerPath, "utf8");
-    const lines = content.trim().split(`
-`).filter((line) => line.trim() !== "");
-    if (lines.length === 0) {
-      return 0;
-    }
-    let maxSeq = 0;
-    for (const line of lines) {
-      try {
-        const event = JSON.parse(line);
-        if (event.seq > maxSeq) {
-          maxSeq = event.seq;
-        }
-      } catch {}
-    }
-    return maxSeq;
-  } catch {
-    return 0;
-  }
-}
-async function readLedgerEvents(directory) {
-  const ledgerPath = getLedgerPath(directory);
-  if (!fs.existsSync(ledgerPath)) {
-    return [];
-  }
-  try {
-    const content = fs.readFileSync(ledgerPath, "utf8");
-    const lines = content.trim().split(`
-`).filter((line) => line.trim() !== "");
-    const events = [];
-    let skippedCount = 0;
-    for (const line of lines) {
-      try {
-        const event = JSON.parse(line);
-        events.push(event);
-      } catch {
-        skippedCount++;
-      }
-    }
-    if (skippedCount > 0) {
-      log(`[ledger] Skipped ${skippedCount} malformed line(s) in plan-ledger.jsonl`);
-    }
-    events.sort((a, b) => a.seq - b.seq);
-    return events;
-  } catch {
-    return [];
-  }
-}
-async function initLedger(directory, planId, initialPlanHash, initialPlan) {
-  assertProjectRoot(directory);
-  const ledgerPath = getLedgerPath(directory);
-  const planJsonPath = getPlanJsonPath(directory);
-  if (fs.existsSync(ledgerPath)) {
-    throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
-  }
-  let planHashAfter = initialPlanHash ?? "";
-  let embeddedPlan = initialPlan;
-  if (!initialPlanHash) {
-    try {
-      if (fs.existsSync(planJsonPath)) {
-        const content = fs.readFileSync(planJsonPath, "utf8");
-        const plan = JSON.parse(content);
-        planHashAfter = computePlanLedgerHash(plan);
-        if (!embeddedPlan)
-          embeddedPlan = plan;
-      }
-    } catch {}
-  }
-  const payload = {
-    plan_epoch: crypto.randomUUID(),
-    ...embeddedPlan ? { plan: embeddedPlan, payload_hash: planHashAfter } : {}
-  };
-  const event = {
-    seq: 1,
-    timestamp: new Date().toISOString(),
-    plan_id: planId,
-    event_type: "plan_created",
-    source: "initLedger",
-    plan_hash_before: "",
-    plan_hash_after: planHashAfter,
-    schema_version: LEDGER_SCHEMA_VERSION,
-    ...payload ? { payload } : {}
-  };
-  fs.mkdirSync(path.join(directory, ".swarm"), { recursive: true });
-  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  const line = `${JSON.stringify(event)}
-`;
-  writeFileFsyncedThenRename(tempPath, ledgerPath, line);
-}
-async function readLedgerEventsForEpoch(directory) {
-  const integrity = await _internals.readLedgerEventsWithIntegrity(directory, {
-    failClosedOnReadError: true
-  });
-  if (integrity.truncated) {
-    throw new Error(`PLAN_LEDGER_TRUNCATED: ${getLedgerPath(directory)} has a malformed line; plan epoch identity cannot be resolved. Preserve this file and quarantine the corrupted suffix before retrying.`);
-  }
-  return integrity.events;
-}
-async function readPlanEpochIdentity(directory, authoritativePlan) {
-  assertProjectRoot(directory);
-  if (!await ledgerExists(directory)) {
-    return null;
-  }
-  const events = await readLedgerEventsForEpoch(directory);
-  if (events.length === 0) {
-    throw new Error("Plan ledger is empty; missing plan_created root.");
-  }
-  return resolvePlanEpochIdentity(events, authoritativePlan);
-}
-async function getOrAdoptPlanEpochUnderLock(directory, authoritativePlan) {
-  assertProjectRoot(directory);
-  const planId = derivePlanId(authoritativePlan);
-  const planIdentityHash = derivePlanIdentityHash(authoritativePlan);
-  const payloadHash = computePlanLedgerHash(authoritativePlan);
-  let lastStaleWriterError;
-  for (let attempt = 0;attempt < 4; attempt++) {
-    if (!await ledgerExists(directory)) {
-      try {
-        await initLedger(directory, planId, payloadHash, authoritativePlan);
-      } catch (error) {
-        if (!(error instanceof Error && error.message.includes("Ledger already initialized"))) {
-          throw error;
-        }
-      }
-    }
-    const events = await readLedgerEventsForEpoch(directory);
-    const existing = resolvePlanEpochIdentity(events, authoritativePlan);
-    if (existing) {
-      return existing;
-    }
-    if (events.length === 0) {
-      throw new Error("Plan ledger is empty; cannot adopt a plan epoch.");
-    }
-    const rootEvent = events[0];
-    const rootEventHash = computeLedgerEventHash(rootEvent);
-    const tail = events[events.length - 1];
-    const planEpoch = _internals.randomUUID();
-    const adoptionPayload = {
-      plan: authoritativePlan,
-      payload_hash: payloadHash,
-      plan_epoch: planEpoch,
-      root_event_hash: rootEventHash
-    };
-    try {
-      const appended = await _internals.appendLedgerEvent(directory, {
-        event_type: "snapshot",
-        source: "plan_epoch_adopted",
-        plan_id: planId,
-        payload: adoptionPayload
-      }, {
-        expectedSeq: tail.seq,
-        expectedLedgerHash: tail.plan_hash_after,
-        planHashAfter: payloadHash
-      });
-      const verifiedEvents = await readLedgerEventsForEpoch(directory);
-      const verified = verifiedEvents[verifiedEvents.length - 1];
-      const verifiedPayload = asRecord(verified?.payload);
-      if (!verified || verified.seq !== appended.seq || verified.event_type !== "snapshot" || verified.source !== "plan_epoch_adopted" || verified.plan_id !== planId || verifiedPayload?.plan_epoch !== planEpoch || verifiedPayload?.root_event_hash !== rootEventHash || verifiedPayload?.payload_hash !== payloadHash) {
-        throw new Error(`Plan epoch adoption read verification failed for ${planId}.`);
-      }
-      return {
-        planId,
-        planIdentityHash,
-        planEpoch,
-        rootEventHash,
-        payloadHash,
-        source: "plan_epoch_adopted"
-      };
-    } catch (error) {
-      if (error instanceof LedgerStaleWriterError) {
-        lastStaleWriterError = error;
-        continue;
-      }
-      throw error;
-    }
-  }
-  throw new Error(`Unable to settle plan epoch for ${planId} after repeated stale-writer retries.`, { cause: lastStaleWriterError });
-}
-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}`);
-    }
-    if (options?.expectedHash !== undefined && options.expectedHash !== planHashBefore) {
-      throw new LedgerStaleWriterError(`Stale writer: expected hash ${options.expectedHash} but found ${planHashBefore}`);
-    }
-    const planHashAfter = options?.planHashAfter ?? planHashBefore;
-    const event = {
-      ...eventInput,
-      seq: nextSeq,
-      timestamp: new Date().toISOString(),
-      plan_hash_before: ledgerHashBefore ?? planHashBefore,
-      plan_hash_after: planHashAfter,
-      schema_version: LEDGER_SCHEMA_VERSION
-    };
-    fs.mkdirSync(path.join(directory, ".swarm"), { recursive: true });
-    const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-    const line = `${JSON.stringify(event)}
-`;
-    if (!fs.existsSync(ledgerPath)) {
-      throw new Error("Ledger not initialized. Call initLedger() first.");
-    }
-    const existingContent = fs.readFileSync(ledgerPath, "utf8");
-    writeFileFsyncedThenRename(tempPath, ledgerPath, existingContent + line);
-    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;
-  const telemetrySource = options?.source ?? "save_plan_tool";
-  const snapshotOptions = { planHashAfter: options?.planHashAfter };
-  let lastError;
-  for (let attempt = 1;attempt <= TOTAL_ATTEMPTS; attempt++) {
-    try {
-      await takeSnapshotEvent(directory, plan, snapshotOptions);
-      return;
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-      if (attempt < TOTAL_ATTEMPTS) {
-        await new Promise((r) => setTimeout(r, 10 * 2 ** (attempt - 1)));
-      }
-    }
-  }
-  criticalWarn(`[takeSnapshotWithRetry] Snapshot failed after ${MAX_RETRIES} retries (${TOTAL_ATTEMPTS} attempts): ${lastError.message}`);
-  try {
-    emit("snapshot_failed", {
-      error: lastError.message,
-      retries: MAX_RETRIES,
-      source: telemetrySource
-    });
-  } catch {}
-}
-async function takeSnapshotEvent(directory, plan, options) {
-  const payloadHash = options?.payloadHashOverride ?? (options?.source === "critic_approved" ? computePlanStructureHash(plan) : computePlanLedgerHash(plan));
-  const snapshotPayload = {
-    plan,
-    payload_hash: payloadHash
-  };
-  if (options?.approvalMetadata) {
-    snapshotPayload.approval = options.approvalMetadata;
-  }
-  const planId = derivePlanId(plan);
-  return appendLedgerEvent(directory, {
-    event_type: "snapshot",
-    source: options?.source ?? "takeSnapshotEvent",
-    plan_id: planId,
-    payload: snapshotPayload
-  }, {
-    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 _internals.readLedgerDirectory(swarmDir).sort(compareCodeUnits)) {
-      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 = computePlanLedgerHash(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);
-  return plan;
-}
-async function replayFromLedgerWithStatus(directory, _options) {
-  const { events, truncated, badSuffix } = await readLedgerEventsWithIntegrity(directory);
-  if (events.length === 0) {
-    return { plan: null, truncated, badSuffix };
-  }
-  if (truncated && badSuffix !== null) {
-    await quarantineLedgerSuffix(directory, badSuffix);
-  }
-  const plan = reconstructPlanFromEvents(directory, events);
-  return { plan, truncated, badSuffix };
-}
-function reconstructPlanFromEvents(directory, events) {
-  const targetPlanId = events[0].plan_id;
-  const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
-  {
-    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 = relevantEvents.filter((e) => e.seq > latestSnapshotEvent.seq);
-      for (const event of eventsAfterSnapshot) {
-        plan2 = applyEventToPlan(plan2, event);
-        if (plan2 === null) {
-          return null;
-        }
-      }
-      return plan2;
-    }
-  }
-  const createdEvent = relevantEvents.find((e) => e.event_type === "plan_created");
-  if (createdEvent?.payload && typeof createdEvent.payload === "object" && "plan" in createdEvent.payload) {
-    const parseResult = PlanSchema.safeParse(createdEvent.payload.plan);
-    if (parseResult.success) {
-      let plan2 = parseResult.data;
-      const eventsAfterCreated = relevantEvents.filter((e) => e.seq > createdEvent.seq);
-      for (const event of eventsAfterCreated) {
-        if (plan2 === null)
-          return null;
-        plan2 = applyEventToPlan(plan2, event);
-      }
-      return plan2;
-    }
-  }
-  const planJsonPath = getPlanJsonPath(directory);
-  if (!fs.existsSync(planJsonPath)) {
-    return null;
-  }
-  let plan;
-  try {
-    const content = fs.readFileSync(planJsonPath, "utf8");
-    plan = JSON.parse(content);
-  } catch {
-    return null;
-  }
-  for (const event of relevantEvents) {
-    if (plan === null) {
-      return null;
-    }
-    plan = applyEventToPlan(plan, event);
-  }
-  return plan;
-}
-function applyEventToPlan(plan, event) {
-  switch (event.event_type) {
-    case "plan_created":
-      if (event.payload && typeof event.payload === "object" && "plan" in event.payload) {
-        const parsed = PlanSchema.safeParse(event.payload.plan);
-        if (parsed.success)
-          return parsed.data;
-      }
-      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 = parseResult.data;
-            break;
-          }
-        }
-      }
-      return plan;
-    case "phase_completed":
-      if (event.phase_id) {
-        const phase = plan.phases.find((p) => p.id === event.phase_id);
-        if (phase) {
-          phase.status = "complete";
-        }
-      }
-      return plan;
-    case "plan_exported":
-      return plan;
-    case "task_added":
-      return plan;
-    case "task_removed":
-      if (event.task_id) {
-        for (const phase of plan.phases) {
-          const idx = phase.tasks.findIndex((t) => t.id === event.task_id);
-          if (idx !== -1) {
-            phase.tasks.splice(idx, 1);
-            break;
-          }
-        }
-      }
-      return plan;
-    case "task_updated":
-      return plan;
-    case "plan_rebuilt":
-      return plan;
-    case "task_reordered":
-      return plan;
-    case "snapshot":
-      return plan;
-    case "plan_reset":
-      return null;
-    case "execution_profile_set": {
-      const rawProfile = event.payload?.execution_profile;
-      if (rawProfile !== undefined) {
-        const parsed = ExecutionProfileSchema.safeParse(rawProfile);
-        if (parsed.success) {
-          return { ...plan, execution_profile: parsed.data };
-        }
-      }
-      return plan;
-    }
-    case "execution_profile_locked": {
-      if (plan.execution_profile) {
-        return {
-          ...plan,
-          execution_profile: { ...plan.execution_profile, locked: true }
-        };
-      }
-      return plan;
-    }
-    default:
-      throw new Error(`applyEventToPlan: unhandled event type "${event.event_type}" at seq ${event.seq}`);
-  }
-}
-async function readLedgerEventsWithIntegrity(directory, options) {
-  const ledgerPath = getLedgerPath(directory);
-  if (!fs.existsSync(ledgerPath)) {
-    return { events: [], truncated: false, badSuffix: null };
-  }
-  try {
-    const content = fs.readFileSync(ledgerPath, "utf8");
-    const lines = content.split(`
-`);
-    const events = [];
-    let truncated = false;
-    let badSuffix = null;
-    for (let i = 0;i < lines.length; i++) {
-      const line = lines[i];
-      if (line.trim() === "") {
-        continue;
-      }
-      try {
-        const event = JSON.parse(line);
-        events.push(event);
-      } catch {
-        truncated = true;
-        badSuffix = lines.slice(i).join(`
-`);
-        break;
-      }
-    }
-    events.sort((a, b) => a.seq - b.seq);
-    return { events, truncated, badSuffix };
-  } catch (error) {
-    if (options?.failClosedOnReadError) {
-      throw new Error(`PLAN_LEDGER_UNREADABLE: ${ledgerPath} exists but could not be read (${error instanceof Error ? error.message : String(error)}); plan state cannot be resolved. This is NOT an absent ledger \u2014 preserve the file and check permissions/filesystem health before retrying.`);
-    }
-    return { events: [], truncated: false, badSuffix: null };
-  }
-}
-async function quarantineLedgerSuffix(directory, badSuffix) {
-  let salvagedCount = 0;
-  for (const line of badSuffix.split(`
-`)) {
-    if (line.trim() === "")
-      continue;
-    try {
-      JSON.parse(line);
-      salvagedCount++;
-    } catch {}
-  }
-  try {
-    assertProjectRoot(directory);
-    const hash = crypto.createHash("sha256").update(badSuffix, "utf8").digest("hex").slice(0, 12);
-    const swarmDir = path.join(directory, ".swarm");
-    try {
-      const existing = _internals.readLedgerDirectory(swarmDir).sort(compareCodeUnits).filter((name) => name.startsWith("plan-ledger.quarantine.") && name.endsWith(`.${hash}`));
-      for (const name of existing) {
-        const existingPath = path.join(swarmDir, name);
-        if (fs.readFileSync(existingPath, "utf8") === badSuffix) {
-          return { path: existingPath, salvagedCount };
-        }
-      }
-    } catch {}
-    const quarantinePath = path.join(swarmDir, `plan-ledger.quarantine.${Date.now()}.${hash}`);
-    fs.writeFileSync(quarantinePath, badSuffix, "utf8");
-    log(`[ledger] Corrupted suffix quarantined to ${path.relative(directory, quarantinePath)} (salvageable events: ${salvagedCount})`);
-    return { path: quarantinePath, salvagedCount };
-  } catch {
-    return { path: null, salvagedCount };
-  }
-}
-async function loadLastApprovedPlan(directory, expectedPlanId) {
-  const events = await readLedgerEvents(directory);
-  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;
-  }
-  for (let i = events.length - 1;i >= 0; i--) {
-    const event = events[i];
-    if (event.event_type !== "snapshot")
-      continue;
-    if (event.source !== "critic_approved")
-      continue;
-    if (expectedPlanId !== undefined && event.plan_id !== expectedPlanId) {
-      continue;
-    }
-    const payload = event.payload;
-    if (!payload || typeof payload !== "object" || !payload.plan) {
-      continue;
-    }
-    if (expectedPlanId !== undefined) {
-      const payloadPlanId = derivePlanId(payload.plan);
-      if (payloadPlanId !== expectedPlanId) {
-        continue;
-      }
-    }
-    if (extraFilter && !extraFilter(payload)) {
-      continue;
-    }
-    return {
-      plan: payload.plan,
-      seq: event.seq,
-      timestamp: event.timestamp,
-      approval: payload.approval,
-      payloadHash: payload.payload_hash
-    };
-  }
-  return null;
-}
-var _internals = {
-  computePlanLedgerHash,
-  computePlanStructureHash,
-  computeCurrentPlanHash,
-  ledgerExists,
-  getLatestLedgerSeq,
-  readLedgerEvents,
-  initLedger,
-  appendLedgerEvent,
-  appendLedgerEventWithRetry,
-  takeSnapshotEvent,
-  replayFromLedger,
-  replayFromLedgerWithStatus,
-  applyEventToPlan,
-  readLedgerEventsWithIntegrity,
-  quarantineLedgerSuffix,
-  loadLastApprovedPlan,
-  loadLastPlanCriticApprovedSnapshot,
-  getLedgerPath,
-  getPlanJsonPath,
-  writeFileFsyncedThenRename,
-  fsyncRecoveryDirectory,
-  readLedgerDirectory,
-  randomUUID: () => crypto.randomUUID()
-};
-
-export { normalizeExecutionProfileForHash, LedgerStaleWriterError, computePlanLedgerHash, computePlanStructureHash, computeCurrentPlanHash, ledgerExists, getLatestLedgerSeq, readLedgerEvents, initLedger, readPlanEpochIdentity, getOrAdoptPlanEpochUnderLock, appendLedgerEvent, takeSnapshotWithRetry, takeSnapshotEvent, replaceTruncatedLedgerWithRecoveryRoot, replayFromLedger, replayFromLedgerWithStatus, readLedgerEventsWithIntegrity, loadLastApprovedPlan };