@tangle-network/agent-runtime 0.102.2 → 0.103.1

package/dist/{chunk-CK76OZPM.js → chunk-SNSMRT6H.js}

@@ -1,10 +1,9 @@
 import {
   sealAgentCandidateBundle
-} from "./chunk-KSM6GFHP.js";
+} from "./chunk-B7K7V22Y.js";
 import {
   RecoveryAgentCandidateTraceStore,
   applyExactAgentProfileDiff,
-  assertExactObjectKeys,
   assertPreparedCandidateIntegrity,
   assertRecoveryMatchesStaged,
   assertTerminalAllowedInPhase,
@@ -15,11 +14,9 @@ import {
   candidateCleanupDeadline,
   candidateCleanupTimeout,
   canonicalCandidateBytes,
-  canonicalCandidateDigest,
   consumePreparedCandidateExecution,
   embeddedCandidateArtifact,
   freezeGenericAgentCandidateProfile,
-  immutableCandidateValue,
   parseExactAgentProfile,
   parseExactAgentProfileDiff,
   parseExactCandidateProfile,
@@ -34,9 +31,8 @@ import {
   sealAgentCandidateModelSettlement,
   sealTerminalDigest,
   terminalRecord,
-  usdToNanos,
   withinCandidateCleanupDeadline
-} from "./chunk-LJLG734E.js";
+} from "./chunk-SBTWKPVR.js";
 
 // src/candidate-execution/builder.ts
 import { verifyCodeSurface } from "@tangle-network/agent-eval/campaign";
@@ -253,19 +249,19 @@ var FileAgentCandidateExecutionClaimStore = class {
   }
   async recoverExpired(requestedAttempt, evidence) {
     const attempt = sealAttemptRef(requestedAttempt);
-    const record2 = await this.storedAttempt(attempt);
-    if (!record2) throw new Error("candidate execution recovery does not name an acquired attempt");
-    const recovered = recoveredTerminalRecord(record2.claim, record2.phase, evidence);
-    if (record2.staged) assertRecoveryMatchesStaged(record2.staged, recovered);
-    const requestedDigest = record2.staged?.terminalDigest ?? recovered.terminalDigest;
-    if (record2.terminal) return rejectedFinish(record2.terminal, requestedDigest);
-    assertExpiredLease(record2.claim.leaseExpiresAtMs, this.now());
-    let staged = record2.staged;
+    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 = record2.phase === "claimed" ? 1 : 2;
+      const transition = record.phase === "claimed" ? 1 : 2;
       const didStage = await writeRecordIfAbsent(
         this.directory,
-        this.transitionPath(record2.claim, transition),
+        this.transitionPath(record.claim, transition),
         {
           kind: "candidate-execution-pending-terminal",
           terminal: recovered
@@ -274,7 +270,7 @@ var FileAgentCandidateExecutionClaimStore = class {
       if (didStage) {
         staged = recovered;
       } else {
-        const winner2 = await this.transitionState(record2.claim);
+        const winner2 = await this.transitionState(record.claim);
         if (!winner2.staged) {
           throw new Error(
             "candidate execution recovery lost terminal staging to a phase transition"
@@ -291,7 +287,7 @@ var FileAgentCandidateExecutionClaimStore = class {
     if (didFinish) return Object.freeze({ finished: true, terminal: staged });
     const winner = await readTerminal(terminalPath);
     assertSameSlot(winner, attempt, terminalPath);
-    assertTerminalMatchesClaim(winner, record2.claim, terminalPath);
+    assertTerminalMatchesClaim(winner, record.claim, terminalPath);
     assertTerminalMatchesStaged(winner, staged, terminalPath);
     return rejectedFinish(winner, staged.terminalDigest);
   }
@@ -355,12 +351,12 @@ var FileAgentCandidateExecutionClaimStore = class {
     return join(this.directory, `${claimSlot(claim)}.transition-${ordinal}.json`);
   }
 };
-async function writeRecordIfAbsent(directory, destination, record2, options = {}) {
+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(record2)), Buffer.from("\n")])
+      Buffer.concat([Buffer.from(canonicalCandidateBytes(record)), Buffer.from("\n")])
     );
     await handle.sync();
   } finally {
@@ -462,356 +458,31 @@ async function disposePreparedAgentCandidateExecution(prepared, options = {}) {
   return Object.freeze({ disposed: true });
 }
 
-// src/candidate-execution/protected-model-port.ts
-var MAX_RECENT_SETTLEMENTS = 4096;
-var RECOVERED_SETTLEMENT_RETENTION_MS = 15 * 60 * 1e3;
-function createProtectedAgentCandidateModelPort(options) {
-  const gatewayDomain = assertGatewayDomain(options.gatewayDomain);
-  const activationEnvNames = exactEnvironmentNames(options.activationEnvNames);
-  const reservations = /* @__PURE__ */ new Map();
-  const recentSettlements = /* @__PURE__ */ new Map();
-  return {
-    resolve: async (input) => {
-      const request = immutableCandidateValue(input);
-      const resolved = validateResolvedModel(await options.resolveModel(request), request);
-      return immutableCandidateValue(resolved);
-    },
-    reserveGrant: async (input) => {
-      pruneExpiredState(reservations, recentSettlements, Date.now());
-      const request = immutableCandidateValue(input);
-      validateReserveInput(request);
-      const requestDigest = canonicalCandidateDigest(request);
-      const key = reservationKey(request.executionId, request.preparationId);
-      if (recentSettlements.has(key)) {
-        throw new Error("protected model reservation is already settled");
-      }
-      const previous = reservations.get(key);
-      if (previous && previous.requestDigest !== requestDigest) {
-        throw new Error("protected model reservation retry changed immutable input");
-      }
-      const reservation = validateReservation(
-        await options.client.reserve(request),
-        request,
-        gatewayDomain
-      );
-      const responseDigest = canonicalCandidateDigest(reservation);
-      if (recentSettlements.has(key)) {
-        throw new Error("protected model reservation completed after the grant was settled");
-      }
-      const recorded = previous ?? reservations.get(key);
-      if (recorded && recorded.requestDigest !== requestDigest) {
-        throw new Error("protected model reservation retry changed immutable input");
-      }
-      if (recorded && recorded.responseDigest !== responseDigest) {
-        throw new Error("protected model reservation retry returned different evidence");
-      }
-      if (!recorded) {
-        reservations.set(key, {
-          requestDigest,
-          responseDigest,
-          executionId: request.executionId,
-          preparationId: request.preparationId,
-          grantDigest: reservation.digest,
-          expiresAtMs: request.expiresAtMs,
-          resolved: immutableCandidateValue(request.resolved),
-          limits: immutableCandidateValue(request.limits),
-          maxCostUsdNanos: usdToNanos(request.limits.maxCostUsd, "reserved maxCostUsd"),
-          activation: "reserved"
-        });
-      }
-      return reservation;
-    },
-    activateGrant: async (input) => {
-      pruneExpiredState(reservations, recentSettlements, Date.now());
-      const request = immutableCandidateValue(input);
-      const key = reservationKey(request.executionId, request.preparationId);
-      if (recentSettlements.has(key)) throw new Error("protected model grant is already settled");
-      const state = reservations.get(key);
-      if (!state) throw new Error("protected model grant was not reserved by this port");
-      assertGrantIdentity(state, request);
-      if (state.settlementDigest) throw new Error("protected model grant is already settled");
-      if (state.activation !== "reserved") {
-        throw new Error("protected model grant activation is single-use");
-      }
-      if (!Number.isSafeInteger(request.deadlineAtMs) || request.deadlineAtMs <= 0) {
-        throw new Error("protected model activation deadline must be a positive safe integer");
-      }
-      if (request.deadlineAtMs <= Date.now()) {
-        throw new Error("protected model activation deadline must be in the future");
-      }
-      if (request.deadlineAtMs > state.expiresAtMs) {
-        throw new Error("protected model activation deadline exceeds the reserved expiry");
-      }
-      state.activation = "activating";
-      try {
-        const activation = validateActivation(
-          await options.client.activate(request),
-          state.limits.maxModelCalls === 0 ? [] : activationEnvNames
-        );
-        if (recentSettlements.has(key) || reservations.get(key) !== state) {
-          throw new Error("protected model grant settled while activation was in flight");
-        }
-        state.activation = "activated";
-        return activation;
-      } catch (error) {
-        state.activation = "reserved";
-        throw error;
-      }
-    },
-    settleGrant: async (input) => {
-      const now = Date.now();
-      pruneExpiredState(reservations, recentSettlements, now);
-      const request = immutableCandidateValue(input);
-      const key = reservationKey(request.executionId, request.preparationId);
-      const state = reservations.get(key);
-      if (state) assertGrantIdentity(state, request);
-      const remembered = state ?? recentSettlements.get(key);
-      if (remembered?.settlementReason && remembered.settlementReason !== request.reason) {
-        throw new Error("protected model settlement retry changed the termination reason");
-      }
-      const sealed = sealAgentCandidateModelSettlement(await options.client.settle(request), {
-        preparationId: request.preparationId,
-        grantDigest: request.grantDigest,
-        model: request.resolved.model
-      });
-      if (state) assertWithinReservedLimits(sealed.usage, state);
-      const settlementDigest = canonicalCandidateDigest(sealed.value);
-      if (remembered?.settlementDigest && remembered.settlementDigest !== settlementDigest) {
-        throw new Error("protected model settlement retry returned a different final ledger");
-      }
-      if (remembered?.settlementReason && remembered.settlementReason !== request.reason) {
-        throw new Error("protected model settlement retry changed the termination reason");
-      }
-      const expiresAtMs = state?.expiresAtMs ?? now + RECOVERED_SETTLEMENT_RETENTION_MS;
-      if (state) {
-        state.settlementDigest = settlementDigest;
-        state.settlementReason = request.reason;
-      }
-      reservations.delete(key);
-      rememberSettlement(recentSettlements, key, {
-        settlementDigest,
-        settlementReason: request.reason,
-        expiresAtMs
-      });
-      return sealed.value;
-    }
-  };
-}
-function validateReserveInput(input) {
-  if (!Number.isSafeInteger(input.expiresAtMs) || input.expiresAtMs <= 0) {
-    throw new Error("protected model reservation expiry must be a positive safe integer");
-  }
-  if (input.expiresAtMs <= Date.now()) {
-    throw new Error("protected model reservation expiry must be in the future");
-  }
-  for (const [name, value] of [
-    ["maxModelCalls", input.limits.maxModelCalls],
-    ["maxInputTokens", input.limits.maxInputTokens],
-    ["maxOutputTokens", input.limits.maxOutputTokens]
-  ]) {
-    if (!Number.isSafeInteger(value) || value < 0) {
-      throw new Error(`protected model reservation ${name} must be a nonnegative safe integer`);
-    }
-  }
-  usdToNanos(input.limits.maxCostUsd, "reserved maxCostUsd");
-}
-function validateReservation(value, expected, gatewayDomain) {
-  const source = exactRecord(
-    value,
-    ["preparationId", "digest", "expiresAtMs", "enforcedLimits", "network"],
-    "protected model reservation response"
-  );
-  if (source.preparationId !== expected.preparationId) {
-    throw new Error("protected model reservation response changed preparation identity");
-  }
-  if (!isSha256Digest(source.digest)) {
-    throw new Error("protected model reservation response has an invalid digest");
-  }
-  if (source.expiresAtMs !== expected.expiresAtMs) {
-    throw new Error("protected model reservation response changed expiry");
-  }
-  exactRecord(
-    source.enforcedLimits,
-    ["maxModelCalls", "maxInputTokens", "maxOutputTokens", "maxCostUsd"],
-    "protected model reservation enforced limits"
-  );
-  if (canonicalCandidateDigest(source.enforcedLimits) !== canonicalCandidateDigest(expected.limits)) {
-    throw new Error("protected model reservation response changed enforced limits");
-  }
-  const network = validateReservationNetwork(
-    source.network,
-    expected.limits.maxModelCalls,
-    gatewayDomain
-  );
-  return immutableCandidateValue({
-    preparationId: source.preparationId,
-    digest: source.digest,
-    expiresAtMs: source.expiresAtMs,
-    enforcedLimits: source.enforcedLimits,
-    network
-  });
-}
-function validateReservationNetwork(value, maxModelCalls, gatewayDomain) {
-  if (maxModelCalls === 0) {
-    const source2 = exactRecord(value, ["mode"], "protected model reservation network");
-    if (source2.mode !== "disabled") {
-      throw new Error("zero-call protected model reservation must disable gateway access");
-    }
-    return { mode: "disabled" };
-  }
-  const source = exactRecord(value, ["mode", "domains"], "protected model reservation network");
-  if (source.mode !== "gateway-only") {
-    throw new Error("protected model reservation must allow only its model gateway");
-  }
-  if (!Array.isArray(source.domains) || source.domains.length !== 1 || source.domains[0] !== gatewayDomain) {
-    throw new Error("protected model reservation returned an unexpected gateway domain");
-  }
-  return { mode: "gateway-only", domains: [gatewayDomain] };
-}
-function validateActivation(value, expectedNames) {
-  const source = exactRecord(value, ["env"], "protected model activation response");
-  const env = record(source.env, "protected model activation environment");
-  const actualNames = Object.keys(env).sort();
-  if (actualNames.length !== expectedNames.length || actualNames.some((name, index) => name !== expectedNames[index])) {
-    throw new Error("protected model activation returned unexpected environment names");
-  }
-  const detached = /* @__PURE__ */ Object.create(null);
-  for (const name of expectedNames) {
-    const value2 = env[name];
-    if (typeof value2 !== "string" || value2.length < 8 || value2.length > 65536) {
-      throw new Error(`protected model activation ${name} must be a non-empty protected value`);
-    }
-    detached[name] = value2;
-  }
-  return Object.freeze({ env: Object.freeze(detached) });
-}
-function validateResolvedModel(value, expected) {
-  const source = exactRecord(
-    value,
-    ["requested", "provider", "model", "snapshot", "reasoningEffort"],
-    "resolved candidate model"
-  );
-  if (source.requested !== expected.requested) {
-    throw new Error("model resolver changed the evaluator-owned request");
-  }
-  if (source.reasoningEffort !== expected.reasoningEffort) {
-    throw new Error("model resolver changed the evaluator-owned reasoning effort");
-  }
-  for (const name of ["requested", "provider", "model", "snapshot"]) {
-    if (typeof source[name] !== "string" || source[name].length === 0) {
-      throw new Error(`resolved candidate model ${name} must be non-empty`);
-    }
-  }
-  return source;
-}
-function assertGrantIdentity(expected, actual) {
-  if (actual.executionId !== expected.executionId || actual.preparationId !== expected.preparationId || actual.grantDigest !== expected.grantDigest || canonicalCandidateDigest(actual.resolved) !== canonicalCandidateDigest(expected.resolved)) {
-    throw new Error("protected model grant input does not match its immutable reservation");
-  }
-}
-function assertWithinReservedLimits(usage, reservation) {
-  for (const [name, actual, limit] of [
-    ["model calls", usage.modelCalls, reservation.limits.maxModelCalls],
-    ["input tokens", usage.inputTokens, reservation.limits.maxInputTokens],
-    ["output tokens", usage.outputTokens, reservation.limits.maxOutputTokens],
-    ["cost USD nanos", usage.costUsdNanos, reservation.maxCostUsdNanos]
-  ]) {
-    if (actual > limit) {
-      throw new Error(`protected model settlement ${name} ${actual} exceeds reserved ${limit}`);
-    }
-  }
-}
-function exactEnvironmentNames(values) {
-  if (values.length === 0) {
-    throw new Error("protected model activation environment names must not be empty");
-  }
-  const names = [...values].sort();
-  if (new Set(names).size !== names.length) {
-    throw new Error("protected model activation environment names must be unique");
-  }
-  for (const name of names) {
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || ["__proto__", "constructor", "prototype"].includes(name)) {
-      throw new Error(`protected model activation environment name is invalid: ${name}`);
-    }
-  }
-  return Object.freeze(names);
-}
-function assertGatewayDomain(value) {
-  if (value.length > 253 || value !== value.toLowerCase() || value.endsWith(".") || value.includes(":") || value === "localhost" || value.endsWith(".localhost") || value === "metadata.google" || value === "metadata.google.internal") {
-    throw new Error("protected model gateway must be an exact lowercase public DNS name");
-  }
-  const labels = value.split(".");
-  if (labels.length < 2 || !labels.every(
-    (label) => label.length >= 1 && label.length <= 63 && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(label)
-  ) || !/[a-z]/.test(labels.at(-1) ?? "")) {
-    throw new Error("protected model gateway must be an exact lowercase public DNS name");
-  }
-  return value;
-}
-function reservationKey(executionId, preparationId) {
-  return canonicalCandidateDigest({ executionId, preparationId });
-}
-function pruneExpiredState(reservations, settlements, now) {
-  for (const [key, value] of reservations) {
-    if (value.expiresAtMs <= now) reservations.delete(key);
-  }
-  for (const [key, value] of settlements) {
-    if (value.expiresAtMs <= now) settlements.delete(key);
-  }
-}
-function rememberSettlement(settlements, key, value) {
-  settlements.delete(key);
-  settlements.set(key, value);
-  while (settlements.size > MAX_RECENT_SETTLEMENTS) {
-    const oldest = settlements.keys().next().value;
-    if (oldest === void 0) return;
-    settlements.delete(oldest);
-  }
-}
-function isSha256Digest(value) {
-  return typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value);
-}
-function exactRecord(value, keys, label) {
-  const source = record(value, label);
-  assertExactObjectKeys(source, keys, label);
-  return source;
-}
-function record(value, label) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${label} must be an object`);
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw new Error(`${label} must be a plain object`);
-  }
-  return value;
-}
-
 // src/candidate-execution/recover.ts
 import {
   agentCandidateExecutionPlanMaterialSchema,
   agentCandidateMaterializationReceiptSchema
 } from "@tangle-network/agent-interface";
 async function recoverExpiredAgentCandidateExecution(options) {
-  const record2 = await options.claimStore.getAttempt(options.attempt);
-  if (!record2) throw new Error("candidate execution recovery attempt is missing");
-  if (record2.terminal) {
-    return Object.freeze({ finished: false, terminal: record2.terminal, exactReplay: true });
+  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 ?? record2.claim.cleanup.cleanupTimeoutMs
+    options.cleanupTimeoutMs ?? record.claim.cleanup.cleanupTimeoutMs
   );
-  if (cleanupTimeoutMs > record2.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() < record2.claim.leaseExpiresAtMs) {
+  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(record2.claim, options.outputArtifacts),
+    () => readRecoveryPreparation(record.claim, options.outputArtifacts),
     cleanupDeadlineAtMs,
     "expired candidate preparation evidence read"
   );
@@ -819,8 +490,8 @@ async function recoverExpiredAgentCandidateExecution(options) {
     async (cleanupSignal) => {
       const stopped = await options.executor.stop(
         {
-          executionId: record2.claim.executionId,
-          executionPlanDigest: record2.claim.executionPlanDigest
+          executionId: record.claim.executionId,
+          executionPlanDigest: record.claim.executionPlanDigest
         },
         {
           traceStore: recoveryTraceStore,
@@ -833,8 +504,8 @@ async function recoverExpiredAgentCandidateExecution(options) {
       if (options.executor.dispose) {
         const disposed = await options.executor.dispose(
           {
-            executionId: record2.claim.executionId,
-            executionPlanDigest: record2.claim.executionPlanDigest
+            executionId: record.claim.executionId,
+            executionPlanDigest: record.claim.executionPlanDigest
           },
           { signal: cleanupSignal }
         );
@@ -850,28 +521,28 @@ async function recoverExpiredAgentCandidateExecution(options) {
   const modelClosure = withinCandidateCleanupDeadline(
     async () => sealAgentCandidateModelSettlement(
       await options.ports.models.settleGrant({
-        executionId: record2.claim.executionId,
-        preparationId: record2.claim.cleanup.preparationId,
-        grantDigest: record2.claim.cleanup.modelGrantDigest,
-        resolved: record2.claim.cleanup.resolvedModel,
+        executionId: record.claim.executionId,
+        preparationId: record.claim.cleanup.preparationId,
+        grantDigest: record.claim.cleanup.modelGrantDigest,
+        resolved: record.claim.cleanup.resolvedModel,
         reason: "failed"
       }),
       {
-        preparationId: record2.claim.cleanup.preparationId,
-        grantDigest: record2.claim.cleanup.modelGrantDigest,
-        model: record2.claim.cleanup.resolvedModel.model
+        preparationId: record.claim.cleanup.preparationId,
+        grantDigest: record.claim.cleanup.modelGrantDigest,
+        model: record.claim.cleanup.resolvedModel.model
       }
     ),
     cleanupDeadlineAtMs,
     "expired candidate model settlement"
   );
-  const memoryClosure = record2.claim.cleanup.memory ? withinCandidateCleanupDeadline(
+  const memoryClosure = record.claim.cleanup.memory ? withinCandidateCleanupDeadline(
     async () => {
-      const memory2 = record2.claim.cleanup.memory;
+      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: record2.claim.executionId,
-        preparationId: record2.claim.cleanup.preparationId,
+        executionId: record.claim.executionId,
+        preparationId: record.claim.cleanup.preparationId,
         accessDigest: memory2.accessDigest,
         effectiveNamespace: memory2.effectiveNamespace,
         reason: "failed"
@@ -907,9 +578,9 @@ async function recoverExpiredAgentCandidateExecution(options) {
   const modelSettlement = await withinCandidateCleanupDeadline(
     () => persistCandidateModelSettlementEvidence(
       {
-        executionId: record2.claim.executionId,
-        executionPlanDigest: record2.claim.executionPlanDigest,
-        resolvedModel: record2.claim.cleanup.resolvedModel
+        executionId: record.claim.executionId,
+        executionPlanDigest: record.claim.executionPlanDigest,
+        resolvedModel: record.claim.cleanup.resolvedModel
       },
       model,
       options.outputArtifacts
@@ -917,28 +588,28 @@ async function recoverExpiredAgentCandidateExecution(options) {
     cleanupDeadlineAtMs,
     "expired candidate model-settlement persistence"
   );
-  const failureClass = record2.phase === "claimed" && model.usage.modelCalls === 0 ? "pre-model-infrastructure" : "unknown";
+  const failureClass = record.phase === "claimed" && model.usage.modelCalls === 0 ? "pre-model-infrastructure" : "unknown";
   const failureEvidence = await withinCandidateCleanupDeadline(
     () => persistCandidateOutputArtifact(options.outputArtifacts, {
-      executionId: record2.claim.executionId,
+      executionId: record.claim.executionId,
       purpose: "failure-evidence",
       bytes: canonicalCandidateBytes({
         kind: "agent-candidate-recovery-failure",
-        executionId: record2.claim.executionId,
-        attempt: record2.claim.attempt,
-        bundleDigest: record2.claim.bundleDigest,
-        executionPlanDigest: record2.claim.executionPlanDigest,
-        materializationReceiptDigest: record2.claim.preparationEvidence.materializationReceipt.sha256,
+        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: record2.claim.cleanup.memory !== void 0
+        memoryClosed: record.claim.cleanup.memory !== void 0
       })
     }),
     cleanupDeadlineAtMs,
     "expired candidate failure-evidence persistence"
   );
-  const memory = record2.claim.cleanup.memory;
+  const memory = record.claim.cleanup.memory;
   return await options.claimStore.recoverExpired(options.attempt, {
     failureClass,
     usage: model.usage,
@@ -946,17 +617,17 @@ async function recoverExpiredAgentCandidateExecution(options) {
     failureEvidence,
     process: {
       stopped: true,
-      executionPlanDigest: record2.claim.executionPlanDigest
+      executionPlanDigest: record.claim.executionPlanDigest
     },
     model: {
       closed: true,
-      preparationId: record2.claim.cleanup.preparationId,
-      grantDigest: record2.claim.cleanup.modelGrantDigest
+      preparationId: record.claim.cleanup.preparationId,
+      grantDigest: record.claim.cleanup.modelGrantDigest
     },
     ...memory ? {
       memory: {
         closed: true,
-        preparationId: record2.claim.cleanup.preparationId,
+        preparationId: record.claim.cleanup.preparationId,
         accessDigest: memory.accessDigest,
         effectiveNamespace: memory.effectiveNamespace
       }
@@ -1004,7 +675,6 @@ export {
   buildAgentCandidateBundle,
   FileAgentCandidateExecutionClaimStore,
   disposePreparedAgentCandidateExecution,
-  createProtectedAgentCandidateModelPort,
   recoverExpiredAgentCandidateExecution
 };
-//# sourceMappingURL=chunk-CK76OZPM.js.map
+//# sourceMappingURL=chunk-SNSMRT6H.js.map