@tangle-network/agent-runtime 0.101.1 → 0.102.1

package/dist/{chunk-HGSHPVJ6.js → chunk-LJLG734E.js}

@@ -1,3 +1,9 @@
+import {
+  assertNoProtectedBytes,
+  createProtectedRecordRedactor,
+  redactProtectedReason,
+  redactProtectedValue
+} from "./chunk-UPWGXKXB.js";
 import {
   contentAddress
 } from "./chunk-IMSNJSXH.js";
@@ -2531,6 +2537,182 @@ function retryLineageDigest(prepared, resultTimeoutMs) {
   });
 }
 
+// src/candidate-execution/verify.ts
+import { agentCandidateBundleSchema } from "@tangle-network/agent-interface";
+var verifiedCandidateState = /* @__PURE__ */ new WeakMap();
+var AGENT_CANDIDATE_EXECUTION_SUPPORT = Object.freeze({
+  outcomes: Object.freeze(["workspace", "output"]),
+  code: Object.freeze(["disabled", "no-op", "git-patch"]),
+  memory: Object.freeze(["disabled", "isolated"]),
+  knowledge: true,
+  profile: Object.freeze({
+    mcpTransports: Object.freeze(["stdio"]),
+    remoteMcp: false,
+    tools: false,
+    permissions: false,
+    modes: false,
+    confidential: false
+  })
+});
+async function verifyAgentCandidateBundle(input, ports) {
+  const parsed = agentCandidateBundleSchema.parse(input);
+  const withoutDigest = omitTopLevelDigest(parsed);
+  const actualDigest = canonicalCandidateDigest(withoutDigest);
+  if (actualDigest !== parsed.digest) {
+    throw new Error(`candidate bundle digest ${parsed.digest} does not match ${actualDigest}`);
+  }
+  const canonicalBytes = canonicalCandidateBytes(withoutDigest);
+  verifyBytes(canonicalBytes, parsed.digest, canonicalBytes.byteLength, "candidate bundle");
+  assertCandidateProfileExecutionSupport(parsed.profile);
+  const artifactBytes = /* @__PURE__ */ new Map();
+  const readArtifact = async (artifact) => {
+    const key = artifactCacheKey(artifact);
+    const existing = artifactBytes.get(key);
+    if (existing) return Uint8Array.from(existing);
+    const bytes = await readVerifiedArtifact(artifact, ports.artifacts);
+    artifactBytes.set(key, Uint8Array.from(bytes));
+    return bytes;
+  };
+  let patchBytes;
+  if (parsed.code.kind === "git-patch") {
+    patchBytes = await readArtifact(parsed.code.patch.artifact);
+  }
+  const materializedTree = await verifyCandidateCode(parsed.code, ports.repositories, patchBytes);
+  const resourceBytes = /* @__PURE__ */ new Map();
+  for (const resource of candidateResources(parsed)) {
+    const bytes = resource.kind === "inline" ? Buffer.from(resource.content, "utf8") : await readCandidateGitHubResource(resource, ports.repositories);
+    verifyBytes(
+      bytes,
+      resource.sha256,
+      resource.byteLength,
+      `candidate resource ${resource.name ?? (resource.kind === "github" ? resource.path : "<unnamed>")}`
+    );
+    resourceBytes.set(resourceKey(resource), Uint8Array.from(bytes));
+    resourceBytes.set(resource.sha256, Uint8Array.from(bytes));
+  }
+  if (parsed.execution.workspace) {
+    const workspace = await verifyWorkspaceSnapshotArtifacts(
+      parsed.execution.workspace,
+      ports.artifacts
+    );
+    artifactBytes.set(artifactCacheKey(parsed.execution.workspace.manifest), workspace.manifest);
+    artifactBytes.set(artifactCacheKey(parsed.execution.workspace.archive), workspace.archive);
+  }
+  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);
+  const verified = Object.freeze({
+    bundle: parsed,
+    ...materializedTree === void 0 ? {} : { materializedTree },
+    [verifiedCandidateBrand]: true
+  });
+  verifiedCandidateState.set(verified, { ports, artifactBytes, resourceBytes });
+  return verified;
+}
+function getVerifiedCandidateState(candidate) {
+  const state = verifiedCandidateState.get(candidate);
+  if (!state || candidate[verifiedCandidateBrand] !== true) {
+    throw new Error("candidate must come from verifyAgentCandidateBundle");
+  }
+  return state;
+}
+async function verifiedArtifactBytes(candidate, artifact) {
+  const state = getVerifiedCandidateState(candidate);
+  const key = artifactCacheKey(artifact);
+  const existing = state.artifactBytes.get(key);
+  if (existing) return Uint8Array.from(existing);
+  const bytes = await readVerifiedArtifact(artifact, state.ports.artifacts);
+  state.artifactBytes.set(key, Uint8Array.from(bytes));
+  return bytes;
+}
+function verifiedResourceTextByDigest(candidate) {
+  const output = /* @__PURE__ */ new Map();
+  for (const resource of candidateResources(candidate.bundle)) {
+    const bytes = getVerifiedCandidateState(candidate).resourceBytes.get(resource.sha256);
+    if (!bytes) throw new Error(`candidate resource digest was not verified: ${resource.sha256}`);
+    output.set(resource.sha256, new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  }
+  return output;
+}
+function candidateResources(bundle) {
+  const resources = bundle.profile.resources;
+  if (!resources) return [];
+  const output = [];
+  for (const mount of resources.files ?? []) output.push(mount.resource);
+  output.push(...resources.tools ?? []);
+  output.push(...resources.skills ?? []);
+  output.push(...resources.agents ?? []);
+  output.push(...resources.commands ?? []);
+  if (typeof resources.instructions === "object") output.push(resources.instructions);
+  return output;
+}
+function resourceKey(resource) {
+  return canonicalCandidateDigest(resource);
+}
+
+// src/candidate-execution/knowledge.ts
+import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2, posix } from "path";
+import { hashKnowledgeBase } from "@tangle-network/agent-knowledge";
+var CANDIDATE_KNOWLEDGE_ROOT_ENV = "TANGLE_CANDIDATE_KNOWLEDGE_ROOT";
+var CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV = "TANGLE_CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG";
+function candidateKnowledgeExecutionPaths(taskRoot, hasRetrievalConfig) {
+  if (!posix.isAbsolute(taskRoot) || posix.normalize(taskRoot) !== taskRoot) {
+    throw new Error("candidate knowledge requires a normalized absolute task root");
+  }
+  const parent = posix.join(taskRoot, ".tangle");
+  return {
+    root: posix.join(parent, "knowledge"),
+    ...hasRetrievalConfig ? { retrievalConfig: posix.join(parent, "knowledge-retrieval-config.json") } : {}
+  };
+}
+async function prepareAgentCandidateKnowledge(candidate, ports, arm) {
+  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 mkdtemp2(join2(tmpdir2(), "agent-candidate-knowledge-"));
+  try {
+    await ports.workspaces.materialize({
+      role: "knowledge",
+      snapshot: knowledge.snapshot,
+      archive,
+      destination: root
+    });
+    const expectedHash = arm === "baseline" ? knowledge.candidate.baseHash : knowledge.candidate.candidateHash;
+    const actualHash = `sha256:${await hashKnowledgeBase(root)}`;
+    if (actualHash !== expectedHash) {
+      throw new Error(
+        `materialized ${arm} knowledge does not match its measured content: expected ${expectedHash}, got ${actualHash}`
+      );
+    }
+    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 rm2(root, { recursive: true, force: true });
+  }
+}
+
 // src/candidate-execution/output-artifacts.ts
 import {
   agentCandidateArtifactRefSchema as agentCandidateArtifactRefSchema3
@@ -2663,7 +2845,7 @@ function requireRecord(value, label) {
 }
 
 // src/candidate-execution/finalize.ts
-import { isLlmSpan as isLlmSpan2, REDACTION_VERSION as REDACTION_VERSION2 } from "@tangle-network/agent-eval";
+import { isLlmSpan as isLlmSpan2, REDACTION_VERSION } from "@tangle-network/agent-eval";
 import {
   agentCandidateRunReceiptSchema,
   agentCandidateWorkspaceSnapshotEvidenceSchema
@@ -2891,253 +3073,6 @@ function safeAdd(left, right, label) {
   return total;
 }
 
-// src/candidate-execution/protected-redaction.ts
-import { createHmac, randomBytes as randomBytes2 } from "crypto";
-import {
-  DEFAULT_REDACTION_RULES,
-  REDACTION_VERSION,
-  redactString
-} from "@tangle-network/agent-eval";
-function createProtectedRecordRedactor(protectedValues) {
-  const identityKey = randomBytes2(32);
-  const aggregate = {
-    version: REDACTION_VERSION,
-    redactionCount: 0,
-    byRule: {}
-  };
-  const mergeReport = (report) => {
-    aggregate.version = report.version;
-    aggregate.redactionCount += report.redactionCount;
-    for (const [rule, count] of Object.entries(report.byRule)) {
-      aggregate.byRule[rule] = (aggregate.byRule[rule] ?? 0) + count;
-    }
-  };
-  const redactScalar = (value, record) => {
-    const redacted = redactProtectedValue(value, protectedValues);
-    if (record) mergeReport(redacted.report);
-    return redacted.value;
-  };
-  const identifier = (value, record) => {
-    const redacted = redactScalar(value, record);
-    if (redacted === value) return value;
-    const digest = createHmac("sha256", identityKey).update(value).digest("hex");
-    return `${redacted}:hmac-sha256:${digest}`;
-  };
-  const transform = (value, record) => {
-    const transformed = transformProtectedRecord(
-      value,
-      void 0,
-      record,
-      redactScalar,
-      identifier
-    );
-    assertNoProtectedEvidence(transformed, protectedValues);
-    return transformed;
-  };
-  return Object.freeze({
-    record: (value) => transform(value, true),
-    query: (value) => transform(value, false),
-    identifier: (value) => identifier(value, false),
-    traceIdentity: (trace) => transform(trace, false),
-    report: () => ({
-      version: aggregate.version,
-      redactionCount: aggregate.redactionCount,
-      byRule: { ...aggregate.byRule }
-    })
-  });
-}
-function redactProtectedValue(value, protectedValues) {
-  const report = {
-    version: REDACTION_VERSION,
-    redactionCount: 0,
-    byRule: {}
-  };
-  const rules = protectedRedactionRules(protectedValues);
-  const redacted = redactNode(value, protectedValues, rules, report);
-  assertNoProtectedEvidence(redacted, protectedValues);
-  return { value: redacted, report };
-}
-function redactProtectedReason(reason, protectedValues) {
-  try {
-    return redactProtectedValue(reason, protectedValues).value;
-  } catch {
-    return "candidate execution failed with a protected error";
-  }
-}
-function assertNoProtectedEvidence(value, protectedValues) {
-  if (value instanceof Uint8Array) {
-    assertNoProtectedBytes(value, protectedValues);
-    return;
-  }
-  if (typeof value === "string") {
-    for (const protectedValue of protectedValueVariants(protectedValues)) {
-      if (value.includes(protectedValue)) {
-        throw new Error("protected value survived candidate evidence redaction");
-      }
-    }
-    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {
-      throw new Error("base64 protected value survived candidate evidence redaction");
-    }
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const entry of value) assertNoProtectedEvidence(entry, protectedValues);
-    return;
-  }
-  if (value && typeof value === "object") {
-    for (const [key, entry] of Object.entries(value)) {
-      assertNoProtectedEvidence(key, protectedValues);
-      assertNoProtectedEvidence(entry, protectedValues);
-    }
-  }
-}
-function assertNoProtectedBytes(bytes, protectedValues) {
-  if (containsProtectedBytes(bytes, protectedValues)) {
-    throw new Error("protected value survived candidate evidence byte redaction");
-  }
-}
-function redactNode(value, protectedValues, rules, report) {
-  if (value instanceof Uint8Array) {
-    if (containsProtectedBytes(value, protectedValues)) {
-      recordRedaction(report, "candidate-access-binary", 1);
-      return Uint8Array.from(Buffer.from("[redacted:candidate-access-binary]", "utf8"));
-    }
-    return Uint8Array.from(value);
-  }
-  if (typeof value === "string") {
-    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {
-      recordRedaction(report, "candidate-access-binary", 1);
-      return "[redacted:candidate-access-binary]";
-    }
-    const redacted = redactString(value, [...rules]);
-    for (const [rule, count] of Object.entries(redacted.report.byRule)) {
-      recordRedaction(report, rule, count);
-    }
-    return redacted.output;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => redactNode(entry, protectedValues, rules, report));
-  }
-  if (value && typeof value === "object") {
-    const entries = [];
-    const seenKeys = /* @__PURE__ */ new Set();
-    for (const [key, entry] of Object.entries(value)) {
-      const redactedKey = redactNode(key, protectedValues, rules, report);
-      if (typeof redactedKey !== "string" || seenKeys.has(redactedKey)) {
-        throw new Error("protected evidence redaction produced an ambiguous object key");
-      }
-      seenKeys.add(redactedKey);
-      entries.push([redactedKey, redactNode(entry, protectedValues, rules, report)]);
-    }
-    return Object.fromEntries(entries);
-  }
-  return value;
-}
-function transformProtectedRecord(value, fieldName, record, redactScalar, redactIdentifier) {
-  if (value instanceof Uint8Array) return redactScalar(value, record);
-  if (typeof value === "string") {
-    return fieldName && isIdentifierFieldName(fieldName) ? redactIdentifier(value, record) : redactScalar(value, record);
-  }
-  if (Array.isArray(value)) {
-    return value.map(
-      (entry) => transformProtectedRecord(entry, fieldName, record, redactScalar, redactIdentifier)
-    );
-  }
-  if (!value || typeof value !== "object") return value;
-  if (fieldName === "tags") {
-    return transformTagMap(value, record, redactScalar, redactIdentifier);
-  }
-  if (fieldName === "tag") {
-    return transformTagFilter(value, record, redactScalar, redactIdentifier);
-  }
-  const entries = [];
-  const seenKeys = /* @__PURE__ */ new Set();
-  for (const [key, entry] of Object.entries(value)) {
-    const redactedKey = redactScalar(key, record);
-    if (seenKeys.has(redactedKey)) {
-      throw new Error("protected evidence redaction produced an ambiguous object key");
-    }
-    seenKeys.add(redactedKey);
-    entries.push([
-      redactedKey,
-      transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier)
-    ]);
-  }
-  return Object.fromEntries(entries);
-}
-function transformTagMap(value, record, redactScalar, redactIdentifier) {
-  const entries = [];
-  const seenKeys = /* @__PURE__ */ new Set();
-  for (const [key, entry] of Object.entries(value)) {
-    const redactedKey = redactIdentifier(key, record);
-    if (seenKeys.has(redactedKey)) {
-      throw new Error("protected evidence redaction produced an ambiguous trace tag");
-    }
-    seenKeys.add(redactedKey);
-    entries.push([
-      redactedKey,
-      typeof entry === "string" ? redactIdentifier(entry, record) : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier)
-    ]);
-  }
-  return Object.fromEntries(entries);
-}
-function transformTagFilter(value, record, redactScalar, redactIdentifier) {
-  const output = {};
-  for (const [key, entry] of Object.entries(value)) {
-    const redactedKey = redactScalar(key, record);
-    output[redactedKey] = (key === "key" || key === "value") && typeof entry === "string" ? redactIdentifier(entry, record) : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier);
-  }
-  return output;
-}
-function isIdentifierFieldName(name) {
-  return /ids?$/i.test(name);
-}
-function protectedRedactionRules(protectedValues) {
-  const exactRules = protectedValueVariants(protectedValues).sort((left, right) => right.length - left.length || left.localeCompare(right)).map((value, index) => ({
-    id: `candidate-access-${index}`,
-    pattern: new RegExp(escapeRegularExpression(value), "g"),
-    replacement: "[redacted:candidate-access]"
-  }));
-  return [...exactRules, ...DEFAULT_REDACTION_RULES];
-}
-function recordRedaction(report, rule, count) {
-  if (count <= 0) return;
-  report.redactionCount += count;
-  report.byRule[rule] = (report.byRule[rule] ?? 0) + count;
-}
-function containsProtectedBytes(bytes, protectedValues) {
-  const source = Buffer.from(bytes);
-  return protectedValueVariants(protectedValues).some(
-    (value) => source.includes(Buffer.from(value, "utf8"))
-  );
-}
-function decodedBase64ContainsProtectedValue(value, protectedValues) {
-  if (value.length < 4 || value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {
-    return false;
-  }
-  try {
-    return containsProtectedBytes(Buffer.from(value, "base64"), protectedValues);
-  } catch {
-    return false;
-  }
-}
-function protectedValueVariants(protectedValues) {
-  const variants = /* @__PURE__ */ new Set();
-  for (const value of normalizedProtectedValues(protectedValues)) {
-    variants.add(value);
-    variants.add(Buffer.from(value, "utf8").toString("base64"));
-    variants.add(Buffer.from(value, "utf8").toString("base64url"));
-    variants.add(encodeURIComponent(value));
-  }
-  return [...variants];
-}
-function normalizedProtectedValues(values) {
-  return [...new Set(values.filter((value) => value.length > 0))];
-}
-function escapeRegularExpression(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 // src/candidate-execution/finalize.ts
 async function finalizeAgentCandidateRun(state, capture, traceStore, traceIdentity, settlement, evidence, protectedValues, writeRedactionReport, signal) {
   let termination;
@@ -3185,7 +3120,7 @@ async function finalizeAgentCandidateRun(state, capture, traceStore, traceIdenti
     );
     const redacted = redactProtectedValue(
       {
-        run: { ...run, redactionVersion: REDACTION_VERSION2 },
+        run: { ...run, redactionVersion: REDACTION_VERSION },
         spans: orderedSpans,
         events: orderedEvents,
         budget: orderedBudget,
@@ -3201,7 +3136,7 @@ async function finalizeAgentCandidateRun(state, capture, traceStore, traceIdenti
       ...redacted.value,
       evaluatorLimits: { resultTimeoutMs: state.resultTimeoutMs },
       redaction: {
-        version: REDACTION_VERSION2,
+        version: REDACTION_VERSION,
         redactionCount: (writeRedactionReport?.redactionCount ?? 0) + redacted.report.redactionCount,
         byRule: combinedByRule
       }
@@ -3348,9 +3283,9 @@ function compareStrings(a, b) {
 }
 
 // src/candidate-execution/outcome-evidence.ts
-import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join2 } from "path";
+import { mkdtemp as mkdtemp3, rm as rm3 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join3 } from "path";
 import {
   agentCandidateBenchmarkResultEvidenceSchema,
   agentCandidateModelSettlementEvidenceSchema,
@@ -3846,7 +3781,7 @@ async function persistCandidateBenchmarkResult(state, termination, outcome, grad
   );
 }
 async function verifyTaskOutcomeArchive(state, snapshot, archive, protectedValues) {
-  const root = await mkdtemp2(join2(tmpdir2(), "agent-candidate-task-archive-"));
+  const root = await mkdtemp3(join3(tmpdir3(), "agent-candidate-task-archive-"));
   try {
     await state.ports.workspaces.materialize({
       role: "task",
@@ -3857,7 +3792,7 @@ async function verifyTaskOutcomeArchive(state, snapshot, archive, protectedValue
     const files = await readMaterializedWorkspaceFiles(root, snapshot.material);
     for (const file of files) assertNoProtectedBytes(file.bytes, protectedValues);
   } finally {
-    await rm2(root, { recursive: true, force: true });
+    await rm3(root, { recursive: true, force: true });
   }
 }
 async function verifyMemoryCapture(state, capture, protectedValues, signal) {
@@ -3878,7 +3813,7 @@ async function verifyMemoryCapture(state, capture, protectedValues, signal) {
     manifest: embeddedCandidateArtifact(manifestBytes),
     archive: embeddedCandidateArtifact(memory.archive)
   });
-  const root = await mkdtemp2(join2(tmpdir2(), "agent-candidate-memory-after-"));
+  const root = await mkdtemp3(join3(tmpdir3(), "agent-candidate-memory-after-"));
   try {
     await state.ports.workspaces.materialize({
       role: "memory",
@@ -3890,7 +3825,7 @@ async function verifyMemoryCapture(state, capture, protectedValues, signal) {
     for (const file of files) assertNoProtectedBytes(file.bytes, protectedValues);
     signal?.throwIfAborted();
   } finally {
-    await rm2(root, { recursive: true, force: true });
+    await rm3(root, { recursive: true, force: true });
   }
 }
 function normalizeEvaluation(evaluation, termination) {
@@ -4794,184 +4729,8 @@ var CandidateExecutionDeadlineError = class extends Error {
   }
 };
 
-// src/candidate-execution/verify.ts
-import { agentCandidateBundleSchema } from "@tangle-network/agent-interface";
-var verifiedCandidateState = /* @__PURE__ */ new WeakMap();
-var AGENT_CANDIDATE_EXECUTION_SUPPORT = Object.freeze({
-  outcomes: Object.freeze(["workspace", "output"]),
-  code: Object.freeze(["disabled", "no-op", "git-patch"]),
-  memory: Object.freeze(["disabled", "isolated"]),
-  knowledge: true,
-  profile: Object.freeze({
-    mcpTransports: Object.freeze(["stdio"]),
-    remoteMcp: false,
-    tools: false,
-    permissions: false,
-    modes: false,
-    confidential: false
-  })
-});
-async function verifyAgentCandidateBundle(input, ports) {
-  const parsed = agentCandidateBundleSchema.parse(input);
-  const withoutDigest = omitTopLevelDigest(parsed);
-  const actualDigest = canonicalCandidateDigest(withoutDigest);
-  if (actualDigest !== parsed.digest) {
-    throw new Error(`candidate bundle digest ${parsed.digest} does not match ${actualDigest}`);
-  }
-  const canonicalBytes = canonicalCandidateBytes(withoutDigest);
-  verifyBytes(canonicalBytes, parsed.digest, canonicalBytes.byteLength, "candidate bundle");
-  assertCandidateProfileExecutionSupport(parsed.profile);
-  const artifactBytes = /* @__PURE__ */ new Map();
-  const readArtifact = async (artifact) => {
-    const key = artifactCacheKey(artifact);
-    const existing = artifactBytes.get(key);
-    if (existing) return Uint8Array.from(existing);
-    const bytes = await readVerifiedArtifact(artifact, ports.artifacts);
-    artifactBytes.set(key, Uint8Array.from(bytes));
-    return bytes;
-  };
-  let patchBytes;
-  if (parsed.code.kind === "git-patch") {
-    patchBytes = await readArtifact(parsed.code.patch.artifact);
-  }
-  const materializedTree = await verifyCandidateCode(parsed.code, ports.repositories, patchBytes);
-  const resourceBytes = /* @__PURE__ */ new Map();
-  for (const resource of candidateResources(parsed)) {
-    const bytes = resource.kind === "inline" ? Buffer.from(resource.content, "utf8") : await readCandidateGitHubResource(resource, ports.repositories);
-    verifyBytes(
-      bytes,
-      resource.sha256,
-      resource.byteLength,
-      `candidate resource ${resource.name ?? (resource.kind === "github" ? resource.path : "<unnamed>")}`
-    );
-    resourceBytes.set(resourceKey(resource), Uint8Array.from(bytes));
-    resourceBytes.set(resource.sha256, Uint8Array.from(bytes));
-  }
-  if (parsed.execution.workspace) {
-    const workspace = await verifyWorkspaceSnapshotArtifacts(
-      parsed.execution.workspace,
-      ports.artifacts
-    );
-    artifactBytes.set(artifactCacheKey(parsed.execution.workspace.manifest), workspace.manifest);
-    artifactBytes.set(artifactCacheKey(parsed.execution.workspace.archive), workspace.archive);
-  }
-  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);
-  const verified = Object.freeze({
-    bundle: parsed,
-    ...materializedTree === void 0 ? {} : { materializedTree },
-    [verifiedCandidateBrand]: true
-  });
-  verifiedCandidateState.set(verified, { ports, artifactBytes, resourceBytes });
-  return verified;
-}
-function getVerifiedCandidateState(candidate) {
-  const state = verifiedCandidateState.get(candidate);
-  if (!state || candidate[verifiedCandidateBrand] !== true) {
-    throw new Error("candidate must come from verifyAgentCandidateBundle");
-  }
-  return state;
-}
-async function verifiedArtifactBytes(candidate, artifact) {
-  const state = getVerifiedCandidateState(candidate);
-  const key = artifactCacheKey(artifact);
-  const existing = state.artifactBytes.get(key);
-  if (existing) return Uint8Array.from(existing);
-  const bytes = await readVerifiedArtifact(artifact, state.ports.artifacts);
-  state.artifactBytes.set(key, Uint8Array.from(bytes));
-  return bytes;
-}
-function verifiedResourceTextByDigest(candidate) {
-  const output = /* @__PURE__ */ new Map();
-  for (const resource of candidateResources(candidate.bundle)) {
-    const bytes = getVerifiedCandidateState(candidate).resourceBytes.get(resource.sha256);
-    if (!bytes) throw new Error(`candidate resource digest was not verified: ${resource.sha256}`);
-    output.set(resource.sha256, new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-  }
-  return output;
-}
-function candidateResources(bundle) {
-  const resources = bundle.profile.resources;
-  if (!resources) return [];
-  const output = [];
-  for (const mount of resources.files ?? []) output.push(mount.resource);
-  output.push(...resources.tools ?? []);
-  output.push(...resources.skills ?? []);
-  output.push(...resources.agents ?? []);
-  output.push(...resources.commands ?? []);
-  if (typeof resources.instructions === "object") output.push(resources.instructions);
-  return output;
-}
-function resourceKey(resource) {
-  return canonicalCandidateDigest(resource);
-}
-
-// src/candidate-execution/knowledge.ts
-import { mkdtemp as mkdtemp3, rm as rm3 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join3, posix } from "path";
-import { hashKnowledgeBase } from "@tangle-network/agent-knowledge";
-var CANDIDATE_KNOWLEDGE_ROOT_ENV = "TANGLE_CANDIDATE_KNOWLEDGE_ROOT";
-var CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV = "TANGLE_CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG";
-function candidateKnowledgeExecutionPaths(taskRoot, hasRetrievalConfig) {
-  if (!posix.isAbsolute(taskRoot) || posix.normalize(taskRoot) !== taskRoot) {
-    throw new Error("candidate knowledge requires a normalized absolute task root");
-  }
-  const parent = posix.join(taskRoot, ".tangle");
-  return {
-    root: posix.join(parent, "knowledge"),
-    ...hasRetrievalConfig ? { retrievalConfig: posix.join(parent, "knowledge-retrieval-config.json") } : {}
-  };
-}
-async function prepareAgentCandidateKnowledge(candidate, ports, arm) {
-  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 mkdtemp3(join3(tmpdir3(), "agent-candidate-knowledge-"));
-  try {
-    await ports.workspaces.materialize({
-      role: "knowledge",
-      snapshot: knowledge.snapshot,
-      archive,
-      destination: root
-    });
-    const expectedHash = arm === "baseline" ? knowledge.candidate.baseHash : knowledge.candidate.candidateHash;
-    const actualHash = `sha256:${await hashKnowledgeBase(root)}`;
-    if (actualHash !== expectedHash) {
-      throw new Error(
-        `materialized ${arm} knowledge does not match its measured content: expected ${expectedHash}, got ${actualHash}`
-      );
-    }
-    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 rm3(root, { recursive: true, force: true });
-  }
-}
-
 // src/candidate-execution/prepare.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 import { lstat as lstat2, readdir as readdir2 } from "fs/promises";
 import { isAbsolute, posix as posix2, relative as relative2, resolve as resolveHostPath } from "path";
 import {
@@ -5097,7 +4856,7 @@ async function prepareAgentCandidateExecution(candidate, task, ports, options =
   const profileActivation = profileApplication.profileActivation;
   const container = await resolveContainer(candidate, task, ports);
   const resolvedModel = await resolveModel(candidate, task, ports);
-  const preparationId = `candidate-preparation.${randomBytes3(32).toString("base64url")}`;
+  const preparationId = `candidate-preparation.${randomBytes2(32).toString("base64url")}`;
   const reservationExpiresAtMs = Date.now() + Math.max(MIN_RESERVATION_TTL_MS, reservationWindowMs);
   const modelReservation = await withinCandidateCleanupDeadline(
     () => ports.models.reserveGrant({
@@ -5802,17 +5561,17 @@ export {
   candidateClaimFileInternals,
   sealAgentCandidateModelSettlement,
   usdToNanos,
-  sealAgentCandidateExecutorStopAcknowledgement,
-  persistCandidateOutputArtifact,
-  persistCandidateModelSettlementEvidence,
-  RecoveryAgentCandidateTraceStore,
-  executePreparedAgentCandidate,
   AGENT_CANDIDATE_EXECUTION_SUPPORT,
   verifyAgentCandidateBundle,
   verifiedResourceTextByDigest,
   CANDIDATE_KNOWLEDGE_ROOT_ENV,
   CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV,
   candidateKnowledgeExecutionPaths,
+  sealAgentCandidateExecutorStopAcknowledgement,
+  persistCandidateOutputArtifact,
+  persistCandidateModelSettlementEvidence,
+  RecoveryAgentCandidateTraceStore,
+  executePreparedAgentCandidate,
   prepareAgentCandidateExecution
 };
-//# sourceMappingURL=chunk-HGSHPVJ6.js.map
+//# sourceMappingURL=chunk-LJLG734E.js.map