@tangle-network/agent-runtime 0.94.13 → 0.95.0

package/dist/{chunk-PCURO3DL.js → chunk-G55QE4IQ.js}

@@ -1,9 +1,28 @@
+import {
+  agentCandidateProfileAsAgentProfile,
+  candidateMaterializerHarness,
+  canonicalCandidateBytes,
+  canonicalCandidateDigest,
+  canonicalCandidateDocument,
+  createAgentCandidateProfileActivation,
+  executePreparedAgentCandidate,
+  immutableCandidateValue,
+  omitTopLevelDigest,
+  parseAgentCandidateProfileActivation,
+  prepareAgentCandidateExecution,
+  verifiedResourceTextByDigest,
+  verifyAgentCandidateBundle,
+  verifyCanonicalCandidateDocument
+} from "./chunk-WTZ37EQY.js";
 import {
   assertModelAllowed
 } from "./chunk-ISTDY47H.js";
+import {
+  runAnalystLoop
+} from "./chunk-QDSOD7RC.js";
 import {
   agenticGenerator
-} from "./chunk-D3H7F6L2.js";
+} from "./chunk-DHCHL6OG.js";
 import {
   ConfigError
 } from "./chunk-YEJR7IXO.js";
@@ -13,6 +32,24 @@ import { spawnSync } from "child_process";
 import {
   verifyCodeSurface
 } from "@tangle-network/agent-eval/campaign";
+
+// src/improvement/cleanup.ts
+async function rethrowAfterCleanup(cause, cleanup, context) {
+  const cleanupErrors = [];
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await cleanup();
+    } catch (cleanupCause) {
+      cleanupErrors.push(cleanupCause);
+      continue;
+    }
+    if (cleanupErrors.length === 0) throw cause;
+    throw new AggregateError([cause, ...cleanupErrors], `${context}; cleanup retry succeeded`);
+  }
+  throw new AggregateError([cause, ...cleanupErrors], `${context}; cleanup failed`);
+}
+
+// src/improvement/improvement-driver.ts
 function improvementDriver(opts) {
   const baseRef = opts.baseRef ?? "main";
   const owned = /* @__PURE__ */ new Map();
@@ -57,22 +94,14 @@ function improvementDriver(opts) {
           owned.delete(wt.path);
           owned.set(surface.worktreeRef, wt);
         } catch (err) {
-          const cleanupErrors = [];
-          for (let attempt = 0; attempt < 2; attempt += 1) {
-            try {
+          const failure = err instanceof Error ? err.message : String(err);
+          return rethrowAfterCleanup(
+            err,
+            async () => {
               await opts.worktree.discard(wt);
               owned.delete(wt.path);
-              break;
-            } catch (cause) {
-              cleanupErrors.push(cause);
-            }
-          }
-          if (cleanupErrors.length === 0) throw err;
-          const failure = err instanceof Error ? err.message : String(err);
-          const cleanupSucceeded = !owned.has(wt.path);
-          throw new AggregateError(
-            [err, ...cleanupErrors],
-            cleanupSucceeded ? `improvementDriver: ${failure}; candidate cleanup retry succeeded` : `improvementDriver: ${failure}; candidate worktree could not be cleaned`
+            },
+            `improvementDriver: ${failure}`
           );
         }
       }
@@ -365,6 +394,8 @@ function baselineSurfaceFor(profile, surface, skills, memory) {
       );
   }
 }
