@tangle-network/agent-runtime 0.94.12 → 0.94.13

package/dist/candidate-execution/index.d.ts

@@ -1,7 +1,7 @@
 import { CodeSurface } from '@tangle-network/agent-eval/campaign';
 import { AgentCandidateCodeDisabled, AgentCandidateCodeNoOp, AgentCandidateGitHubRepository, AgentProfile, AgentProfileDiff, AgentCandidateProfile, AgentCandidateExecution, AgentCandidateKnowledge, AgentCandidateMemoryPolicy, AgentCandidateLineage, Sha256Digest, AgentCandidateArtifactRef, AgentCandidateWorkspaceSnapshotEvidence } from '@tangle-network/agent-interface';
-import { a9 as sealAgentCandidateBundle, a0 as PreparedAgentCandidateExecution, j as AgentCandidateExecutionClaim, l as AgentCandidateExecutionClaimStore, k as AgentCandidateExecutionClaimResult, i as AgentCandidateExecutionAttemptRef, h as AgentCandidateExecutionAttemptRecord, p as AgentCandidateExecutionLease, r as AgentCandidateExecutionPhaseResult, v as AgentCandidateExecutionTerminalResult, t as AgentCandidateExecutionStageResult, o as AgentCandidateExecutionFinishResult, s as AgentCandidateExecutionRecoveryEvidence, M as AgentCandidateOutputArtifactPort, N as AgentCandidateOutputPurpose, L as AgentCandidateModelPort, R as AgentCandidateProtectedModelReservation, O as AgentCandidateProtectedModelActivation, S as AgentCandidateProtectedModelSettlement, z as AgentCandidateExecutorPort, b as AgentCandidateExecutionPorts, W as AgentCandidateVerificationPorts, a5 as VerifiedAgentCandidate, G as AgentCandidateExecutorWorkspaceFile, X as AgentCandidateWorkspacePort } from '../prepare-DIeVgQG3.js';
-export { d as AgentCandidateArtifactPort, e as AgentCandidateBenchmarkGraderIdentity, f as AgentCandidateBenchmarkGraderPort, A as AgentCandidateBundleInput, g as AgentCandidateContainerPort, m as AgentCandidateExecutionCleanupHandles, n as AgentCandidateExecutionFailureClass, q as AgentCandidateExecutionPhase, u as AgentCandidateExecutionTerminalRecord, w as AgentCandidateExecutionUsage, x as AgentCandidateExecutorFinalCapture, y as AgentCandidateExecutorMemoryCapture, B as AgentCandidateExecutorProfileFile, C as AgentCandidateExecutorRequest, D as AgentCandidateExecutorStopRequest, F as AgentCandidateExecutorTaskOutcomeCapture, H as AgentCandidateExecutorWorkspaceInput, I as AgentCandidateMemoryPort, J as AgentCandidateMemoryResetResult, K as AgentCandidateModelLimits, Q as AgentCandidateProtectedModelCall, T as AgentCandidateProtectedRunCapture, U as AgentCandidateRepositoryPort, V as AgentCandidateRetryRejection, c as AgentCandidateRunFinalization, a as AgentCandidateTaskExecution, Y as CANDIDATE_TRACE_ENV, Z as CANDIDATE_TRACE_TAGS, _ as CanonicalCandidateDocument, E as ExecutePreparedAgentCandidateOptions, $ as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, a1 as PreparedAgentCandidateInstruction, a2 as PreparedAgentCandidateLaunch, a3 as PreparedAgentCandidateTrace, a4 as ResolvedAgentCandidateContainer, a6 as VerifiedAgentCandidateTaskOutcome, a7 as executePreparedAgentCandidate, a8 as prepareAgentCandidateExecution } from '../prepare-DIeVgQG3.js';
+import { aa as sealAgentCandidateBundle, a0 as PreparedAgentCandidateExecution, j as AgentCandidateExecutionClaim, l as AgentCandidateExecutionClaimStore, k as AgentCandidateExecutionClaimResult, i as AgentCandidateExecutionAttemptRef, h as AgentCandidateExecutionAttemptRecord, p as AgentCandidateExecutionLease, r as AgentCandidateExecutionPhaseResult, v as AgentCandidateExecutionTerminalResult, t as AgentCandidateExecutionStageResult, o as AgentCandidateExecutionFinishResult, s as AgentCandidateExecutionRecoveryEvidence, M as AgentCandidateOutputArtifactPort, N as AgentCandidateOutputPurpose, L as AgentCandidateModelPort, R as AgentCandidateProtectedModelReservation, O as AgentCandidateProtectedModelActivation, S as AgentCandidateProtectedModelSettlement, z as AgentCandidateExecutorPort, b as AgentCandidateExecutionPorts, W as AgentCandidateVerificationPorts, a6 as VerifiedAgentCandidate, G as AgentCandidateExecutorWorkspaceFile, X as AgentCandidateWorkspacePort } from '../prepare-CtdtsFNG.js';
+export { d as AgentCandidateArtifactPort, e as AgentCandidateBenchmarkGraderIdentity, f as AgentCandidateBenchmarkGraderPort, A as AgentCandidateBundleInput, g as AgentCandidateContainerPort, m as AgentCandidateExecutionCleanupHandles, n as AgentCandidateExecutionFailureClass, q as AgentCandidateExecutionPhase, u as AgentCandidateExecutionTerminalRecord, w as AgentCandidateExecutionUsage, x as AgentCandidateExecutorFinalCapture, y as AgentCandidateExecutorMemoryCapture, B as AgentCandidateExecutorProfileFile, C as AgentCandidateExecutorRequest, D as AgentCandidateExecutorStopRequest, F as AgentCandidateExecutorTaskOutcomeCapture, H as AgentCandidateExecutorWorkspaceInput, I as AgentCandidateMemoryPort, J as AgentCandidateMemoryResetResult, K as AgentCandidateModelLimits, Q as AgentCandidateProtectedModelCall, T as AgentCandidateProtectedRunCapture, U as AgentCandidateRepositoryPort, V as AgentCandidateRetryRejection, c as AgentCandidateRunFinalization, a as AgentCandidateTaskExecution, Y as CANDIDATE_TRACE_ENV, Z as CANDIDATE_TRACE_TAGS, _ as CanonicalCandidateDocument, E as ExecutePreparedAgentCandidateOptions, $ as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, a1 as PreparedAgentCandidateInstruction, a2 as PreparedAgentCandidateKnowledge, a3 as PreparedAgentCandidateLaunch, a4 as PreparedAgentCandidateTrace, a5 as ResolvedAgentCandidateContainer, a7 as VerifiedAgentCandidateTaskOutcome, a8 as executePreparedAgentCandidate, a9 as prepareAgentCandidateExecution } from '../prepare-CtdtsFNG.js';
 import { TraceStore } from '@tangle-network/agent-eval';
 
 /** A complete profile that can be frozen without losing behavior. */

