@tangle-network/agent-runtime 0.105.0 → 0.106.1

package/dist/chunk-CTRA64LY.js

@@ -1,680 +0,0 @@
-import {
-  sealAgentCandidateBundle
-} from "./chunk-RDOAVVHY.js";
-import {
-  RecoveryAgentCandidateTraceStore,
-  applyExactAgentProfileDiff,
-  assertPreparedCandidateIntegrity,
-  assertRecoveryMatchesStaged,
-  assertTerminalAllowedInPhase,
-  assertTerminalMatchesClaim,
-  assertTerminalMatchesStaged,
-  beginPreparedCandidateDisposal,
-  candidateClaimFileInternals,
-  candidateCleanupDeadline,
-  candidateCleanupTimeout,
-  canonicalCandidateBytes,
-  consumePreparedCandidateExecution,
-  embeddedCandidateArtifact,
-  freezeGenericAgentCandidateProfile,
-  parseExactAgentProfile,
-  parseExactAgentProfileDiff,
-  parseExactCandidateProfile,
-  persistCandidateModelSettlementEvidence,
-  persistCandidateOutputArtifact,
-  readVerifiedArtifact,
-  recoveredTerminalRecord,
-  rejectedFinish,
-  rejectedStage,
-  requireStagedTerminal,
-  sealAgentCandidateExecutorStopAcknowledgement,
-  sealAgentCandidateModelSettlement,
-  sealTerminalDigest,
-  terminalRecord,
-  withinCandidateCleanupDeadline
-} from "./chunk-WSTRQZYQ.js";
-
-// src/candidate-execution/builder.ts
-import { verifyCodeSurface } from "@tangle-network/agent-eval/campaign";
-function buildAgentCandidateBundle(input) {
-  const bundle = {
-    kind: "agent-candidate-bundle",
-    digestAlgorithm: "rfc8785-sha256",
-    profile: compileCandidateProfile(input.profile),
-    code: compileCandidateCode(input.code),
-    execution: input.execution,
-    ...input.knowledge !== void 0 ? { knowledge: input.knowledge } : {},
-    memory: input.memory
-  };
-  return sealAgentCandidateBundle(bundle);
-}
-function compileCandidateProfile(source) {
-  if (source.kind === "candidate-profile") {
-    return parseExactCandidateProfile(source.profile);
-  }
-  if (source.kind === "profile") {
-    return freezeGenericAgentCandidateProfile(source.profile);
-  }
-  if (source.kind !== "profile-diffs") {
-    throw new Error(
-      `unsupported candidate profile source: ${String(source.kind)}`
-    );
-  }
-  if (source.diffs.length === 0) {
-    throw new Error("profile-diffs source requires at least one AgentProfileDiff");
-  }
-  let profile = parseExactAgentProfile(source.base, "base profile");
-  for (const [index, inputDiff] of source.diffs.entries()) {
-    const diff = parseExactAgentProfileDiff(inputDiff, `profile diff ${index}`);
-    profile = applyExactAgentProfileDiff(profile, diff, `profile diff ${index}`);
-  }
-  return freezeGenericAgentCandidateProfile(profile);
-}
-function compileCandidateCode(source) {
-  if (source.kind === "disabled" || source.kind === "no-op") return source;
-  if (source.kind !== "code-surface") {
-    throw new Error(
-      `unsupported candidate code source: ${String(source.kind)}`
-    );
-  }
-  const verified = verifyCodeSurface(source.surface, source.worktreeDir);
-  const patch = embeddedCandidateArtifact(verified.patchBytes);
-  if (patch.sha256 !== source.surface.patch.sha256 || patch.byteLength !== source.surface.patch.byteLength) {
-    throw new Error("verified CodeSurface patch bytes do not match its content identity");
-  }
-  return {
-    kind: "git-patch",
-    repository: source.repository,
-    baseCommit: source.surface.baseCommit,
-    baseTree: source.surface.baseTree,
-    candidateTree: source.surface.candidateTree,
-    patch: { format: "git-diff-binary", artifact: patch }
-  };
-}
-
-// src/candidate-execution/claim-file-store.ts
-import { randomUUID } from "crypto";
-import { linkSync } from "fs";
-import { mkdir, open, unlink } from "fs/promises";
-import { join } from "path";
-var {
-  assertExpiredLease,
-  assertLease,
-  assertSameSlot,
-  assertUnexpiredLease,
-  attemptRecord,
-  claimSlot,
-  leaseDigest,
-  newLease,
-  readClaim,
-  readClaimIfPresent,
-  readTerminal,
-  readTerminalIfPresent,
-  readTransitionIfPresent,
-  rejectedExistingClaim,
-  rejectedRetry,
-  retryRejection,
-  sealAttemptRef,
-  sealClaim,
-  sealLease
-} = candidateClaimFileInternals;
-var FileAgentCandidateExecutionClaimStore = class {
-  directory;
-  now;
-  constructor(options) {
-    if (options.directory.length === 0) {
-      throw new Error("candidate execution claim directory must not be empty");
-    }
-    this.directory = options.directory;
-    this.now = options.now ?? Date.now;
-  }
-  async tryClaim(requested) {
-    const claim = sealClaim(requested);
-    await mkdir(this.directory, { recursive: true });
-    const claimPath = this.claimPath(claim);
-    const existing = await readClaimIfPresent(claimPath);
-    if (existing) {
-      assertSameSlot(existing.claim, claim, claimPath);
-      return rejectedExistingClaim(existing.claim, claim);
-    }
-    assertUnexpiredLease(claim.leaseExpiresAtMs, this.now());
-    const retryFailure = await this.retryFailure(claim);
-    if (retryFailure) return rejectedRetry(claim, retryFailure);
-    const lease = newLease(claim);
-    const acquired = await writeRecordIfAbsent(this.directory, claimPath, {
-      ...claim,
-      phase: "claimed",
-      leaseDigest: leaseDigest(lease)
-    });
-    if (acquired) return Object.freeze({ acquired: true, claim, lease });
-    const winner = await readClaim(claimPath);
-    assertSameSlot(winner.claim, claim, claimPath);
-    return rejectedExistingClaim(winner.claim, claim);
-  }
-  async getAttempt(requestedAttempt) {
-    return await this.storedAttempt(sealAttemptRef(requestedAttempt));
-  }
-  async markCandidateMayRun(requestedLease) {
-    const lease = sealLease(requestedLease);
-    const claimPath = this.claimPath(lease);
-    const stored = await readClaim(claimPath);
-    assertSameSlot(stored.claim, lease, claimPath);
-    assertLease(stored.leaseDigest, stored.claim.leaseExpiresAtMs, lease);
-    const state = await this.transitionState(stored.claim);
-    if (state.phase === "candidate-may-run") {
-      return Object.freeze({ marked: false, phase: "candidate-may-run" });
-    }
-    if (state.staged) {
-      throw new Error("candidate execution terminal was staged before candidate-may-run phase");
-    }
-    assertUnexpiredLease(stored.claim.leaseExpiresAtMs, this.now());
-    const marked = await writeRecordIfAbsent(
-      this.directory,
-      this.transitionPath(stored.claim, 1),
-      {
-        kind: "candidate-execution-phase",
-        executionId: stored.claim.executionId,
-        attempt: stored.claim.attempt,
-        executionPlanDigest: stored.claim.executionPlanDigest,
-        phase: "candidate-may-run"
-      },
-      this.ownerPublication(stored.claim)
-    );
-    if (marked) return Object.freeze({ marked: true, phase: "candidate-may-run" });
-    const winner = await this.transitionState(stored.claim);
-    if (winner.phase === "candidate-may-run") {
-      return Object.freeze({ marked: false, phase: "candidate-may-run" });
-    }
-    throw new Error("candidate execution terminal was staged before candidate-may-run phase");
-  }
-  async stageTerminal(requestedLease, result) {
-    const lease = sealLease(requestedLease);
-    const claimPath = this.claimPath(lease);
-    const stored = await readClaim(claimPath);
-    assertSameSlot(stored.claim, lease, claimPath);
-    assertLease(stored.leaseDigest, stored.claim.leaseExpiresAtMs, lease);
-    const terminal = terminalRecord(stored.claim, result);
-    const state = await this.transitionState(stored.claim);
-    if (state.staged) return rejectedStage(state.staged, terminal);
-    assertTerminalAllowedInPhase(state.phase, terminal);
-    assertUnexpiredLease(stored.claim.leaseExpiresAtMs, this.now());
-    const transition = state.phase === "claimed" ? 1 : 2;
-    const staged = await writeRecordIfAbsent(
-      this.directory,
-      this.transitionPath(stored.claim, transition),
-      {
-        kind: "candidate-execution-pending-terminal",
-        terminal
-      },
-      this.ownerPublication(stored.claim)
-    );
-    if (staged) return Object.freeze({ staged: true, terminal });
-    const winner = await this.transitionState(stored.claim);
-    if (!winner.staged) {
-      throw new Error("candidate execution phase transition won while staging terminal");
-    }
-    return rejectedStage(winner.staged, terminal);
-  }
-  async finish(requestedLease, requestedTerminalDigest) {
-    const lease = sealLease(requestedLease);
-    const terminalDigest = sealTerminalDigest(requestedTerminalDigest);
-    const claimPath = this.claimPath(lease);
-    const stored = await readClaim(claimPath);
-    assertSameSlot(stored.claim, lease, claimPath);
-    assertLease(stored.leaseDigest, stored.claim.leaseExpiresAtMs, lease);
-    const state = await this.transitionState(stored.claim);
-    const staged = requireStagedTerminal(state.staged, terminalDigest);
-    const terminalPath = this.terminalPath(lease);
-    const existing = await readTerminalIfPresent(terminalPath);
-    if (existing) {
-      assertTerminalMatchesClaim(existing, stored.claim, terminalPath);
-      assertTerminalMatchesStaged(existing, staged, terminalPath);
-      return rejectedFinish(existing, terminalDigest);
-    }
-    assertUnexpiredLease(stored.claim.leaseExpiresAtMs, this.now());
-    const finished = await writeRecordIfAbsent(
-      this.directory,
-      terminalPath,
-      {
-        terminal: staged
-      },
-      this.ownerPublication(stored.claim)
-    );
-    if (finished) return Object.freeze({ finished: true, terminal: staged });
-    const winner = await readTerminal(terminalPath);
-    assertSameSlot(winner, lease, terminalPath);
-    assertTerminalMatchesClaim(winner, stored.claim, terminalPath);
-    assertTerminalMatchesStaged(winner, staged, terminalPath);
-    return rejectedFinish(winner, terminalDigest);
-  }
-  async recoverExpired(requestedAttempt, evidence) {
-    const attempt = sealAttemptRef(requestedAttempt);
-    const record = await this.storedAttempt(attempt);
-    if (!record) throw new Error("candidate execution recovery does not name an acquired attempt");
-    const recovered = recoveredTerminalRecord(record.claim, record.phase, evidence);
-    if (record.staged) assertRecoveryMatchesStaged(record.staged, recovered);
-    const requestedDigest = record.staged?.terminalDigest ?? recovered.terminalDigest;
-    if (record.terminal) return rejectedFinish(record.terminal, requestedDigest);
-    assertExpiredLease(record.claim.leaseExpiresAtMs, this.now());
-    let staged = record.staged;
-    if (!staged) {
-      const transition = record.phase === "claimed" ? 1 : 2;
-      const didStage = await writeRecordIfAbsent(
-        this.directory,
-        this.transitionPath(record.claim, transition),
-        {
-          kind: "candidate-execution-pending-terminal",
-          terminal: recovered
-        }
-      );
-      if (didStage) {
-        staged = recovered;
-      } else {
-        const winner2 = await this.transitionState(record.claim);
-        if (!winner2.staged) {
-          throw new Error(
-            "candidate execution recovery lost terminal staging to a phase transition"
-          );
-        }
-        assertRecoveryMatchesStaged(winner2.staged, recovered);
-        staged = winner2.staged;
-      }
-    }
-    const terminalPath = this.terminalPath(attempt);
-    const didFinish = await writeRecordIfAbsent(this.directory, terminalPath, {
-      terminal: staged
-    });
-    if (didFinish) return Object.freeze({ finished: true, terminal: staged });
-    const winner = await readTerminal(terminalPath);
-    assertSameSlot(winner, attempt, terminalPath);
-    assertTerminalMatchesClaim(winner, record.claim, terminalPath);
-    assertTerminalMatchesStaged(winner, staged, terminalPath);
-    return rejectedFinish(winner, staged.terminalDigest);
-  }
-  async storedAttempt(claim) {
-    const claimPath = this.claimPath(claim);
-    const stored = await readClaimIfPresent(claimPath);
-    if (!stored) return void 0;
-    assertSameSlot(stored.claim, claim, claimPath);
-    const state = await this.transitionState(stored.claim);
-    const terminalPath = this.terminalPath(claim);
-    const terminal = await readTerminalIfPresent(terminalPath);
-    if (terminal) {
-      assertTerminalMatchesClaim(terminal, stored.claim, terminalPath);
-      if (!state.staged) {
-        throw new Error(
-          `candidate execution terminal record at ${terminalPath} has no staged outbox`
-        );
-      }
-      assertTerminalMatchesStaged(terminal, state.staged, terminalPath);
-    }
-    return attemptRecord(stored.claim, state.phase, state.staged, terminal);
-  }
-  async transitionState(claim) {
-    const firstPath = this.transitionPath(claim, 1);
-    const first = await readTransitionIfPresent(firstPath, claim);
-    if (!first) return { phase: "claimed" };
-    if (first.kind === "pending") return { phase: "claimed", staged: first.terminal };
-    const secondPath = this.transitionPath(claim, 2);
-    const second = await readTransitionIfPresent(secondPath, claim);
-    if (!second) return { phase: "candidate-may-run" };
-    if (second.kind !== "pending") {
-      throw new Error(`candidate execution transition at ${secondPath} repeats the phase marker`);
-    }
-    return { phase: "candidate-may-run", staged: second.terminal };
-  }
-  async retryFailure(claim) {
-    if (claim.attempt === 1) return void 0;
-    return retryRejection(
-      claim,
-      await this.storedAttempt({
-        executionId: claim.executionId,
-        attempt: claim.attempt - 1
-      })
-    );
-  }
-  ownerPublication(claim) {
-    return {
-      authorizePublish: () => {
-        assertUnexpiredLease(claim.leaseExpiresAtMs, this.now());
-        return true;
-      }
-    };
-  }
-  claimPath(claim) {
-    return join(this.directory, `${claimSlot(claim)}.claim.json`);
-  }
-  terminalPath(claim) {
-    return join(this.directory, `${claimSlot(claim)}.terminal.json`);
-  }
-  transitionPath(claim, ordinal) {
-    return join(this.directory, `${claimSlot(claim)}.transition-${ordinal}.json`);
-  }
-};
-async function writeRecordIfAbsent(directory, destination, record, options = {}) {
-  const temporaryPath = join(directory, `.candidate-execution-${process.pid}-${randomUUID()}.tmp`);
-  const handle = await open(temporaryPath, "wx", 384);
-  try {
-    await handle.writeFile(
-      Buffer.concat([Buffer.from(canonicalCandidateBytes(record)), Buffer.from("\n")])
-    );
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  let written = false;
-  try {
-    if (options.authorizePublish && options.authorizePublish() !== true) {
-      throw new Error("candidate execution record publication was not authorized");
-    }
-    linkSync(temporaryPath, destination);
-    written = true;
-    await syncDirectory(directory);
-  } catch (error) {
-    if (!isNodeError(error, "EEXIST")) throw error;
-  } finally {
-    await unlink(temporaryPath).catch((error) => {
-      if (!isNodeError(error, "ENOENT")) throw error;
-    });
-  }
-  return written;
-}
-async function syncDirectory(directory) {
-  const handle = await open(directory, "r");
-  try {
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-}
-function isNodeError(error, code) {
-  return error !== null && typeof error === "object" && "code" in error && error.code === code;
-}
-
-// src/candidate-execution/dispose.ts
-async function disposePreparedAgentCandidateExecution(prepared, options = {}) {
-  const initialState = assertPreparedCandidateIntegrity(prepared);
-  const cleanupTimeoutMs = options.cleanupTimeoutMs ?? initialState.cleanupTimeoutMs;
-  if (cleanupTimeoutMs > initialState.cleanupTimeoutMs) {
-    throw new Error("disposal cleanup timeout exceeds the frozen preparation bound");
-  }
-  const cleanupDeadlineAtMs = candidateCleanupDeadline(cleanupTimeoutMs);
-  const state = beginPreparedCandidateDisposal(prepared);
-  const cleanup = [];
-  if (state.memory.mode === "isolated") {
-    const reservation = state.memoryReservation;
-    if (!reservation) throw new Error("isolated memory reservation is missing");
-    cleanup.push(
-      withinCandidateCleanupDeadline(
-        async () => {
-          const closed = await state.ports.memory.close({
-            executionId: state.executionId,
-            preparationId: reservation.preparationId,
-            accessDigest: reservation.accessDigest,
-            effectiveNamespace: reservation.effectiveNamespace,
-            reason: "abandoned"
-          });
-          if (closed.closed !== true || Object.keys(closed).some((key) => key !== "closed")) {
-            throw new Error("abandoned isolated memory access did not acknowledge closure");
-          }
-        },
-        cleanupDeadlineAtMs,
-        "isolated memory disposal"
-      )
-    );
-  }
-  cleanup.push(
-    withinCandidateCleanupDeadline(
-      async () => {
-        const settlement = sealAgentCandidateModelSettlement(
-          await state.ports.models.settleGrant({
-            executionId: state.executionId,
-            preparationId: state.preparationId,
-            grantDigest: state.modelReservation.digest,
-            resolved: state.resolvedModel,
-            reason: "abandoned"
-          }),
-          {
-            preparationId: state.preparationId,
-            grantDigest: state.modelReservation.digest,
-            model: state.resolvedModel.model
-          }
-        );
-        if (settlement.usage.modelCalls !== 0) {
-          throw new Error("unexecuted model reservation unexpectedly contains calls");
-        }
-      },
-      cleanupDeadlineAtMs,
-      "model reservation disposal"
-    )
-  );
-  const results = await Promise.allSettled(cleanup);
-  const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason);
-  if (failures.length > 0) {
-    consumePreparedCandidateExecution(prepared, "disposal-failed");
-    throw new AggregateError(failures, "candidate preparation disposal failed");
-  }
-  consumePreparedCandidateExecution(prepared, "disposed");
-  return Object.freeze({ disposed: true });
-}
-
-// src/candidate-execution/recover.ts
-import {
-  agentCandidateExecutionPlanMaterialSchema,
-  agentCandidateMaterializationReceiptSchema
-} from "@tangle-network/agent-interface";
-async function recoverExpiredAgentCandidateExecution(options) {
-  const record = await options.claimStore.getAttempt(options.attempt);
-  if (!record) throw new Error("candidate execution recovery attempt is missing");
-  if (record.terminal) {
-    return Object.freeze({ finished: false, terminal: record.terminal, exactReplay: true });
-  }
-  const cleanupTimeoutMs = candidateCleanupTimeout(
-    options.cleanupTimeoutMs ?? record.claim.cleanup.cleanupTimeoutMs
-  );
-  if (cleanupTimeoutMs > record.claim.cleanup.cleanupTimeoutMs) {
-    throw new Error("recovery cleanup timeout exceeds the frozen preparation bound");
-  }
-  const now = options.now ?? Date.now;
-  if (now() < record.claim.leaseExpiresAtMs) {
-    throw new Error("candidate execution lease has not expired");
-  }
-  const cleanupDeadlineAtMs = candidateCleanupDeadline(cleanupTimeoutMs);
-  const recoveryTraceStore = new RecoveryAgentCandidateTraceStore(options.traceStore);
-  const preparation = withinCandidateCleanupDeadline(
-    () => readRecoveryPreparation(record.claim, options.outputArtifacts),
-    cleanupDeadlineAtMs,
-    "expired candidate preparation evidence read"
-  );
-  const processClosure = withinCandidateCleanupDeadline(
-    async (cleanupSignal) => {
-      const stopped = await options.executor.stop(
-        {
-          executionId: record.claim.executionId,
-          executionPlanDigest: record.claim.executionPlanDigest
-        },
-        {
-          traceStore: recoveryTraceStore,
-          reason: "failed",
-          signal: cleanupSignal,
-          deadlineAtMs: cleanupDeadlineAtMs
-        }
-      );
-      sealAgentCandidateExecutorStopAcknowledgement(stopped);
-      if (options.executor.dispose) {
-        const disposed = await options.executor.dispose(
-          {
-            executionId: record.claim.executionId,
-            executionPlanDigest: record.claim.executionPlanDigest
-          },
-          { signal: cleanupSignal }
-        );
-        if (disposed.disposed !== true || Object.keys(disposed).some((key) => key !== "disposed")) {
-          throw new Error("expired candidate executor did not acknowledge resource disposal");
-        }
-      }
-      return { stopped: true };
-    },
-    cleanupDeadlineAtMs,
-    "expired candidate process termination"
-  );
-  const modelClosure = withinCandidateCleanupDeadline(
-    async () => sealAgentCandidateModelSettlement(
-      await options.ports.models.settleGrant({
-        executionId: record.claim.executionId,
-        preparationId: record.claim.cleanup.preparationId,
-        grantDigest: record.claim.cleanup.modelGrantDigest,
-        resolved: record.claim.cleanup.resolvedModel,
-        reason: "failed"
-      }),
-      {
-        preparationId: record.claim.cleanup.preparationId,
-        grantDigest: record.claim.cleanup.modelGrantDigest,
-        model: record.claim.cleanup.resolvedModel.model
-      }
-    ),
-    cleanupDeadlineAtMs,
-    "expired candidate model settlement"
-  );
-  const memoryClosure = record.claim.cleanup.memory ? withinCandidateCleanupDeadline(
-    async () => {
-      const memory2 = record.claim.cleanup.memory;
-      if (!memory2) throw new Error("expired candidate memory handle is missing");
-      const closed = await options.ports.memory.close({
-        executionId: record.claim.executionId,
-        preparationId: record.claim.cleanup.preparationId,
-        accessDigest: memory2.accessDigest,
-        effectiveNamespace: memory2.effectiveNamespace,
-        reason: "failed"
-      });
-      if (closed.closed !== true || Object.keys(closed).some((key) => key !== "closed")) {
-        throw new Error("expired candidate memory did not acknowledge closure");
-      }
-      return { closed: true };
-    },
-    cleanupDeadlineAtMs,
-    "expired candidate memory closure"
-  ) : void 0;
-  const closureOutcomes = Promise.allSettled([
-    modelClosure,
-    memoryClosure ?? Promise.resolve(void 0)
-  ]);
-  const [preparationOutcome, processOutcome] = await Promise.allSettled([
-    preparation,
-    processClosure
-  ]);
-  const failures = [preparationOutcome, processOutcome].filter((outcome) => outcome.status === "rejected").map((outcome) => outcome.reason);
-  const [modelOutcome, memoryOutcome] = await closureOutcomes;
-  for (const outcome of [modelOutcome, memoryOutcome]) {
-    if (outcome.status === "rejected") failures.push(outcome.reason);
-  }
-  if (failures.length > 0) {
-    throw new AggregateError(failures, "expired candidate cleanup could not be proven");
-  }
-  if (modelOutcome.status !== "fulfilled") {
-    throw new Error("expired candidate model settlement was not recovered");
-  }
-  const model = modelOutcome.value;
-  const modelSettlement = await withinCandidateCleanupDeadline(
-    () => persistCandidateModelSettlementEvidence(
-      {
-        executionId: record.claim.executionId,
-        executionPlanDigest: record.claim.executionPlanDigest,
-        resolvedModel: record.claim.cleanup.resolvedModel
-      },
-      model,
-      options.outputArtifacts
-    ),
-    cleanupDeadlineAtMs,
-    "expired candidate model-settlement persistence"
-  );
-  const failureClass = record.phase === "claimed" && model.usage.modelCalls === 0 ? "pre-model-infrastructure" : "unknown";
-  const failureEvidence = await withinCandidateCleanupDeadline(
-    () => persistCandidateOutputArtifact(options.outputArtifacts, {
-      executionId: record.claim.executionId,
-      purpose: "failure-evidence",
-      bytes: canonicalCandidateBytes({
-        kind: "agent-candidate-recovery-failure",
-        executionId: record.claim.executionId,
-        attempt: record.claim.attempt,
-        bundleDigest: record.claim.bundleDigest,
-        executionPlanDigest: record.claim.executionPlanDigest,
-        materializationReceiptDigest: record.claim.preparationEvidence.materializationReceipt.sha256,
-        failureClass,
-        processStopped: true,
-        modelSettlementDigest: modelSettlement.digest,
-        memoryClosed: record.claim.cleanup.memory !== void 0
-      })
-    }),
-    cleanupDeadlineAtMs,
-    "expired candidate failure-evidence persistence"
-  );
-  const memory = record.claim.cleanup.memory;
-  return await options.claimStore.recoverExpired(options.attempt, {
-    failureClass,
-    usage: model.usage,
-    modelSettlement: modelSettlement.artifact,
-    failureEvidence,
-    process: {
-      stopped: true,
-      executionPlanDigest: record.claim.executionPlanDigest
-    },
-    model: {
-      closed: true,
-      preparationId: record.claim.cleanup.preparationId,
-      grantDigest: record.claim.cleanup.modelGrantDigest
-    },
-    ...memory ? {
-      memory: {
-        closed: true,
-        preparationId: record.claim.cleanup.preparationId,
-        accessDigest: memory.accessDigest,
-        effectiveNamespace: memory.effectiveNamespace
-      }
-    } : {}
-  });
-}
-async function readRecoveryPreparation(claim, artifacts) {
-  const [planBytes, receiptBytes] = await Promise.all([
-    readVerifiedArtifact(claim.preparationEvidence.executionPlan, artifacts),
-    readVerifiedArtifact(claim.preparationEvidence.materializationReceipt, artifacts)
-  ]);
-  const plan = agentCandidateExecutionPlanMaterialSchema.parse(
-    parseCanonicalBytes(planBytes, "plan")
-  );
-  if (claim.preparationEvidence.executionPlan.sha256 !== claim.executionPlanDigest) {
-    throw new Error("recovery execution plan artifact does not match the claimed digest");
-  }
-  const receiptMaterial = parseCanonicalBytes(receiptBytes, "materialization receipt");
-  const receipt = agentCandidateMaterializationReceiptSchema.parse({
-    ...receiptMaterial,
-    digest: claim.preparationEvidence.materializationReceipt.sha256
-  });
-  if (receipt.bundleDigest !== claim.bundleDigest || receipt.executionPlan.digest !== claim.executionPlanDigest || plan.runCell.bundleDigest !== claim.bundleDigest || plan.executionId !== claim.executionId) {
-    throw new Error("recovery preparation evidence does not match the durable claim");
-  }
-  return { plan, receipt };
-}
-function parseCanonicalBytes(bytes, label) {
-  let parsed;
-  try {
-    parsed = JSON.parse(Buffer.from(bytes).toString("utf8"));
-  } catch (error) {
-    throw new Error(`candidate recovery ${label} is not JSON`, { cause: error });
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`candidate recovery ${label} must be an object`);
-  }
-  if (!Buffer.from(canonicalCandidateBytes(parsed)).equals(Buffer.from(bytes))) {
-    throw new Error(`candidate recovery ${label} bytes are not canonical`);
-  }
-  return parsed;
-}
-
-export {
-  buildAgentCandidateBundle,
-  FileAgentCandidateExecutionClaimStore,
-  disposePreparedAgentCandidateExecution,
-  recoverExpiredAgentCandidateExecution
-};
-//# sourceMappingURL=chunk-CTRA64LY.js.map