opencode-swarm 7.141.2 → 7.142.1

package/dist/cli/{index-hwxcdrv9.js → index-j02ez59y.js}

@@ -6,16 +6,16 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-kq5p3nm3.js";
+} from "./index-w7x7qxz2.js";
 import {
   atomicWriteFile
-} from "./index-c2hczjhp.js";
-import {
-  require_proper_lockfile
-} from "./index-7g4c7s5r.js";
+} from "./index-erfnw81g.js";
 import {
   readCachedParsedFile
 } from "./index-ed5ykebp.js";
+import {
+  require_proper_lockfile
+} from "./index-7g4c7s5r.js";
 import {
   init_logger,
   log
@@ -709,7 +709,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
   const {
     readAuthoritativeKnowledgeCounterRollups,
     effectiveRetrievalOutcomes
-  } = await import("./knowledge-events-hsdx5prn.js");
+  } = await import("./knowledge-events-8x2wt562.js");
   const rollups = await readAuthoritativeKnowledgeCounterRollups(directory);
   const flagIds = new Set;
   for (const e of atFloor) {
@@ -776,11 +776,11 @@ async function applyConfidenceFloorAction(directory, touched, options) {
     });
   }
   if (action === "quarantine" && toQuarantine.length > 0) {
-    const { quarantineEntry } = await import("./knowledge-validator-jr5694jb.js");
-    const { KnowledgeConfigSchema } = await import("./schema-f6pt0zjy.js");
+    const { quarantineEntry } = await import("./knowledge-validator-ewfj679a.js");
+    const { KnowledgeConfigSchema } = await import("./schema-ney3c685.js");
     let config;
     try {
-      const { loadPluginConfigWithMeta } = await import("./index-p5y72gtj.js");
+      const { loadPluginConfigWithMeta } = await import("./index-kbshtwha.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-h3vk67wp.js → index-k1xsjzm3.js}

@@ -2,18 +2,18 @@
 import {
   effectiveRetrievalOutcomes,
   readAuthoritativeKnowledgeCounterRollups
-} from "./index-76651erq.js";
+} from "./index-ajfa2wmj.js";
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-6bp1jecx.js";
+} from "./index-9kf3mj08.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-hwxcdrv9.js";
+} from "./index-j02ez59y.js";
 import {
   advisoryWarn,
   init_warning_buffer

package/dist/cli/{index-zbj3yrrd.js → index-k31en0ja.js}

@@ -2,13 +2,13 @@
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
+import {
+  emit
+} from "./index-s2rcz51a.js";
 import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
-import {
-  emit
-} from "./index-9d4gck4e.js";
 import {
   __toESM
 } from "./index-a76rekgs.js";

package/dist/cli/{index-q4vaar2b.js → index-k92cagmt.js}

@@ -9,11 +9,11 @@ import {
 } from "./index-y8552snf.js";
 import {
   atomicWriteFile
-} from "./index-c2hczjhp.js";
+} from "./index-erfnw81g.js";
 import {
   assertProjectRoot,
   withEvidenceLock
-} from "./index-zbj3yrrd.js";
+} from "./index-k31en0ja.js";
 import {
   exports_external,
   init_zod

package/dist/cli/{index-p5y72gtj.js → index-kbshtwha.js}

@@ -2,7 +2,7 @@
 import {
   _internals,
   resolveWorktreeIsolationConfig
-} from "./index-r6pdts5c.js";
+} from "./index-ktazgjqw.js";
 import {
   ApprovalEvidenceSchema,
   BaseEvidenceSchema,
@@ -42,7 +42,7 @@ import {
   loadPluginConfig,
   loadPluginConfigWithMeta,
   loadPluginConfigWithMetaAsync
-} from "./index-y6k6x197.js";
+} from "./index-sdqtecsd.js";
 import"./index-4rhhvd1a.js";
 import"./index-zgwm4ryv.js";
 import {
@@ -66,7 +66,7 @@ import {
   TurboConfigSchema,
   WorktreeIsolationConfigSchema,
   resolveAutoReviewConfig
-} from "./index-mqqmant3.js";
+} from "./index-we279je2.js";
 import {
   ALL_AGENT_NAMES,
   ALL_SUBAGENT_NAMES,

package/dist/cli/{index-r6pdts5c.js → index-ktazgjqw.js}

@@ -2,10 +2,10 @@
 import {
   init_loader,
   loadPluginConfigWithMeta
-} from "./index-y6k6x197.js";
+} from "./index-sdqtecsd.js";
 import {
   init_schema
-} from "./index-mqqmant3.js";
+} from "./index-we279je2.js";
 import {
   DEFAULT_WORKTREE_ISOLATION_CONFIG,
   init_constants

package/dist/cli/{index-mxtt4x8r.js → index-myav90y6.js}

@@ -2,21 +2,21 @@
 import {
   assertProjectRoot,
   withEvidenceLock
-} from "./index-zbj3yrrd.js";
+} from "./index-k31en0ja.js";
+import {
+  emit
+} from "./index-s2rcz51a.js";
 import {
   ExecutionProfileSchema,
   PlanSchema,
   TaskStatusSchema,
   init_loader
-} from "./index-y6k6x197.js";
+} from "./index-sdqtecsd.js";
 import {
   criticalWarn,
   init_logger,
   log
 } from "./index-zgwm4ryv.js";