+var DISTILLED_NOTES_MAX_CHARS = 1500;
+var DISTILLED_ERROR_MAX_CHARS = 500;
 function generationFailureDistiller(staticFindings) {
   const CAP = 12;
   return async (input) => {
@@ -379,14 +410,14 @@ function generationFailureDistiller(staticFindings) {
         ) : [];
         const composite = judgeScores.length === 0 ? 0 : judgeScores.reduce((sum, j) => sum + (j.composite ?? 0), 0) / judgeScores.length;
         if (!error && composite >= 0.999) continue;
-        const notes = judgeScores.map((j) => j.notes).filter((n) => typeof n === "string" && n.length > 0).join("; ").slice(0, 400);
-        const claim = notes || (error ? `Scenario ${scenario} failed: ${error.slice(0, 200)}` : "");
+        const notes = judgeScores.map((j) => j.notes).filter((n) => typeof n === "string" && n.length > 0).join("; ").slice(0, DISTILLED_NOTES_MAX_CHARS);
+        const claim = notes || (error ? `Scenario ${scenario} failed: ${error.slice(0, DISTILLED_ERROR_MAX_CHARS)}` : "");
         failures.push({
           scenario,
           composite: Number(composite.toFixed(3)),
           notes,
           ...claim ? { claim } : {},
-          ...error ? { error: error.slice(0, 200) } : {}
+          ...error ? { error: error.slice(0, DISTILLED_ERROR_MAX_CHARS) } : {}
         });
       }
     }
@@ -402,25 +433,11 @@ function memoryGenerationDistiller(staticFindings) {
     return fresh === staticFindings ? staticFindings : [...staticFindings, ...fresh];
   };
 }
-async function rethrowAfterCleanup(cause, cleanup, message) {
-  const cleanupErrors = [];
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      await cleanup();
-    } catch (cleanupCause) {
-      cleanupErrors.push(cleanupCause);
-      continue;
-    }
-    if (cleanupErrors.length === 0) throw cause;
-    throw new AggregateError([cause, ...cleanupErrors], `${message}; the cleanup retry succeeded`);
-  }
-  throw new AggregateError([cause, ...cleanupErrors], message);
-}
 async function discardPreparedBaseline(worktree, baselineWorktree, cause) {
   return rethrowAfterCleanup(
     cause,
     () => worktree.discard(baselineWorktree),
-    "improve(): code preparation failed and its baseline worktree could not be cleaned"
+    "improve(): code preparation failed"
   );
 }
 function isCodeSurface(surface) {
@@ -608,7 +625,7 @@ async function improve(profile, findings, opts) {
     return rethrowAfterCleanup(
       cause,
       () => preparedCode.cleanup(),
-      "improve(): code improvement failed and its worktrees could not be cleaned"
+      "improve(): code improvement failed"
     );
   }
   const shipped = raw.gateDecision === "ship";
@@ -652,10 +669,469 @@ async function improve(profile, findings, opts) {
   };
 }
 
