@tangle-network/agent-runtime 0.94.12 → 0.95.0

package/dist/{chunk-FTXM7Q7P.js → chunk-6YBA64Z2.js}

@@ -1,12 +1,7 @@
 import {
-  CLAIM_FORMAT_VERSION,
-  PENDING_FORMAT_VERSION,
-  PHASE_FORMAT_VERSION,
   RecoveryAgentCandidateTraceStore,
-  TERMINAL_FORMAT_VERSION,
   applyExactAgentProfileDiff,
   assertExactObjectKeys,
-  assertNoGitIndirection,
   assertPreparedCandidateIntegrity,
   assertRecoveryMatchesStaged,
   assertTerminalAllowedInPhase,
@@ -18,68 +13,63 @@ import {
   candidateCleanupTimeout,
   canonicalCandidateBytes,
   canonicalCandidateDigest,
-  captureMaterializedWorkspace,
   consumePreparedCandidateExecution,
-  deepFreezeCandidate,
   embeddedCandidateArtifact,
   freezeGenericAgentCandidateProfile,
   immutableCandidateValue,
+  omitTopLevelDigest,
   parseExactAgentProfile,
   parseExactAgentProfileDiff,
   parseExactCandidateProfile,
   persistCandidateModelSettlementEvidence,
   persistCandidateOutputArtifact,
-  readCandidateGitTreeFiles,
+  readVerifiedArtifact,
   recoveredTerminalRecord,
   rejectedFinish,
   rejectedStage,
   requireStagedTerminal,
-  runCandidateGit,
-  sealAgentCandidateBundle,
-  sealAgentCandidateExecutorFinalCapture,
+  sealAgentCandidateExecutorStopAcknowledgement,
   sealAgentCandidateModelSettlement,
   sealTerminalDigest,
-  sha256Bytes,
   terminalRecord,
   usdToNanos,
-  verifyBytes,
-  verifyMaterializedWorkspace,
   withinCandidateCleanupDeadline
-} from "./chunk-37V4KQDC.js";
+} from "./chunk-WTZ37EQY.js";
 
 // src/candidate-execution/builder.ts
 import { verifyCodeSurface } from "@tangle-network/agent-eval/campaign";