-import {
-  emit
-} from "./index-9d4gck4e.js";
 
 // src/plan/utils.ts
 import { createHash } from "crypto";
@@ -47,6 +47,28 @@ function normalizeExecutionProfileForHash(profile) {
 
 // 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 = computePlanHash(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";
@@ -63,6 +85,90 @@ function getLedgerPath(directory) {
 function getPlanJsonPath(directory) {
   return path.join(directory, ".swarm", PLAN_JSON_FILENAME);
 }
+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 (computePlanHash(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 {
@@ -258,7 +364,10 @@ async function initLedger(directory, planId, initialPlanHash, initialPlan) {
       }
     } catch {}
   }
-  const payload = embeddedPlan ? { plan: embeddedPlan, payload_hash: planHashAfter } : undefined;
+  const payload = {
+    plan_epoch: crypto.randomUUID(),
+    ...embeddedPlan ? { plan: embeddedPlan, payload_hash: planHashAfter } : {}
+  };
   const event = {
     seq: 1,
     timestamp: new Date().toISOString(),
@@ -276,6 +385,95 @@ async function initLedger(directory, planId, initialPlanHash, initialPlan) {
 `;
   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 = computePlanHash(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 () => {
@@ -627,7 +825,7 @@ function applyEventToPlan(plan, event) {
       throw new Error(`applyEventToPlan: unhandled event type "${event.event_type}" at seq ${event.seq}`);
   }
 }
-async function readLedgerEventsWithIntegrity(directory) {
+async function readLedgerEventsWithIntegrity(directory, options) {
   const ledgerPath = getLedgerPath(directory);
   if (!fs.existsSync(ledgerPath)) {
     return { events: [], truncated: false, badSuffix: null };
@@ -656,7 +854,10 @@ async function readLedgerEventsWithIntegrity(directory) {
     }
     events.sort((a, b) => a.seq - b.seq);
     return { events, truncated, badSuffix };
-  } catch {
+  } 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 };
   }
 }
@@ -757,7 +958,8 @@ var _internals = {
   getLedgerPath,
   getPlanJsonPath,
   writeFileFsyncedThenRename,
-  fsyncRecoveryDirectory
+  fsyncRecoveryDirectory,
+  randomUUID: () => crypto.randomUUID()
 };
 
-export { normalizeExecutionProfileForHash, derivePlanId, derivePlanIdentityHash, LedgerStaleWriterError, computePlanHash, computePlanStructureHash, computeCurrentPlanHash, ledgerExists, getLatestLedgerSeq, readLedgerEvents, initLedger, appendLedgerEvent, takeSnapshotWithRetry, takeSnapshotEvent, replaceTruncatedLedgerWithRecoveryRoot, replayFromLedger, replayFromLedgerWithStatus, readLedgerEventsWithIntegrity, loadLastApprovedPlan };
+export { normalizeExecutionProfileForHash, derivePlanId, derivePlanIdentityHash, LedgerStaleWriterError, computePlanHash, computePlanStructureHash, computeCurrentPlanHash, ledgerExists, getLatestLedgerSeq, readLedgerEvents, initLedger, readPlanEpochIdentity, getOrAdoptPlanEpochUnderLock, appendLedgerEvent, takeSnapshotWithRetry, takeSnapshotEvent, replaceTruncatedLedgerWithRecoveryRoot, replayFromLedger, replayFromLedgerWithStatus, readLedgerEventsWithIntegrity, loadLastApprovedPlan };

package/dist/cli/{index-kkn2jxda.js → index-rthq1a6w.js}

@@ -15,7 +15,7 @@ import {
 import {
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-mqqmant3.js";
+} from "./index-we279je2.js";
 import {
   init_constants
 } from "./index-jqsfsqbx.js";