+// src/intelligence/improvement-cycle.ts
+import { assertNoJudgeVerdict } from "@tangle-network/agent-eval/analyst";
+import {
+  measuredComparisonFromCandidateExperiment,
+  runCandidateExperiment,
+  verifyCandidateExperiment,
+  verifyCandidateExperimentComparison
+} from "@tangle-network/agent-eval/contract";
+import {
+  agentCandidateMaterializationReceiptSchema,
+  agentCandidateRunReceiptSchema,
+  agentImprovementActivationSchema,
+  agentImprovementProposalSchema,
+  agentImprovementReviewSchema,
+  candidateExecutionEvidenceSchema
+} from "@tangle-network/agent-interface";
+import { materializeCandidateProfile } from "@tangle-network/agent-profile-materialize";
+var AgentCandidateExperimentCellExecutionError = class extends Error {
+  finalization;
+  constructor(finalization) {
+    super(`candidate experiment cell failed: ${finalization.reason}`);
+    this.name = "AgentCandidateExperimentCellExecutionError";
+    this.finalization = finalization;
+  }
+};
+async function runAgentCandidateExperiment(options) {
+  const experiment = verifyCandidateExperiment(options.experiment);
+  const measurements = await runCandidateExperiment({
+    experiment,
+    ...options.maxConcurrency === void 0 ? {} : { maxConcurrency: options.maxConcurrency },
+    ...options.signal ? { signal: options.signal } : {},
+    execute: async (input) => {
+      const placement = await options.placeCell(input);
+      return await executeAgentCandidateExperimentCell({ ...input, ...placement });
+    }
+  });
+  const evaluation = createAgentImprovementMeasuredComparison({
+    experiment,
+    measurements,
+    runId: options.runId,
+    ...options.candidate ? { candidate: options.candidate } : {},
+    ...options.generationsExplored === void 0 ? {} : { generationsExplored: options.generationsExplored },
+    ...options.searchDurationMs === void 0 ? {} : { searchDurationMs: options.searchDurationMs },
+    ...options.searchCostUsd === void 0 ? {} : { searchCostUsd: options.searchCostUsd },
+    ...options.metadata ? { metadata: options.metadata } : {}
+  });
+  return { experiment, measurements, evaluation };
+}
+async function executeAgentCandidateExperimentCell(options) {
+  const experiment = verifyCandidateExperiment(options.experiment);
+  const bundle = experiment[options.arm];
+  assertExactExperimentInput(options, experiment, bundle);
+  const attempt = options.attempt ?? 1;
+  if (attempt > options.task.attempt.maxAttempts) {
+    throw new Error("candidate experiment attempt exceeds the signed task policy");
+  }
+  const runCell = canonicalCandidateDocument({
+    kind: "agent-candidate-run-cell",
+    experimentDigest: experiment.digest,
+    arm: options.arm,
+    bundleDigest: bundle.digest,
+    suiteDigest: options.benchmarkCell.suiteDigest,
+    taskDigest: options.task.digest,
+    taskIndex: options.benchmarkCell.taskIndex,
+    repetition: options.benchmarkCell.repetition,
+    seed: options.seed,
+    attempt
+  }).value;
+  const verified = await verifyAgentCandidateBundle(bundle, options.ports);
+  const prepared = await prepareAgentCandidateExecution(
+    verified,
+    {
+      executionId: options.executionId,
+      runCell,
+      benchmarkSuite: experiment.benchmark.suite,
+      task: options.task,
+      executionRoots: options.executionRoots,
+      stagingRoots: options.stagingRoots
+    },
+    options.ports,
+    options.preparation
+  );
+  const finalization = await executePreparedAgentCandidate(prepared, options.execution);
+  if (!finalization.succeeded) {
+    throw new AgentCandidateExperimentCellExecutionError(finalization);
+  }
+  const evidence = canonicalCandidateDocument({
+    kind: "agent-candidate-execution-evidence",
+    materializationReceipt: prepared.materializationReceipt.value,
+    receipt: finalization.receipt.value
+  }).value;
+  return verifyCandidateExecutionEvidence(evidence, {
+    experiment,
+    arm: options.arm,
+    benchmarkCell: options.benchmarkCell,
+    seed: options.seed,
+    attempt,
+    resolvedResources: verifiedResourceTextByDigest(verified)
+  });
+}
+function createAgentImprovementMeasuredComparison(options) {
+  return verifyCandidateExperimentComparison(measuredComparisonFromCandidateExperiment(options));
+}
+async function proposeAgentImprovement(options) {
+  const writeBackSurface = options.improvement.skills?.writeBack ? "skill" : options.improvement.memory?.writeBack ? "memory" : null;
+  if (writeBackSurface) {
+    throw new Error(`proposeAgentImprovement cannot write ${writeBackSurface} before approval`);
+  }
+  const analysis = await runAnalystLoop({ ...options.analysis, runId: options.runId });
+  const findings = assertNoJudgeVerdict(
+    analysis.analystResult.findings,
+    "proposeAgentImprovement findings"
+  );
+  const improvement = await improve(options.profile, [...findings], options.improvement);
+  try {
+    if (!improvement.shipped) {
+      throw new Error("agent improvement search did not produce a promotable candidate");
+    }
+    const experiment = verifyCandidateExperiment(
+      await options.buildExperiment({ analysis, improvement })
+    );
+    if (canonicalCandidateDigest(experiment.baseline.profile) !== canonicalCandidateDigest(options.profile)) {
+      throw new Error("candidate experiment baseline does not match the analyzed agent profile");
+    }
+    const measured = await runAgentCandidateExperiment({
+      experiment,
+      runId: options.runId,
+      placeCell: options.placeCell,
+      ...options.maxConcurrency === void 0 ? {} : { maxConcurrency: options.maxConcurrency },
+      ...options.signal ? { signal: options.signal } : {},
+      ...options.candidate ? { candidate: options.candidate } : {},
+      ...options.metadata ? { metadata: options.metadata } : {},
+      generationsExplored: improvement.raw.generationsExplored,
+      searchDurationMs: improvement.raw.durationMs,
+      searchCostUsd: improvement.raw.totalCostUsd
+    });
+    const proposal = createAgentImprovementProposal({
+      runId: options.runId,
+      findings,
+      evaluation: measured.evaluation,
+      ...options.now ? { now: options.now } : {}
+    });
+    return {
+      analysis,
+      improvement,
+      experiment,
+      measurements: measured.measurements,
+      proposal
+    };
+  } catch (cause) {
+    return rethrowAfterCleanup(cause, () => improvement.dispose(), "proposeAgentImprovement failed");
+  }
+}
+function createAgentImprovementProposal(options) {
+  const findings = assertNoJudgeVerdict(
+    [...options.findings],
+    "createAgentImprovementProposal findings"
+  );
+  const evaluation = verifyCandidateExperimentComparison(options.evaluation);
+  if (evaluation.decision.outcome !== "ship") {
+    throw new Error("agent improvement proposal requires a passing experiment");
+  }
+  if (options.runId !== evaluation.provenance.runId) {
+    throw new Error("proposal runId does not match its measured experiment");
+  }
+  const changedSurfaces = deriveChangedSurfaces(
+    evaluation.experiment.baseline,
+    evaluation.experiment.candidate
+  );
+  return agentImprovementProposalSchema.parse(
+    canonicalCandidateDocument({
+      kind: "agent-improvement-proposal",
+      runId: options.runId,
+      changedSurfaces,
+      proposedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+      findings: [...findings],
+      evaluation
+    }).value
+  );
+}
+function reviewAgentImprovementProposal(inputProposal, input) {
+  const proposal = verifyAgentImprovementProposal(inputProposal);
+  if (!input.reviewedBy.trim()) throw new Error("candidate review requires reviewedBy");
+  if (!input.reason.trim()) throw new Error("candidate review requires a reason");
+  if (input.decision === "approve" && proposal.evaluation.decision.outcome !== "ship") {
+    throw new Error("candidate cannot be approved without a passing experiment");
+  }
+  return agentImprovementReviewSchema.parse(
+    canonicalCandidateDocument({
+      kind: "agent-improvement-review",
+      proposalDigest: proposal.digest,
+      decision: input.decision,
+      reviewedBy: input.reviewedBy,
+      reviewedAt: (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+      reason: input.reason,
+      ...input.feedback === void 0 ? {} : { feedback: input.feedback }
+    }).value
+  );
+}
+function createAgentImprovementActivation(inputProposal, inputReview, options) {
+  const proposal = verifyAgentImprovementProposal(inputProposal);
+  const review = verifyAgentImprovementReview(inputReview);
+  if (review.decision !== "approve" || review.proposalDigest !== proposal.digest) {
+    throw new Error("candidate activation requires an approval for the exact proposal");
+  }
+  if (!options.fundingOwner.trim() || !options.authorizedBy.trim()) {
+    throw new Error("candidate activation authority must be non-empty");
+  }
+  const experiment = proposal.evaluation.experiment;
+  assertActivationTargets(proposal.changedSurfaces, experiment, options.targets);
+  return agentImprovementActivationSchema.parse(
+    canonicalCandidateDocument({
+      kind: "agent-improvement-activation",
+      proposalDigest: proposal.digest,
+      reviewDigest: review.digest,
+      experimentDigest: experiment.digest,
+      candidateBundleDigest: experiment.candidate.digest,
+      targets: options.targets,
+      fundingOwner: options.fundingOwner,
+      authorizedBy: options.authorizedBy,
+      authorizedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+    }).value
+  );
+}
+function verifyAgentImprovementProposal(input) {
+  const proposal = verifyCanonicalCandidateDocument(
+    agentImprovementProposalSchema.parse(input),
+    "agent improvement proposal"
+  );
+  const evaluation = verifyCandidateExperimentComparison(proposal.evaluation);
+  if (evaluation.decision.outcome !== "ship") {
+    throw new Error("agent improvement proposal does not contain a passing experiment");
+  }
+  if (proposal.runId !== evaluation.provenance.runId) {
+    throw new Error("proposal runId does not match its measured experiment");
+  }
+  const changedSurfaces = deriveChangedSurfaces(
+    evaluation.experiment.baseline,
+    evaluation.experiment.candidate
+  );
+  if (!sameOrderedValues(proposal.changedSurfaces, changedSurfaces)) {
+    throw new Error("proposal changed surfaces do not match its exact experiment");
+  }
+  assertNoJudgeDerivedProposalFindings(proposal.findings);
+  return proposal;
+}
+function verifyAgentImprovementReview(input) {
+  return verifyCanonicalCandidateDocument(
+    agentImprovementReviewSchema.parse(input),
+    "agent improvement review"
+  );
+}
+function verifyAgentImprovementActivation(input) {
+  const proposal = verifyAgentImprovementProposal(input.proposal);
+  const review = verifyAgentImprovementReview(input.review);
+  const activation = verifyCanonicalCandidateDocument(
+    agentImprovementActivationSchema.parse(input.activation),
+    "agent improvement activation"
+  );
+  const experiment = proposal.evaluation.experiment;
+  if (review.decision !== "approve" || review.proposalDigest !== proposal.digest || activation.proposalDigest !== proposal.digest || activation.reviewDigest !== review.digest || activation.experimentDigest !== experiment.digest || activation.candidateBundleDigest !== experiment.candidate.digest) {
+    throw new Error("candidate activation does not bind the measured and approved candidate");
+  }
+  assertActivationTargets(proposal.changedSurfaces, experiment, activation.targets);
+  return activation;
+}
+function verifyCandidateExecutionEvidence(input, options) {
+  const experiment = verifyCandidateExperiment(options.experiment);
+  const bundle = experiment[options.arm];
+  const task = experiment.benchmark.tasks[options.benchmarkCell.taskIndex];
+  const index = options.benchmarkCell.taskIndex * experiment.benchmark.suite.reps + options.benchmarkCell.repetition;
+  if (!task || options.benchmarkCell.suiteDigest !== experiment.benchmark.suite.digest || options.seed !== experiment.benchmark.suite.seeds[index]) {
+    throw new Error("candidate execution evidence points outside its signed experiment");
+  }
+  const evidence = verifyCanonicalCandidateDocument(
+    candidateExecutionEvidenceSchema.parse(input),
+    "candidate execution evidence"
+  );
+  const materialization = verifyCanonicalCandidateDocument(
+    agentCandidateMaterializationReceiptSchema.parse(evidence.materializationReceipt),
+    "candidate materialization receipt"
+  );
+  const receipt = verifyCanonicalCandidateDocument(
+    agentCandidateRunReceiptSchema.parse(evidence.receipt),
+    "candidate run receipt"
+  );
+  const plan = materialization.executionPlan;
+  const cell = plan.material.runCell;
+  const attempt = options.attempt ?? 1;
+  if (cell.experimentDigest !== experiment.digest || cell.arm !== options.arm || cell.bundleDigest !== bundle.digest || cell.suiteDigest !== experiment.benchmark.suite.digest || cell.taskDigest !== task.digest || cell.taskIndex !== options.benchmarkCell.taskIndex || cell.repetition !== options.benchmarkCell.repetition || cell.seed !== options.seed || cell.attempt !== attempt || canonicalCandidateDigest(omitTopLevelDigest(cell)) !== cell.digest) {
+    throw new Error("candidate execution receipt substituted its signed experiment cell");
+  }
+  assertCapturedInput(
+    materialization.benchmark.suite,
+    experiment.benchmark.suite,
+    "benchmark suite"
+  );
+  assertCapturedInput(materialization.benchmark.task, task, "benchmark task");
+  assertEvidenceMaterialDigest(plan, "candidate execution plan");
+  assertEvidenceMaterialDigest(
+    materialization.profileActivation.profilePlan,
+    "candidate profile plan"
+  );
+  const expectedProfilePlan = materializeCandidateProfile(
+    bundle.profile,
+    candidateMaterializerHarness(materialization.harness),
+    { resolvedResources: options.resolvedResources }
+  );
+  const activation = parseAgentCandidateProfileActivation(
+    materialization.profileActivation,
+    materialization.profileActivation.profilePlan.digest
+  );
+  const regeneratedActivation = createAgentCandidateProfileActivation(
+    expectedProfilePlan,
+    materialization.profileActivation.profilePlan
+  );
+  if (activation.digest !== regeneratedActivation.digest) {
+    throw new Error("candidate profile activation does not match the experiment bundle");
+  }
+  if (materialization.bundleDigest !== bundle.digest || receipt.bundleDigest !== bundle.digest || receipt.runCellDigest !== cell.digest || receipt.materializationReceiptDigest !== materialization.digest || receipt.executionPlanDigest !== plan.digest) {
+    throw new Error("candidate execution evidence does not bind one exact Runtime run");
+  }
+  assertEvidenceMaterialDigest(receipt.modelSettlement, "candidate model settlement");
+  assertEvidenceMaterialDigest(receipt.taskOutcome, "candidate task outcome");
+  assertEvidenceMaterialDigest(receipt.benchmarkResult, "candidate benchmark result");
+  return immutableCandidateValue(evidence);
+}
+function assertExactExperimentInput(input, experiment, bundle) {
+  const task = experiment.benchmark.tasks[input.benchmarkCell.taskIndex];
+  const index = input.benchmarkCell.taskIndex * experiment.benchmark.suite.reps + input.benchmarkCell.repetition;
+  if (input.experiment.digest !== experiment.digest || input.bundle.digest !== bundle.digest || !task || input.task.digest !== task.digest || input.benchmarkCell.suiteDigest !== experiment.benchmark.suite.digest || input.seed !== experiment.benchmark.suite.seeds[index]) {
+    throw new Error("Runtime received a substituted candidate experiment cell");
+  }
+}
+function assertCapturedInput(captured, expected, label) {
+  const bytes = canonicalCandidateBytes(omitTopLevelDigest(expected));
+  if (captured.digest !== expected.digest || captured.material.sha256 !== expected.digest || captured.material.byteLength !== bytes.byteLength) {
+    throw new Error(`candidate materialization substituted its ${label}`);
+  }
+}
+function assertEvidenceMaterialDigest(evidence, label) {
+  const bytes = canonicalCandidateBytes(evidence.material);
+  if (canonicalCandidateDigest(evidence.material) !== evidence.digest || evidence.artifact.sha256 !== evidence.digest || evidence.artifact.byteLength !== bytes.byteLength) {
+    throw new Error(`${label} digest does not match its canonical material`);
+  }
+}
+var CHANGED_SURFACE_ORDER = [
+  "prompt",
+  "skills",
+  "tools",
+  "mcp",
+  "hooks",
+  "subagents",
+  "agent-profile",
+  "memory",
+  "code",
+  "knowledge"
+];
+function deriveChangedSurfaces(baselineBundle, candidateBundle) {
+  const baseline = improvementSurfaceValues(baselineBundle);
+  const candidate = improvementSurfaceValues(candidateBundle);
+  const changed = /* @__PURE__ */ new Set();
+  for (const surface of CHANGED_SURFACE_ORDER) {
+    if (canonicalCandidateDigest(baseline[surface]) !== canonicalCandidateDigest(candidate[surface])) {
+      changed.add(surface);
+    }
+  }
+  const ordered = CHANGED_SURFACE_ORDER.filter((surface) => changed.has(surface));
+  if (ordered.length === 0) throw new Error("candidate experiment does not change an agent surface");
+  return ordered;
+}
+function improvementSurfaceValues(bundle) {
+  const profile = agentCandidateProfileAsAgentProfile(bundle.profile);
+  return {
+    prompt: {
+      prompt: profile.prompt ?? null,
+      instructions: profile.resources?.instructions ?? null
+    },
+    skills: profile.resources?.skills ?? null,
+    tools: {
+      tools: profile.tools ?? null,
+      resources: profile.resources?.tools ?? null
+    },
+    mcp: profile.mcp ?? null,
+    hooks: profile.hooks ?? null,
+    subagents: {
+      subagents: profile.subagents ?? null,
+      resources: profile.resources?.agents ?? null
+    },
+    "agent-profile": { profile: opaqueProfileSlice(profile), execution: bundle.execution },
+    memory: bundle.memory,
+    code: bundle.code,
+    knowledge: bundle.knowledge ?? null
+  };
+}
+function opaqueProfileSlice(profile) {
+  const {
+    prompt: _prompt,
+    tools: _tools,
+    mcp: _mcp,
+    hooks: _hooks,
+    subagents: _subagents,
+    resources,
+    ...opaqueProfile
+  } = profile;
+  const {
+    instructions: _instructions,
+    skills: _skills,
+    tools: _resourceTools,
+    agents: _agents,
+    ...opaqueResources
+  } = resources ?? {};
+  return {
+    ...opaqueProfile,
+    ...Object.keys(opaqueResources).length > 0 ? { resources: opaqueResources } : {}
+  };
+}
+function assertActivationTargets(surfaces, experiment, targets) {
+  const expected = new Set(surfaces);
+  const actual = new Set(targets.map((target) => target.surface));
+  const baselineValues = improvementSurfaceValues(experiment.baseline);
+  if (targets.some((target) => !target.identity.trim()) || targets.some(
+    (target) => target.expectedBaseDigest !== expectedActivationBaseDigest(experiment, target.surface, baselineValues)
+  ) || expected.size !== actual.size || [...expected].some((surface) => !actual.has(surface))) {
+    throw new Error("candidate activation targets must cover exactly the changed surfaces");
+  }
+}
+function expectedActivationBaseDigest(experiment, surface, baselineValues) {
+  if (surface === "knowledge" && experiment.candidate.knowledge) {
+    return experiment.candidate.knowledge.candidate.baseHash;
+  }
+  return canonicalCandidateDigest(baselineValues[surface]);
+}
+function sameOrderedValues(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function assertNoJudgeDerivedProposalFindings(findings) {
+  const leaked = findings.filter((finding) => finding.derived_from_judge === true);
+  if (leaked.length === 0) return;
+  const identifiers = leaked.map(
+    (finding) => typeof finding.finding_id === "string" ? finding.finding_id : "<unknown>"
+  );
+  throw new Error(
+    `agent improvement proposal findings: judge-derived findings cannot steer an improvement: [${identifiers.join(", ")}]`
+  );
+}
+
 export {
   improvementDriver,
   rawTraceDistiller,
   applyImprovementWinnerToProfile,
-  improve
+  improve,
+  AgentCandidateExperimentCellExecutionError,
+  runAgentCandidateExperiment,
+  executeAgentCandidateExperimentCell,
+  createAgentImprovementMeasuredComparison,
+  proposeAgentImprovement,
+  createAgentImprovementProposal,
+  reviewAgentImprovementProposal,
+  createAgentImprovementActivation,
+  verifyAgentImprovementProposal,
+  verifyAgentImprovementReview,
+  verifyAgentImprovementActivation,
+  verifyCandidateExecutionEvidence
 };
-//# sourceMappingURL=chunk-PCURO3DL.js.map
+//# sourceMappingURL=chunk-G55QE4IQ.js.map