-function buildAgentCandidateBundle(input) {
-  if (Object.hasOwn(input.lineage, "profileDiffIds")) {
-    throw new Error("profileDiffIds is derived from the profile source and cannot be supplied");
+
+// src/candidate-execution/bundle.ts
+import { agentCandidateBundleSchema } from "@tangle-network/agent-interface";
+function sealAgentCandidateBundle(input) {
+  const digest = canonicalCandidateDigest(input);
+  const parsed = agentCandidateBundleSchema.parse({ ...input, digest });
+  const parsedDigest = canonicalCandidateDigest(omitTopLevelDigest(parsed));
+  if (parsedDigest !== digest) {
+    throw new Error("candidate bundle changed while validating its canonical wire shape");
   }
-  const compiledProfile = compileCandidateProfile(input.profile);
-  const profileDiffIds = compiledProfile.profileDiffIds;
+  return immutableCandidateValue(parsed);
+}
+
+// src/candidate-execution/builder.ts
+function buildAgentCandidateBundle(input) {
   const bundle = {
-    schemaVersion: 1,
     kind: "agent-candidate-bundle",
     digestAlgorithm: "rfc8785-sha256",
-    profile: compiledProfile.profile,
+    profile: compileCandidateProfile(input.profile),
     code: compileCandidateCode(input.code),
     execution: input.execution,
-    ...input.knowledge ? { knowledge: input.knowledge } : {},
-    memory: input.memory,
-    lineage: {
-      ...input.lineage,
-      ...profileDiffIds.length > 0 ? { profileDiffIds } : {}
-    }
+    ...input.knowledge !== void 0 ? { knowledge: input.knowledge } : {},
+    memory: input.memory
   };
   return sealAgentCandidateBundle(bundle);
 }
 function compileCandidateProfile(source) {
   if (source.kind === "candidate-profile") {
-    return {
-      profile: parseExactCandidateProfile(source.profile),
-      profileDiffIds: []
-    };
+    return parseExactCandidateProfile(source.profile);
   }
   if (source.kind === "profile") {
-    return { profile: freezeGenericAgentCandidateProfile(source.profile), profileDiffIds: [] };
+    return freezeGenericAgentCandidateProfile(source.profile);
   }
   if (source.kind !== "profile-diffs") {
     throw new Error(
@@ -90,13 +80,11 @@ function compileCandidateProfile(source) {
     throw new Error("profile-diffs source requires at least one AgentProfileDiff");
   }
   let profile = parseExactAgentProfile(source.base, "base profile");
-  const profileDiffIds = [];
   for (const [index, inputDiff] of source.diffs.entries()) {
     const diff = parseExactAgentProfileDiff(inputDiff, `profile diff ${index}`);
     profile = applyExactAgentProfileDiff(profile, diff, `profile diff ${index}`);
-    profileDiffIds.push(canonicalCandidateDigest(diff));
   }
-  return { profile: freezeGenericAgentCandidateProfile(profile), profileDiffIds };
+  return freezeGenericAgentCandidateProfile(profile);
 }
 function compileCandidateCode(source) {
   if (source.kind === "disabled" || source.kind === "no-op") return source;
@@ -170,7 +158,6 @@ var FileAgentCandidateExecutionClaimStore = class {
     if (retryFailure) return rejectedRetry(claim, retryFailure);
     const lease = newLease(claim);
     const acquired = await writeRecordIfAbsent(this.directory, claimPath, {
-      version: CLAIM_FORMAT_VERSION,
       ...claim,
       phase: "claimed",
       leaseDigest: leaseDigest(lease)
@@ -201,7 +188,6 @@ var FileAgentCandidateExecutionClaimStore = class {
       this.directory,
       this.transitionPath(stored.claim, 1),
       {
-        version: PHASE_FORMAT_VERSION,
         kind: "candidate-execution-phase",
         executionId: stored.claim.executionId,
         attempt: stored.claim.attempt,
@@ -233,7 +219,6 @@ var FileAgentCandidateExecutionClaimStore = class {
       this.directory,
       this.transitionPath(stored.claim, transition),
       {
-        version: PENDING_FORMAT_VERSION,
         kind: "candidate-execution-pending-terminal",
         terminal
       },
@@ -267,7 +252,6 @@ var FileAgentCandidateExecutionClaimStore = class {
       this.directory,
       terminalPath,
       {
-        version: TERMINAL_FORMAT_VERSION,
         terminal: staged
       },
       this.ownerPublication(stored.claim)
@@ -295,7 +279,6 @@ var FileAgentCandidateExecutionClaimStore = class {
         this.directory,
         this.transitionPath(record2.claim, transition),
         {
-          version: PENDING_FORMAT_VERSION,
           kind: "candidate-execution-pending-terminal",
           terminal: recovered
         }
@@ -315,7 +298,6 @@ var FileAgentCandidateExecutionClaimStore = class {
     }
     const terminalPath = this.terminalPath(attempt);
     const didFinish = await writeRecordIfAbsent(this.directory, terminalPath, {
-      version: TERMINAL_FORMAT_VERSION,
       terminal: staged
     });
     if (didFinish) return Object.freeze({ finished: true, terminal: staged });
@@ -604,7 +586,7 @@ function createProtectedAgentCandidateModelPort(options) {
         grantDigest: request.grantDigest,
         model: request.resolved.model
       });
-      if (state) assertWithinReservedLimits(sealed.fixedUsage, state);
+      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");
@@ -818,6 +800,10 @@ function record(value, label) {
 }
 
 // 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");
@@ -835,12 +821,15 @@ async function recoverExpiredAgentCandidateExecution(options) {
     throw new Error("candidate execution lease has not expired");
   }
   const cleanupDeadlineAtMs = candidateCleanupDeadline(cleanupTimeoutMs);
-  const controller = new AbortController();
-  controller.abort(new Error("recovering an expired candidate execution"));
   const recoveryTraceStore = new RecoveryAgentCandidateTraceStore(options.traceStore);
+  const preparation = withinCandidateCleanupDeadline(
+    () => readRecoveryPreparation(record2.claim, options.outputArtifacts),
+    cleanupDeadlineAtMs,
+    "expired candidate preparation evidence read"
+  );
   const processClosure = withinCandidateCleanupDeadline(
-    async () => {
-      const stopped = await options.executor.stopAndCapture(
+    async (cleanupSignal) => {
+      const stopped = await options.executor.stop(
         {
           executionId: record2.claim.executionId,
           executionPlanDigest: record2.claim.executionPlanDigest
@@ -848,11 +837,23 @@ async function recoverExpiredAgentCandidateExecution(options) {
         {
           traceStore: recoveryTraceStore,
           reason: "failed",
-          signal: controller.signal,
-          deadlineAtMs: record2.claim.leaseExpiresAtMs
+          signal: cleanupSignal,
+          deadlineAtMs: cleanupDeadlineAtMs
         }
       );
-      sealAgentCandidateExecutorFinalCapture(stopped);
+      sealAgentCandidateExecutorStopAcknowledgement(stopped);
+      if (options.executor.dispose) {
+        const disposed = await options.executor.dispose(
+          {
+            executionId: record2.claim.executionId,
+            executionPlanDigest: record2.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,
@@ -895,13 +896,26 @@ async function recoverExpiredAgentCandidateExecution(options) {
     cleanupDeadlineAtMs,
     "expired candidate memory closure"
   ) : void 0;
-  const operations = [processClosure, modelClosure, ...memoryClosure ? [memoryClosure] : []];
-  const outcomes = await Promise.allSettled(operations);
-  const failures = outcomes.filter((outcome) => outcome.status === "rejected").map((outcome) => outcome.reason);
+  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");
   }
-  const model = await modelClosure;
+  if (modelOutcome.status !== "fulfilled") {
+    throw new Error("expired candidate model settlement was not recovered");
+  }
+  const model = modelOutcome.value;
   const modelSettlement = await withinCandidateCleanupDeadline(
     () => persistCandidateModelSettlementEvidence(
       {
@@ -915,11 +929,33 @@ async function recoverExpiredAgentCandidateExecution(options) {
     cleanupDeadlineAtMs,
     "expired candidate model-settlement persistence"
   );
+  const failureClass = record2.phase === "claimed" && model.usage.modelCalls === 0 ? "pre-model-infrastructure" : "unknown";
+  const failureEvidence = await withinCandidateCleanupDeadline(
+    () => persistCandidateOutputArtifact(options.outputArtifacts, {
+      executionId: record2.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,
+        failureClass,
+        processStopped: true,
+        modelSettlementDigest: modelSettlement.digest,
+        memoryClosed: record2.claim.cleanup.memory !== void 0
+      })
+    }),
+    cleanupDeadlineAtMs,
+    "expired candidate failure-evidence persistence"
+  );
   const memory = record2.claim.cleanup.memory;
   return await options.claimStore.recoverExpired(options.attempt, {
-    failureClass: record2.phase === "claimed" && model.fixedUsage.modelCalls === 0 ? "pre-model-infrastructure" : "unknown",
-    usage: model.fixedUsage,
+    failureClass,
+    usage: model.usage,
     modelSettlement: modelSettlement.artifact,
+    failureEvidence,
     process: {
       stopped: true,
       executionPlanDigest: record2.claim.executionPlanDigest
@@ -939,689 +975,49 @@ async function recoverExpiredAgentCandidateExecution(options) {
     } : {}
   });
 }
-
-// src/candidate-execution/workspace-archive.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { constants as fsConstants } from "fs";
-import {
-  lstat,
-  mkdir as mkdir2,
-  mkdtemp,
-  open as open2,
-  readdir,
-  readFile,
-  realpath,
-  rename,
-  rm,
-  writeFile
-} from "fs/promises";
-import { tmpdir } from "os";
-import { dirname, isAbsolute, join as join2, resolve, sep, win32 } from "path";
-import { isAnyArrayBuffer, isSharedArrayBuffer } from "util/types";
-import { extract, pack } from "tar-stream";
-var archiveKind = "agent-candidate-workspace-archive";
-var workspaceEntryPrefix = "workspace/";
-var repositoryMetadataEntry = "metadata/repository.json";
-var repositoryBundleEntry = "metadata/repository.bundle";
-var fixedTarTime = /* @__PURE__ */ new Date(0);
-var defaultLimits = Object.freeze({
-  maxArchiveBytes: 512 * 1024 * 1024,
-  maxEmbeddedArtifactBytes: 1024 * 1024,
-  maxFiles: 5e4,
-  maxFileBytes: 128 * 1024 * 1024,
-  maxTotalFileBytes: 256 * 1024 * 1024,
-  maxPathBytes: 4096,
-  maxRepositoryBundleBytes: 128 * 1024 * 1024
-});
-async function captureAgentCandidateWorkspace(rootInput, options = {}) {
-  const root = resolve(rootInput);
-  const limits = workspaceLimits(options.limits);
-  const captured = options.includeRepository ? await captureRepository(root, limits) : await captureMaterializedWorkspace(root, {
-    limits: {
-      maxFiles: limits.maxFiles,
-      maxFileBytes: limits.maxFileBytes,
-      maxTotalFileBytes: limits.maxTotalFileBytes
-    }
-  });
-  assertWorkspaceFilesWithinLimits(captured.files, limits);
-  const repository = "repository" in captured ? captured.repository : void 0;
-  return captureWorkspaceFiles(captured.files, repository, limits, options.artifactPersistence);
-}
-async function captureAgentCandidateWorkspaceFiles(input, options = {}) {
-  const limits = workspaceLimits(options.limits);
-  return captureWorkspaceFiles(
-    normalizeWorkspaceFiles(input, limits),
-    void 0,
-    limits,
-    options.artifactPersistence
+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")
   );
-}
-async function captureWorkspaceFiles(files, repository, limits, artifactPersistence) {
-  const material = workspaceManifest(files);
-  const manifest = canonicalCandidateBytes(material);
-  const archive = await encodeWorkspaceArchive(files, repository, limits.maxArchiveBytes);
-  if (!artifactPersistence && (manifest.byteLength > limits.maxEmbeddedArtifactBytes || archive.byteLength > limits.maxEmbeddedArtifactBytes)) {
-    throw new Error(
-      "candidate workspace artifacts exceed maxEmbeddedArtifactBytes; artifactPersistence is required"
-    );
+  if (claim.preparationEvidence.executionPlan.sha256 !== claim.executionPlanDigest) {
+    throw new Error("recovery execution plan artifact does not match the claimed digest");
   }
-  const manifestArtifact = await captureWorkspaceArtifact("manifest", manifest, artifactPersistence);
-  const archiveArtifact = await captureWorkspaceArtifact("archive", archive, artifactPersistence);
-  const snapshot = deepFreezeCandidate({
-    schemaVersion: 1,
-    kind: "agent-candidate-workspace-snapshot",
-    digest: canonicalCandidateDigest(material),
-    material,
-    manifest: manifestArtifact,
-    archive: archiveArtifact
-  });
-  return Object.freeze({ snapshot, archive });
-}
-async function captureWorkspaceArtifact(kind, bytes, persistence) {
-  if (!persistence) return embeddedCandidateArtifact(bytes);
-  if (!persistence.executionId.trim()) {
-    throw new Error("candidate workspace artifact persistence requires an executionId");
-  }
-  return persistCandidateOutputArtifact(persistence.outputArtifacts, {
-    executionId: persistence.executionId,
-    purpose: kind === "manifest" ? "candidate-workspace-manifest" : "candidate-workspace-archive",
-    bytes,
-    ...persistence.signal ? { signal: persistence.signal } : {}
+  const receiptMaterial = parseCanonicalBytes(receiptBytes, "materialization receipt");
+  const receipt = agentCandidateMaterializationReceiptSchema.parse({
+    ...receiptMaterial,
+    digest: claim.preparationEvidence.materializationReceipt.sha256
   });
-}
-function createAgentCandidateWorkspacePort(options = {}) {
-  const limits = workspaceLimits(options.limits);
-  const port = {
-    materialize: async ({ role, snapshot, archive, destination }) => {
-      await materializeAgentCandidateWorkspace({
-        role,
-        snapshot,
-        archive,
-        destination,
-        limits
-      });
-    }
-  };
-  return Object.freeze(port);
-}
-async function materializeAgentCandidateWorkspace(input) {
-  verifyBytes(
-    input.archive,
-    input.snapshot.archive.sha256,
-    input.snapshot.archive.byteLength,
-    "candidate workspace archive"
-  );
-  const decoded = await parseWorkspaceArchive(input.archive, input.limits);
-  if (decoded.repository && input.role !== "task") {
-    throw new Error("only task workspaces may carry a Git repository");
-  }
-  assertArchiveMatchesSnapshot(decoded.files, input.snapshot);
-  const destination = resolve(input.destination);
-  await prepareEmptyDestination(destination);
-  const staging = await mkdtemp(`${destination}.materializing-`);
-  try {
-    await writeWorkspaceFiles(staging, decoded.files);
-    if (decoded.repository) {
-      await materializeRepository(decoded.repository, staging);
-    }
-    await verifyMaterializedWorkspace(staging, input.snapshot.material, {
-      ignoredProtectedRootEntries: decoded.repository ? [".git"] : []
-    });
-    await rename(staging, destination);
-  } catch (error) {
-    await rm(staging, { recursive: true, force: true });
-    await rm(destination, { recursive: true, force: true });
-    throw error;
+  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 };
 }
-async function captureRepository(root, limits) {
-  const stats = await lstat(root);
-  if (!stats.isDirectory() || stats.isSymbolicLink() || await realpath(root) !== root) {
-    throw new Error("candidate repository root must be a real directory");
-  }
-  const topLevel = (await runCandidateGit(root, ["rev-parse", "--show-toplevel"])).stdout.toString("utf8").trim();
-  if (resolve(topLevel) !== root) {
-    throw new Error("candidate repository capture must start at the Git worktree root");
-  }
-  const gitDir = resolve(
-    (await runCandidateGit(root, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim()
-  );
-  if (await realpath(gitDir) !== gitDir || gitDir.includes(":")) {
-    throw new Error("candidate repository Git object store has an unsupported path");
-  }
-  await assertNoGitIndirection(root, gitDir, "candidate repository");
-  const headCommit = (await runCandidateGit(root, ["rev-parse", "HEAD"])).stdout.toString("utf8").trim();
-  const headTree = (await runCandidateGit(root, ["rev-parse", "HEAD^{tree}"])).stdout.toString("utf8").trim();
-  assertGitObjectId(headCommit, "HEAD");
-  assertGitObjectId(headTree, "HEAD tree");
-  if (headCommit.length !== headTree.length) {
-    throw new Error("candidate repository HEAD and tree use different object formats");
-  }
-  const files = await readCandidateGitTreeFiles(root, headTree, {}, limits);
-  assertWorkspaceFilesWithinLimits(files, limits);
-  const reachableBytesText = (await runCandidateGit(root, ["rev-list", "--disk-usage", "--objects", "HEAD"])).stdout.toString("utf8").trim();
-  const reachableBytes = Number(reachableBytesText);
-  if (!Number.isSafeInteger(reachableBytes) || reachableBytes < 0) {
-    throw new Error("candidate repository reachable size is invalid");
-  }
-  if (reachableBytes > limits.maxRepositoryBundleBytes) {
-    throw new Error("candidate repository exceeds maxRepositoryBundleBytes");
-  }
-  const temporary = await mkdtemp(join2(tmpdir(), "agent-candidate-workspace-bundle-"));
-  const bundlePath = join2(temporary, `${randomUUID2()}.bundle`);
+function parseCanonicalBytes(bytes, label) {
+  let parsed;
   try {
-    await runCandidateGit(root, ["bundle", "create", bundlePath, "HEAD"]);
-    const bundle = Uint8Array.from(await readFile(bundlePath));
-    if (bundle.byteLength > limits.maxRepositoryBundleBytes) {
-      throw new Error("candidate repository bundle exceeds maxRepositoryBundleBytes");
-    }
-    return {
-      files,
-      repository: {
-        headCommit,
-        headTree,
-        bundle: {
-          sha256: sha256Bytes(bundle),
-          byteLength: bundle.byteLength,
-          bytes: bundle
-        }
-      }
-    };
-  } finally {
-    await rm(temporary, { recursive: true, force: true });
-  }
-}
-async function encodeWorkspaceArchive(files, repository, maxArchiveBytes) {
-  const archive = pack();
-  const output = collectStream(archive, maxArchiveBytes, "candidate workspace archive");
-  try {
-    await writeWorkspaceArchiveEntries(archive, files, repository);
-    archive.finalize();
-    return await output;
+    parsed = JSON.parse(Buffer.from(bytes).toString("utf8"));
   } catch (error) {
-    archive.destroy(error instanceof Error ? error : new Error(String(error)));
-    await output.catch(() => void 0);
-    throw error;
+    throw new Error(`candidate recovery ${label} is not JSON`, { cause: error });
   }
-}
-async function verifyCanonicalWorkspaceArchive(files, repository, expected, maxArchiveBytes) {
-  const archive = pack();
-  const comparison = streamEqualsBytes(
-    archive,
-    expected,
-    maxArchiveBytes,
-    "candidate workspace archive"
-  );
-  try {
-    await writeWorkspaceArchiveEntries(archive, files, repository);
-    archive.finalize();
-    if (!await comparison) throw new Error("candidate workspace tar is not canonical");
-  } catch (error) {
-    archive.destroy(error instanceof Error ? error : new Error(String(error)));
-    await comparison.catch(() => void 0);
-    throw error;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`candidate recovery ${label} must be an object`);
   }
-}
-async function writeWorkspaceArchiveEntries(archive, files, repository) {
-  for (const file of files) {
-    await writeTarEntry(archive, `${workspaceEntryPrefix}${file.path}`, file.mode, file.bytes);
-  }
-  if (!repository) return;
-  const metadata = canonicalCandidateBytes({
-    schemaVersion: 1,
-    kind: archiveKind,
-    headCommit: repository.headCommit,
-    headTree: repository.headTree,
-    bundle: {
-      sha256: repository.bundle.sha256,
-      byteLength: repository.bundle.byteLength
-    }
-  });
-  await writeTarEntry(archive, repositoryMetadataEntry, 384, metadata);
-  await writeTarEntry(archive, repositoryBundleEntry, 384, repository.bundle.bytes);
-}
-async function parseWorkspaceArchive(bytes, limits) {
-  if (bytes.byteLength > limits.maxArchiveBytes) {
-    throw new Error("candidate workspace archive exceeds maxArchiveBytes");
-  }
-  const parser = extract();
-  const files = [];
-  const observedEntryNames = /* @__PURE__ */ new Set();
-  const observedPaths = /* @__PURE__ */ new Set();
-  let totalBytes = 0;
-  let retainedEntryBytes = 0;
-  let previousPath;
-  let repositoryMetadata;
-  let repositoryBundle;
-  const decoded = (async () => {
-    for await (const entry of parser) {
-      const name = entry.header.name;
-      if (entry.header.type !== "file" || typeof name !== "string" || observedEntryNames.has(name)) {
-        throw new Error("candidate workspace tar contains an invalid entry");
-      }
-      observedEntryNames.add(name);
-      if (name.startsWith(workspaceEntryPrefix)) {
-        if (files.length >= limits.maxFiles) {
-          throw new Error("candidate workspace archive has an invalid file count");
-        }
-        const path = safeArchivePath(name.slice(workspaceEntryPrefix.length), limits.maxPathBytes);
-        if (entry.header.mode !== 420 && entry.header.mode !== 493) {
-          throw new Error(`candidate workspace archive has an unsupported mode: ${path}`);
-        }
-        assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
-        const fileBytes = await readTarEntry(entry, limits.maxFileBytes, `workspace file ${path}`);
-        retainedEntryBytes += fileBytes.byteLength;
-        assertWorkspacePathOrder(
-          path,
-          previousPath,
-          observedPaths,
-          "candidate workspace archive paths must be unique and sorted"
-        );
-        previousPath = path;
-        if (fileBytes.byteLength > limits.maxTotalFileBytes - totalBytes) {
-          throw new Error("candidate workspace archive exceeds maxTotalFileBytes");
-        }
-        totalBytes += fileBytes.byteLength;
-        files.push({ path, mode: entry.header.mode, bytes: fileBytes });
-      } else if (name === repositoryMetadataEntry) {
-        if (entry.header.mode !== 384 || repositoryMetadata) {
-          throw new Error("candidate workspace archive repository metadata is invalid");
-        }
-        assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
-        const metadataBytes = await readTarEntry(
-          entry,
-          limits.maxPathBytes,
-          "candidate repository metadata"
-        );
-        retainedEntryBytes += metadataBytes.byteLength;
-        repositoryMetadata = parseRepositoryMetadata(metadataBytes, limits.maxRepositoryBundleBytes);
-      } else if (name === repositoryBundleEntry) {
-        if (entry.header.mode !== 384 || repositoryBundle) {
-          throw new Error("candidate workspace archive repository bundle is invalid");
-        }
-        assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
-        repositoryBundle = await readTarEntry(
-          entry,
-          limits.maxRepositoryBundleBytes,
-          "candidate Git bundle"
-        );
-        retainedEntryBytes += repositoryBundle.byteLength;
-      } else {
-        throw new Error(`candidate workspace tar contains an unsupported entry: ${name}`);
-      }
-    }
-    if (Boolean(repositoryMetadata) !== Boolean(repositoryBundle)) {
-      throw new Error("candidate workspace archive repository evidence is incomplete");
-    }
-    const repository = repositoryMetadata && repositoryBundle ? repositoryFromTar(repositoryMetadata, repositoryBundle) : void 0;
-    return { files, ...repository ? { repository } : {} };
-  })();
-  parser.end(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
-  const result = await decoded;
-  await verifyCanonicalWorkspaceArchive(
-    result.files,
-    result.repository,
-    bytes,
-    limits.maxArchiveBytes
-  );
-  return result;
-}
-function assertRetainedArchiveSize(archiveBytes, retainedEntryBytes, entryBytes, limits) {
-  if (!Number.isSafeInteger(entryBytes) || entryBytes === void 0 || entryBytes < 0 || entryBytes > limits.maxArchiveBytes - archiveBytes - retainedEntryBytes) {
-    throw new Error("candidate workspace archive exceeds maxArchiveBytes while decoding");
+  if (!Buffer.from(canonicalCandidateBytes(parsed)).equals(Buffer.from(bytes))) {
+    throw new Error(`candidate recovery ${label} bytes are not canonical`);
   }
+  return parsed;
 }
-function parseRepositoryMetadata(bytes, maxBundleBytes) {
-  let value;
-  try {
-    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-  } catch (error) {
-    throw new Error("candidate workspace archive repository metadata is invalid", { cause: error });
-  }
-  if (!isRecord(value) || Object.keys(value).sort().join(",") !== "bundle,headCommit,headTree,kind,schemaVersion" || value.schemaVersion !== 1 || value.kind !== archiveKind || typeof value.headCommit !== "string" || typeof value.headTree !== "string" || !isRecord(value.bundle) || Object.keys(value.bundle).sort().join(",") !== "byteLength,sha256" || typeof value.bundle.sha256 !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.bundle.sha256) || !Number.isSafeInteger(value.bundle.byteLength) || value.bundle.byteLength <= 0 || value.bundle.byteLength > maxBundleBytes) {
-    throw new Error("candidate workspace archive repository is invalid");
-  }
-  if (!Buffer.from(canonicalCandidateBytes(value)).equals(Buffer.from(bytes))) {
-    throw new Error("candidate workspace archive repository metadata is not canonical");
-  }
-  assertGitObjectId(value.headCommit, "repository HEAD");
-  assertGitObjectId(value.headTree, "repository HEAD tree");
-  if (value.headCommit.length !== value.headTree.length) {
-    throw new Error("candidate repository HEAD and tree use different object formats");
-  }
-  return {
-    schemaVersion: 1,
-    kind: archiveKind,
-    headCommit: value.headCommit,
-    headTree: value.headTree,
-    bundle: {
-      sha256: value.bundle.sha256,
-      byteLength: value.bundle.byteLength
-    }
-  };
-}
-function repositoryFromTar(metadata, bundle) {
-  verifyBytes(bundle, metadata.bundle.sha256, metadata.bundle.byteLength, "candidate Git bundle");
-  return {
-    headCommit: metadata.headCommit,
-    headTree: metadata.headTree,
-    bundle: { ...metadata.bundle, bytes: bundle }
-  };
-}
-async function writeTarEntry(archive, name, mode, bytes) {
-  await new Promise((resolveEntry, rejectEntry) => {
-    archive.entry(
-      {
-        name,
-        mode,
-        uid: 0,
-        gid: 0,
-        size: bytes.byteLength,
-        mtime: fixedTarTime,
-        type: "file",
-        uname: "",
-        gname: ""
-      },
-      Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength),
-      (error) => error ? rejectEntry(error) : resolveEntry()
-    );
-  });
-}
-async function readTarEntry(entry, maxBytes, label) {
-  const size = entry.header.size;
-  if (!Number.isSafeInteger(size) || size === void 0 || size < 0 || size > maxBytes) {
-    throw new Error(`${label} has an invalid tar size`);
-  }
-  const bytes = await collectStream(entry, maxBytes, label);
-  if (bytes.byteLength !== size) throw new Error(`${label} differs from its tar size`);
-  return bytes;
-}
-async function collectStream(stream, maxBytes, label) {
-  const chunks = [];
-  let totalBytes = 0;
-  for await (const chunk of stream) {
-    if (chunk.byteLength > maxBytes - totalBytes) {
-      const error = new Error(`${label} exceeds its size limit`);
-      if ("destroy" in stream && typeof stream.destroy === "function") stream.destroy(error);
-      throw error;
-    }
-    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    chunks.push(bytes);
-    totalBytes += bytes.byteLength;
-  }
-  return Buffer.concat(chunks, totalBytes);
-}
-async function streamEqualsBytes(stream, expected, maxBytes, label) {
-  const expectedBuffer = Buffer.from(expected.buffer, expected.byteOffset, expected.byteLength);
-  let equal = true;
-  let offset = 0;
-  for await (const chunk of stream) {
-    if (chunk.byteLength > maxBytes - offset) {
-      const error = new Error(`${label} exceeds its size limit`);
-      if ("destroy" in stream && typeof stream.destroy === "function") stream.destroy(error);
-      throw error;
-    }
-    const observed = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-    if (offset + observed.byteLength > expectedBuffer.byteLength || !observed.equals(expectedBuffer.subarray(offset, offset + observed.byteLength))) {
-      equal = false;
-    }
-    offset += observed.byteLength;
-  }
-  return equal && offset === expectedBuffer.byteLength;
-}
-async function prepareEmptyDestination(destination) {
-  await mkdir2(destination, { recursive: true, mode: 448 });
-  const stats = await lstat(destination);
-  if (!stats.isDirectory() || stats.isSymbolicLink() || await realpath(destination) !== destination) {
-    throw new Error("candidate workspace destination must be a real directory");
-  }
-  if ((await readdir(destination)).length > 0) {
-    throw new Error("candidate workspace destination must be empty");
-  }
-}
-async function writeWorkspaceFiles(destination, files) {
-  for (const file of files) {
-    const path = workspacePath(destination, file.path);
-    await mkdir2(dirname(path), { recursive: true, mode: 448 });
-    const descriptor = await open2(
-      path,
-      fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | (typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0),
-      384
-    );
-    try {
-      await descriptor.writeFile(file.bytes);
-      const stats = await descriptor.stat();
-      if (!stats.isFile() || stats.nlink !== 1) {
-        throw new Error(`candidate workspace file identity changed while writing: ${file.path}`);
-      }
-      await descriptor.chmod(file.mode);
-    } finally {
-      await descriptor.close();
-    }
-  }
-}
-async function materializeRepository(repository, destination) {
-  const temporary = await mkdtemp(join2(tmpdir(), "agent-candidate-workspace-bundle-"));
-  const bundlePath = join2(temporary, `${randomUUID2()}.bundle`);
-  try {
-    await writeFile(bundlePath, repository.bundle.bytes, { flag: "wx", mode: 384 });
-    await runCandidateGit(destination, [
-      "init",
-      "--quiet",
-      "--initial-branch=candidate",
-      `--object-format=${repository.headCommit.length === 64 ? "sha256" : "sha1"}`
-    ]);
-    await runCandidateGit(destination, ["bundle", "verify", bundlePath]);
-    await runCandidateGit(destination, ["bundle", "unbundle", bundlePath]);
-    const objectType = (await runCandidateGit(destination, ["cat-file", "-t", repository.headCommit])).stdout.toString("utf8").trim();
-    if (objectType !== "commit") throw new Error("candidate repository HEAD is not a commit");
-    const observedTree = (await runCandidateGit(destination, ["rev-parse", `${repository.headCommit}^{tree}`])).stdout.toString("utf8").trim();
-    if (observedTree !== repository.headTree) {
-      throw new Error("candidate repository bundle HEAD tree changed");
-    }
-    await runCandidateGit(destination, ["update-ref", "--no-deref", "HEAD", repository.headCommit]);
-    await runCandidateGit(destination, ["read-tree", repository.headTree]);
-    const status = (await runCandidateGit(destination, ["status", "--porcelain=v1", "--untracked-files=all"])).stdout.toString("utf8").trim();
-    if (status) throw new Error("candidate repository files do not exactly match HEAD");
-  } finally {
-    await rm(temporary, { recursive: true, force: true });
-  }
-}
-function workspaceManifest(files) {
-  return {
-    schemaVersion: 1,
-    kind: "agent-candidate-workspace-manifest",
-    files: files.map((file) => ({
-      path: file.path,
-      mode: file.mode,
-      sha256: sha256Bytes(file.bytes),
-      byteLength: file.bytes.byteLength
-    }))
-  };
-}
-function assertArchiveMatchesSnapshot(files, snapshot) {
-  const material = workspaceManifest(files);
-  const materialBytes = canonicalCandidateBytes(material);
-  verifyBytes(
-    materialBytes,
-    snapshot.manifest.sha256,
-    snapshot.manifest.byteLength,
-    "candidate workspace manifest"
-  );
-  if (canonicalCandidateDigest(material) !== snapshot.digest || !Buffer.from(materialBytes).equals(Buffer.from(canonicalCandidateBytes(snapshot.material)))) {
-    throw new Error("candidate workspace archive does not match its snapshot manifest");
-  }
-}
-function assertWorkspaceFilesWithinLimits(files, limits) {
-  if (files.length > limits.maxFiles) {
-    throw new Error("candidate workspace exceeds maxFiles");
-  }
-  let totalBytes = 0;
-  let previousPath;
-  const observedPaths = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    const path = safeArchivePath(file.path, limits.maxPathBytes);
-    assertWorkspacePathOrder(
-      path,
-      previousPath,
-      observedPaths,
-      "candidate workspace paths must be unique and sorted"
-    );
-    previousPath = path;
-    if (file.mode !== 420 && file.mode !== 493) {
-      throw new Error(`candidate workspace file has unsupported mode: ${path}`);
-    }
-    if (file.bytes.byteLength > limits.maxFileBytes) {
-      throw new Error(`candidate workspace file exceeds maxFileBytes: ${path}`);
-    }
-    totalBytes += file.bytes.byteLength;
-    if (totalBytes > limits.maxTotalFileBytes) {
-      throw new Error("candidate workspace exceeds maxTotalFileBytes");
-    }
-  }
-}
-function normalizeWorkspaceFiles(input, limits) {
-  if (!Array.isArray(input)) {
-    throw new Error("candidate workspace files must be an array");
-  }
-  const fileCount = input.length;
-  if (fileCount > limits.maxFiles) {
-    throw new Error("candidate workspace exceeds maxFiles");
-  }
-  let totalBytes = 0;
-  const files = [];
-  for (let index = 0; index < fileCount; index++) {
-    const inputFile = input[index];
-    if (!isRecord(inputFile) || Object.keys(inputFile).sort().join(",") !== "bytes,mode,path") {
-      throw new Error(`candidate workspace file ${index} is invalid`);
-    }
-    const descriptors = Object.getOwnPropertyDescriptors(inputFile);
-    if (!("value" in (descriptors.path ?? {})) || !("value" in (descriptors.mode ?? {})) || !("value" in (descriptors.bytes ?? {}))) {
-      throw new Error(`candidate workspace file ${index} must use fixed values`);
-    }
-    const path = safeArchivePath(descriptors.path?.value, limits.maxPathBytes);
-    const mode = descriptors.mode?.value;
-    const inputBytes = descriptors.bytes?.value;
-    if (mode !== 420 && mode !== 493) {
-      throw new Error(`candidate workspace file has unsupported mode: ${path}`);
-    }
-    const view = inspectWorkspaceBytes(inputBytes, path);
-    if (view.byteLength > limits.maxFileBytes) {
-      throw new Error(`candidate workspace file exceeds maxFileBytes: ${path}`);
-    }
-    if (view.byteLength > limits.maxTotalFileBytes - totalBytes) {
-      throw new Error("candidate workspace exceeds maxTotalFileBytes");
-    }
-    if (view.byteLength > Math.max(0, limits.maxArchiveBytes - 1024)) {
-      throw new Error("candidate workspace archive exceeds maxArchiveBytes");
-    }
-    totalBytes += view.byteLength;
-    files.push({ path, mode, bytes: detachWorkspaceBytes(view) });
-  }
-  files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
-  assertWorkspaceFilesWithinLimits(files, limits);
-  return files;
-}
-function workspaceLimits(overrides) {
-  const limits = { ...defaultLimits, ...overrides };
-  for (const [name, value] of Object.entries(limits)) {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new Error(`candidate workspace ${name} must be a positive safe integer`);
-    }
-  }
-  return Object.freeze(limits);
-}
-function safeArchivePath(value, maxPathBytes) {
-  if (typeof value !== "string" || !value || !isWellFormedUnicode(value) || Buffer.byteLength(value, "utf8") > maxPathBytes || isAbsolute(value) || win32.isAbsolute(value) || value.includes("\\") || value.includes("\0") || hasControlCharacter(value) || value.split("/").some((part) => !part || part === "." || part === "..") || [".git", ".sidecar"].includes(value.split("/")[0]?.toLowerCase() ?? "")) {
-    throw new Error(`candidate workspace archive contains an unsafe path: ${String(value)}`);
-  }
-  return value;
-}
-function assertWorkspacePathOrder(path, previousPath, observedPaths, errorMessage) {
-  if (previousPath !== void 0 && previousPath >= path) throw new Error(errorMessage);
-  for (let slash = path.indexOf("/"); slash !== -1; slash = path.indexOf("/", slash + 1)) {
-    if (observedPaths.has(path.slice(0, slash))) throw new Error(errorMessage);
-  }
-  observedPaths.add(path);
-}
-function inspectWorkspaceBytes(input, path) {
-  let buffer;
-  let byteOffset;
-  let byteLength;
-  try {
-    buffer = typedArrayBufferGetter.call(input);
-    byteOffset = typedArrayByteOffsetGetter.call(input);
-    byteLength = typedArrayByteLengthGetter.call(input);
-  } catch {
-    throw new Error(`candidate workspace file bytes are invalid: ${path}`);
-  }
-  if (isSharedArrayBuffer(buffer)) {
-    throw new Error(`candidate workspace file uses shared bytes: ${path}`);
-  }
-  if (!isAnyArrayBuffer(buffer)) {
-    throw new Error(`candidate workspace file bytes are invalid: ${path}`);
-  }
-  return { buffer, byteOffset, byteLength };
-}
-function detachWorkspaceBytes(input) {
-  const { buffer, byteOffset, byteLength } = input;
-  const copy = new Uint8Array(byteLength);
-  Uint8Array.prototype.set.call(copy, new Uint8Array(buffer, byteOffset, byteLength));
-  return copy;
-}
-function isWellFormedUnicode(value) {
-  for (let index = 0; index < value.length; index++) {
-    const code = value.charCodeAt(index);
-    if (code >= 55296 && code <= 56319) {
-      const next = value.charCodeAt(index + 1);
-      if (!(next >= 56320 && next <= 57343)) return false;
-      index++;
-    } else if (code >= 56320 && code <= 57343) {
-      return false;
-    }
-  }
-  return true;
-}
-function workspacePath(root, relativePath) {
-  const path = resolve(root, relativePath);
-  if (!path.startsWith(`${root}${sep}`)) {
-    throw new Error(`candidate workspace archive path escapes its destination: ${relativePath}`);
-  }
-  return path;
-}
-function assertGitObjectId(value, label) {
-  if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(value)) {
-    throw new Error(`candidate repository ${label} is not a Git object id`);
-  }
-}
-function hasControlCharacter(value) {
-  for (let index = 0; index < value.length; index++) {
-    const code = value.charCodeAt(index);
-    if (code < 32 || code === 127) return true;
-  }
-  return false;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function requireTypedArrayGetter(name) {
-  const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-  const getter = Object.getOwnPropertyDescriptor(typedArrayPrototype, name)?.get;
-  if (!getter) throw new Error(`typed array intrinsic ${name} accessor is unavailable`);
-  return getter;
-}
-var typedArrayBufferGetter = requireTypedArrayGetter("buffer");
-var typedArrayByteOffsetGetter = requireTypedArrayGetter("byteOffset");
-var typedArrayByteLengthGetter = requireTypedArrayGetter("byteLength");
 
 export {
+  sealAgentCandidateBundle,
   buildAgentCandidateBundle,
   FileAgentCandidateExecutionClaimStore,
   disposePreparedAgentCandidateExecution,
   createProtectedAgentCandidateModelPort,
-  recoverExpiredAgentCandidateExecution,
-  captureAgentCandidateWorkspace,
-  captureAgentCandidateWorkspaceFiles,
-  createAgentCandidateWorkspacePort
+  recoverExpiredAgentCandidateExecution
 };
-//# sourceMappingURL=chunk-FTXM7Q7P.js.map
+//# sourceMappingURL=chunk-6YBA64Z2.js.map