package/dist/candidate-execution/index.js

@@ -7,7 +7,7 @@ import {
   createProtectedAgentCandidateModelPort,
   disposePreparedAgentCandidateExecution,
   recoverExpiredAgentCandidateExecution
-} from "../chunk-FTXM7Q7P.js";
+} from "../chunk-TVJQAYQM.js";
 import {
   CANDIDATE_TRACE_ENV,
   CANDIDATE_TRACE_TAGS,
@@ -21,7 +21,7 @@ import {
   prepareAgentCandidateExecution,
   sealAgentCandidateBundle,
   verifyAgentCandidateBundle
-} from "../chunk-37V4KQDC.js";
+} from "../chunk-CNH7DF7Z.js";
 import "../chunk-WIPGQ4GT.js";
 import "../chunk-3MDZX7YU.js";
 import "../chunk-DGUM43GV.js";

package/dist/{chunk-37V4KQDC.js → chunk-CNH7DF7Z.js}

@@ -1464,6 +1464,18 @@ async function readMaterializedWorkspaceFiles(root, expected, options = {}) {
     (file) => Object.freeze({ path: file.path, mode: file.mode, bytes: Uint8Array.from(file.bytes) })
   );
 }
+function candidateWorkspaceManifest(files) {
+  return {
+    schemaVersion: 2,
+    kind: "agent-candidate-workspace-manifest",
+    files: files.map((file) => ({
+      path: file.path,
+      mode: file.mode,
+      sha256: sha256Bytes(file.bytes),
+      byteLength: file.bytes.byteLength
+    })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)
+  };
+}
 function assertWorkspaceManifest(observed, expected) {
   if (!Buffer.from(canonicalCandidateBytes(observed)).equals(canonicalCandidateBytes(expected))) {
     throw new Error(
@@ -1493,7 +1505,6 @@ async function scanWorkspace(root, ignoredProtectedRootEntries, limits) {
   if (await realpath(absoluteRoot) !== absoluteRoot) {
     throw new Error("workspace root has a symlinked path component");
   }
-  const files = [];
   const capturedFiles = [];
   let totalBytes = 0;
   async function visit(directory) {
@@ -1519,7 +1530,7 @@ async function scanWorkspace(root, ignoredProtectedRootEntries, limits) {
       if (!stats.isFile()) {
         throw new Error(`workspace contains a non-regular entry: ${relPath}`);
       }
-      if (limits && files.length >= limits.maxFiles) {
+      if (limits && capturedFiles.length >= limits.maxFiles) {
         throw new Error("workspace exceeds maxFiles");
       }
       const descriptor = await open(
@@ -1535,9 +1546,6 @@ async function scanWorkspace(root, ignoredProtectedRootEntries, limits) {
           throw new Error(`workspace contains a hard-linked file: ${relPath}`);
         }
         const mode = openedStats.mode & 511;
-        if (mode !== 420 && mode !== 493) {
-          throw new Error(`workspace file has unsupported mode ${mode.toString(8)}: ${relPath}`);
-        }
         if (limits && openedStats.size > limits.maxFileBytes) {
           throw new Error(`workspace file exceeds maxFileBytes: ${relPath}`);
         }
@@ -1551,28 +1559,15 @@ async function scanWorkspace(root, ignoredProtectedRootEntries, limits) {
           relPath
         );
         totalBytes += bytes.byteLength;
-        const supportedMode = mode;
-        files.push({
-          path: relPath,
-          mode: supportedMode,
-          sha256: sha256Bytes(bytes),
-          byteLength: bytes.byteLength
-        });
-        capturedFiles.push({ path: relPath, mode: supportedMode, bytes: Uint8Array.from(bytes) });
+        capturedFiles.push({ path: relPath, mode, bytes: Uint8Array.from(bytes) });
       } finally {
         await descriptor.close();
       }
     }
   }
   await visit(absoluteRoot);
-  files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-  capturedFiles.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
   return {
-    manifest: {
-      schemaVersion: 1,
-      kind: "agent-candidate-workspace-manifest",
-      files
-    },
+    manifest: candidateWorkspaceManifest(capturedFiles),
     files: capturedFiles
   };
 }
@@ -1797,19 +1792,9 @@ async function assertSafeTree(repositoryRoot, tree, environment = {}) {
   }
 }
 async function workspaceManifestFromGitTree(repositoryRoot, tree, environment) {
-  const files = (await readCandidateGitTreeFiles(repositoryRoot, tree, environment)).map(
-    ({ path, mode, bytes }) => ({
-      path,
-      mode,
-      sha256: sha256Bytes(bytes),
-      byteLength: bytes.byteLength
-    })
+  return candidateWorkspaceManifest(
+    await readCandidateGitTreeFiles(repositoryRoot, tree, environment)
   );
-  return {
-    schemaVersion: 1,
-    kind: "agent-candidate-workspace-manifest",
-    files
-  };
 }
 async function readCandidateGitTreeFiles(repositoryRoot, tree, environment = {}, limits) {
   const listing = (await runCandidateGit(
@@ -1951,6 +1936,14 @@ function isNoEntry(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
+// src/candidate-execution/workspace-task.ts
+function workspaceTaskRepository(task) {
+  if (task.outcome.kind !== "workspace" || !task.repository) {
+    throw new Error("candidate runtime requires a workspace outcome with repository provenance");
+  }
+  return task.repository;
+}
+
 // src/candidate-execution/prepared-state.ts
 var stateByExecution = /* @__PURE__ */ new WeakMap();
 var lifecycleByExecution = /* @__PURE__ */ new WeakMap();
@@ -2058,7 +2051,7 @@ async function assertPreparedCandidateWorkspaces(state) {
   await verifyMaterializedWorkspace(state.roots.staging.taskRoot, plan.task.workspace.material, {
     ignoredProtectedRootEntries: [".git", ".sidecar"]
   });
-  await verifyTaskCheckout(state.roots.staging.taskRoot, plan.task.repository);
+  await verifyTaskCheckout(state.roots.staging.taskRoot, workspaceTaskRepository(plan.task));
   await verifyMaterializedProfileWorkspace(
     state.roots.staging.profileRoot,
     state.profilePlan.value.material
@@ -2125,9 +2118,10 @@ function detachPreparedCandidateState(input) {
     ...input.memoryReservation ? { memoryReservation: immutableCandidateValue(input.memoryReservation) } : {},
     ...input.knowledge ? {
       knowledge: Object.freeze({
-        snapshotId: input.knowledge.snapshotId,
-        manifestDigest: input.knowledge.manifestDigest,
-        manifest: Uint8Array.from(input.knowledge.manifest)
+        candidate: immutableCandidateValue(input.knowledge.candidate),
+        snapshot: immutableCandidateValue(input.knowledge.snapshot),
+        files: immutableExecutorFiles(input.knowledge.files),
+        ...input.knowledge.retrievalConfig ? { retrievalConfig: Uint8Array.from(input.knowledge.retrievalConfig) } : {}
       })
     } : {},
     trace: immutableCandidateValue(input.trace),
@@ -2157,6 +2151,7 @@ function assertPrivateCandidateIntegrity(state) {
     throw new Error("prepared model access no longer matches the signed execution plan");
   }
   assertExecutorInputs(state);
+  assertPreparedKnowledge(state);
   if (state.memory.mode === "isolated" && !state.memoryReservation || state.memory.mode === "disabled" && state.memoryReservation) {
     throw new Error("prepared memory reservation does not match the signed execution plan");
   }
@@ -2210,13 +2205,16 @@ function bytesView(value, key) {
   });
 }
 function knowledgeView(knowledge) {
-  const manifest = Uint8Array.from(knowledge.manifest);
+  const retrievalConfig = knowledge.retrievalConfig ? Uint8Array.from(knowledge.retrievalConfig) : void 0;
   return Object.freeze({
-    snapshotId: knowledge.snapshotId,
-    manifestDigest: knowledge.manifestDigest,
-    get manifest() {
-      return Uint8Array.from(manifest);
-    }
+    candidate: knowledge.candidate,
+    snapshot: knowledge.snapshot,
+    files: Object.freeze(knowledge.files.map((file) => profileFileView(file))),
+    ...retrievalConfig ? {
+      get retrievalConfig() {
+        return Uint8Array.from(retrievalConfig);
+      }
+    } : {}
   });
 }
 function workspaceInputView(snapshot, sourceFiles) {
@@ -2261,6 +2259,28 @@ function assertExecutorInputs(state) {
     }
   }
 }
+function assertPreparedKnowledge(state) {
+  const expected = state.bundle.knowledge;
+  const actual = state.knowledge;
+  if (!expected || !actual) {
+    if (expected || actual)
+      throw new Error("prepared knowledge does not match the candidate bundle");
+    return;
+  }
+  if (canonicalCandidateDigest(actual.candidate) !== canonicalCandidateDigest(expected.candidate) || canonicalCandidateDigest(actual.snapshot) !== canonicalCandidateDigest(expected.snapshot) || state.executionPlan.value.material.knowledgeManifestDigest !== expected.snapshot.digest) {
+    throw new Error("prepared knowledge identity does not match the candidate bundle");
+  }
+  assertWorkspaceExecutorFiles(actual.files, expected.snapshot.material);
+  if (!expected.retrievalConfig || !actual.retrievalConfig) {
+    if (expected.retrievalConfig || actual.retrievalConfig) {
+      throw new Error("prepared knowledge retrieval config does not match the candidate bundle");
+    }
+    return;
+  }
+  if (actual.retrievalConfig.byteLength !== expected.retrievalConfig.byteLength || sha256Bytes(actual.retrievalConfig) !== expected.retrievalConfig.sha256) {
+    throw new Error("prepared knowledge retrieval config does not match the candidate bundle");
+  }
+}
 function assertWorkspaceExecutorFiles(actualFiles, expected) {
   if (actualFiles.length !== expected.files.length) {
     throw new Error("prepared workspace executor files do not match the signed manifest");
@@ -2452,6 +2472,18 @@ function sealAgentCandidateExecutorFinalCapture(value) {
     ...memoryAfter ? { memoryAfter: Object.freeze(memoryAfter) } : {}
   });
 }
+function encodeAgentCandidateExecutorCapture(input) {
+  return canonicalCandidateBytes({
+    schemaVersion: 1,
+    kind: "agent-candidate-executor-capture",
+    executionId: input.executionId,
+    executionPlanDigest: input.executionPlanDigest,
+    termination: input.termination,
+    stopped: true,
+    taskOutcome: input.taskOutcome,
+    ...input.memoryAfter ? { memoryAfter: input.memoryAfter } : {}
+  });
+}
 function sealMemoryCapture(value) {
   const capture = requireRecord(value, "candidate memory capture");
   assertExactObjectKeys(capture, ["afterState", "archive"], "candidate memory capture");
@@ -2498,7 +2530,7 @@ import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join2 } from "path";
 import { isLlmSpan as isLlmSpan2, REDACTION_VERSION as REDACTION_VERSION2 } from "@tangle-network/agent-eval";
-import { agentCandidateRunReceiptV2Schema } from "@tangle-network/agent-interface";
+import { agentCandidateRunReceiptSchema } from "@tangle-network/agent-interface";
 
 // src/candidate-execution/model-settlement.ts
 import { isLlmSpan } from "@tangle-network/agent-eval";
@@ -2883,7 +2915,7 @@ function provisionalCandidateWorkspaceSnapshot(materialInput, archive) {
   );
   const manifestBytes = canonicalCandidateBytes(material);
   const snapshot = Object.freeze({
-    schemaVersion: 1,
+    schemaVersion: 2,
     kind: "agent-candidate-workspace-snapshot",
     digest: sha256Bytes(manifestBytes),
     material,
@@ -2912,7 +2944,7 @@ async function persistCandidateWorkspaceSnapshot(port, input) {
   ]);
   return immutableCandidateValue(
     agentCandidateWorkspaceSnapshotEvidenceSchema.parse({
-      schemaVersion: 1,
+      schemaVersion: 2,
       kind: "agent-candidate-workspace-snapshot",
       digest: sha256Bytes(manifestBytes),
       material,
@@ -2961,7 +2993,6 @@ async function finalizeAgentCandidateRun(state, capture, traceStore, settlement,
     );
     const modelSpans = orderedSpans.filter(isLlmSpan2);
     assertTraceMatchesModelSettlement(modelSpans, settlement);
-    const usage = settlement.usage;
     enforceLimits(state, run.startedAt, run.endedAt, orderedSpans, settlement);
     const finalCapture = sealAgentCandidateExecutorFinalCapture(evidence.finalCapture);
     const memory = await memoryReceipt(
@@ -2971,6 +3002,20 @@ async function finalizeAgentCandidateRun(state, capture, traceStore, settlement,
       protectedValues,
       signal
     );
+    const executorCaptureBytes = encodeAgentCandidateExecutorCapture({
+      executionId: protectedCapture.executionId,
+      executionPlanDigest: state.executionPlan.value.digest,
+      termination: protectedCapture.termination,
+      taskOutcome: evidence.taskOutcome.evidence,
+      ...memory.mode === "isolated" ? { memoryAfter: memory.afterState } : {}
+    });
+    assertNoProtectedBytes(executorCaptureBytes, protectedValues);
+    const executorCapture = await persistCandidateOutputArtifact(evidence.outputArtifacts, {
+      executionId: state.executionId,
+      purpose: "executor-capture",
+      bytes: executorCaptureBytes,
+      signal
+    });
     const redacted = redactProtectedValue(
       {
         schemaVersion: 1,
@@ -3010,23 +3055,21 @@ async function finalizeAgentCandidateRun(state, capture, traceStore, settlement,
       modelCallCount: modelSpans.length
     };
     const document = canonicalCandidateDocument({
-      schemaVersion: 2,
+      schemaVersion: 3,
       kind: "agent-candidate-run",
       digestAlgorithm: "rfc8785-sha256",
       bundleDigest: state.bundle.digest,
       materializationReceiptDigest: state.materializationReceipt.digest,
       executionPlanDigest: state.executionPlan.value.digest,
       memory,
-      usage,
-      modelUsage: { resolved: state.resolvedModel, usage },
       trace,
       termination,
-      fixedUsage: settlement.fixedUsage,
+      executorCapture,
       modelSettlement: evidence.modelSettlement,
       taskOutcome: evidence.taskOutcome.evidence,
       benchmarkResult: evidence.benchmarkResult
     });
-    agentCandidateRunReceiptV2Schema.parse(document.value);
+    agentCandidateRunReceiptSchema.parse(document.value);
     const runReceipt = await persistCandidateOutputArtifact(evidence.outputArtifacts, {
       executionId: state.executionId,
       purpose: "run-receipt",
@@ -3037,6 +3080,7 @@ async function finalizeAgentCandidateRun(state, capture, traceStore, settlement,
       succeeded: true,
       receipt: document,
       artifacts: {
+        executorCapture,
         modelSettlement: evidence.modelSettlement.artifact,
         taskOutcome: evidence.taskOutcome.evidence.artifact,
         benchmarkResult: evidence.benchmarkResult.artifact,
@@ -3288,7 +3332,7 @@ async function persistCandidateModelSettlementEvidence(identity, settlement, out
   });
   return immutableCandidateValue(
     agentCandidateModelSettlementEvidenceSchema.parse({
-      schemaVersion: 1,
+      schemaVersion: 2,
       kind: "agent-candidate-model-settlement",
       digest,
       material,
@@ -3305,7 +3349,7 @@ async function persistVerifiedCandidateTaskOutcome(state, capture, outputArtifac
   assertNoProtectedBytes(archive, protectedValues);
   const provisional = provisionalCandidateWorkspaceSnapshot(capture.afterState, archive);
   const afterState = provisional.material;
-  const repository = state.executionPlan.value.material.task.repository;
+  const repository = workspaceTaskRepository(state.executionPlan.value.material.task);
   const verified = await verifyTaskOutcomePatch({
     repositoryRoot: state.roots.staging.taskRoot,
     baseCommit: repository.baseCommit,
@@ -3332,25 +3376,28 @@ async function persistVerifiedCandidateTaskOutcome(state, capture, outputArtifac
     signal
   });
   const material = {
-    schemaVersion: 1,
+    schemaVersion: 2,
     kind: "agent-candidate-task-outcome-material",
     executionPlanDigest: state.executionPlan.value.digest,
-    baseRepository: {
-      identity: repository.identity,
-      rootIdentity: repository.rootIdentity,
-      commit: repository.baseCommit,
-      tree: repository.baseTree
-    },
-    resultRepository: {
-      identity: repository.identity,
-      rootIdentity: repository.rootIdentity,
-      commit: verified.resultCommit,
-      tree: verified.resultTree
-    },
-    afterState: snapshot,
-    gitDiff: {
-      format: "git-diff-binary",
-      artifact: gitDiff
+    outcome: {
+      kind: "workspace",
+      baseRepository: {
+        identity: repository.identity,
+        rootIdentity: repository.rootIdentity,
+        commit: repository.baseCommit,
+        tree: repository.baseTree
+      },
+      resultRepository: {
+        identity: repository.identity,
+        rootIdentity: repository.rootIdentity,
+        commit: verified.resultCommit,
+        tree: verified.resultTree
+      },
+      afterState: snapshot,
+      gitDiff: {
+        format: "git-diff-binary",
+        artifact: gitDiff
+      }
     }
   };
   const bytes = canonicalCandidateBytes(material);
@@ -3363,7 +3410,7 @@ async function persistVerifiedCandidateTaskOutcome(state, capture, outputArtifac
   });
   const evidence = immutableCandidateValue(
     agentCandidateTaskOutcomeEvidenceSchema.parse({
-      schemaVersion: 1,
+      schemaVersion: 2,
       kind: "agent-candidate-task-outcome",
       digest,
       material,
@@ -4345,7 +4392,16 @@ async function verifyAgentCandidateBundle(input, ports) {
     artifactBytes.set(artifactCacheKey(parsed.execution.workspace.manifest), workspace.manifest);
     artifactBytes.set(artifactCacheKey(parsed.execution.workspace.archive), workspace.archive);
   }
-  if (parsed.knowledge) await readArtifact(parsed.knowledge.manifest);
+  if (parsed.knowledge) {
+    const knowledge = await verifyWorkspaceSnapshotArtifacts(
+      parsed.knowledge.snapshot,
+      ports.artifacts
+    );
+    artifactBytes.set(artifactCacheKey(parsed.knowledge.snapshot.manifest), knowledge.manifest);
+    artifactBytes.set(artifactCacheKey(parsed.knowledge.snapshot.archive), knowledge.archive);
+    if (parsed.knowledge.retrievalConfig) await readArtifact(parsed.knowledge.retrievalConfig);
+    await readArtifact(parsed.knowledge.evaluation);
+  }
   if (parsed.memory.mode === "isolated" && parsed.memory.seed)
     await readArtifact(parsed.memory.seed);
   deepFreezeCandidate(parsed);
@@ -4416,6 +4472,41 @@ import {
   applyAgentCandidateWorkspacePlan,
   materializeCandidateProfile
 } from "@tangle-network/agent-profile-materialize";
+
+// src/candidate-execution/knowledge.ts
+import { mkdtemp as mkdtemp4, rm as rm4 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join4 } from "path";
+async function prepareAgentCandidateKnowledge(candidate, ports) {
+  const knowledge = candidate.bundle.knowledge;
+  if (!knowledge) return void 0;
+  const archive = await verifiedArtifactBytes(candidate, knowledge.snapshot.archive);
+  const retrievalConfig = knowledge.retrievalConfig ? await verifiedArtifactBytes(candidate, knowledge.retrievalConfig) : void 0;
+  const root = await mkdtemp4(join4(tmpdir4(), "agent-candidate-knowledge-"));
+  try {
+    await ports.workspaces.materialize({
+      role: "knowledge",
+      snapshot: knowledge.snapshot,
+      archive,
+      destination: root
+    });
+    const files = await readMaterializedWorkspaceFiles(root, knowledge.snapshot.material);
+    return Object.freeze({
+      candidate: knowledge.candidate,
+      snapshot: knowledge.snapshot,
+      files: Object.freeze(
+        files.map(
+          (file) => Object.freeze({ path: file.path, mode: file.mode, bytes: Uint8Array.from(file.bytes) })
+        )
+      ),
+      ...retrievalConfig ? { retrievalConfig: Uint8Array.from(retrievalConfig) } : {}
+    });
+  } finally {
+    await rm4(root, { recursive: true, force: true });
+  }
+}
+
+// src/candidate-execution/prepare.ts
 var MATERIALIZER_HARNESSES = /* @__PURE__ */ new Set([
   "claude-code",
   "claude",
@@ -4549,11 +4640,7 @@ async function prepareAgentCandidateExecution(candidate, task, ports, options =
       cleanupTimeoutMs
     );
     const memory = preparedMemory.value;
-    const knowledge = bundle.knowledge ? {
-      snapshotId: bundle.knowledge.snapshotId,
-      manifestDigest: bundle.knowledge.manifest.sha256,
-      manifest: await verifiedArtifactBytes(candidate, bundle.knowledge.manifest)
-    } : void 0;
+    const knowledge = await prepareAgentCandidateKnowledge(candidate, ports);
     const baseLaunch = buildLaunch(candidate, task, profileApplication.flags);
     const publicEnv = mergePublicEnvironment(
       bundle.execution.env ?? {},
@@ -4567,7 +4654,7 @@ async function prepareAgentCandidateExecution(candidate, task, ports, options =
     );
     const routes = modelRoutes(bundle.profile, task.model.requested);
     const executionMaterial = {
-      schemaVersion: 1,
+      schemaVersion: 2,
       kind: "agent-candidate-execution-plan-material",
       bundleDigest: bundle.digest,
       executionId: task.executionId,
@@ -4584,6 +4671,7 @@ async function prepareAgentCandidateExecution(candidate, task, ports, options =
           delivery: bundle.execution.instructionDelivery
         },
         repository: task.repository,
+        outcome: { kind: "workspace" },
         workspace: task.workspace
       },
       workspaces: {
@@ -4613,7 +4701,7 @@ async function prepareAgentCandidateExecution(candidate, task, ports, options =
         env: publicEnv,
         cwd: bundle.execution.cwd
       },
-      ...bundle.knowledge ? { knowledgeManifestDigest: bundle.knowledge.manifest.sha256 } : {},
+      ...bundle.knowledge ? { knowledgeManifestDigest: bundle.knowledge.snapshot.digest } : {},
       memory,
       limits: task.limits,
       network: { mode: "disabled" }
@@ -4625,7 +4713,7 @@ async function prepareAgentCandidateExecution(candidate, task, ports, options =
       throw new Error("execution plan canonical serializers disagree");
     }
     const executionPlan = agentCandidateExecutionPlanEvidenceSchema2.parse({
-      schemaVersion: 1,
+      schemaVersion: 2,
       kind: "agent-candidate-execution-plan",
       digest: executionDigest,
       material: executionMaterial,
@@ -4634,7 +4722,7 @@ async function prepareAgentCandidateExecution(candidate, task, ports, options =
     const entrypoint = candidateEntrypointReceipt(candidate);
     const materializationReceipt = canonicalCandidateDocument(
       {
-        schemaVersion: 1,
+        schemaVersion: 2,
         kind: "agent-candidate-materialization",
         digestAlgorithm: "rfc8785-sha256",
         bundleDigest: bundle.digest,
@@ -4647,7 +4735,7 @@ async function prepareAgentCandidateExecution(candidate, task, ports, options =
         harnessVersion: bundle.execution.harnessVersion,
         container,
         resolvedModel,
-        ...bundle.knowledge ? { knowledgeManifestDigest: bundle.knowledge.manifest.sha256 } : {},
+        ...bundle.knowledge ? { knowledgeManifestDigest: bundle.knowledge.snapshot.digest } : {},
         ...entrypoint ? { entrypoint } : {}
       }
     );
@@ -5119,7 +5207,7 @@ function exactProfileExecutorFiles(sourceFiles, expectedFiles) {
     const source = byPath.get(expected.relPath);
     const mode = source?.mode ?? 420;
     const bytes = Buffer.from(source?.content ?? "", "utf8");
-    if (!source || mode !== 420 && mode !== 493 || mode !== expected.mode || sha256Bytes(bytes) !== expected.contentSha256) {
+    if (!source || !Number.isInteger(mode) || mode < 0 || mode > 511 || mode !== expected.mode || sha256Bytes(bytes) !== expected.contentSha256) {
       throw new Error("profile source files do not match the signed profile plan");
     }
     return { path: expected.relPath, mode, bytes: Uint8Array.from(bytes) };
@@ -5179,6 +5267,7 @@ export {
   verifyBytes,
   verifyMaterializedWorkspace,
   captureMaterializedWorkspace,
+  candidateWorkspaceManifest,
   assertNoGitIndirection,
   readCandidateGitTreeFiles,
   runCandidateGit,
@@ -5200,4 +5289,4 @@ export {
   verifyAgentCandidateBundle,
   prepareAgentCandidateExecution
 };
-//# sourceMappingURL=chunk-37V4KQDC.js.map
+//# sourceMappingURL=chunk-CNH7DF7Z.js.map