@tangle-network/agent-runtime 0.103.1 → 0.105.0

package/dist/index.js

@@ -6,19 +6,18 @@ import {
   researchLoopRunner,
   runDelegatedLoop,
   runLoopRunnerCli,
-  selfImproveLoopRunner,
   worktreeLoopRunner
-} from "./chunk-AAN2MB2X.js";
+} from "./chunk-HNP72PNU.js";
 import {
   FileAgentCandidateExecutionClaimStore,
   buildAgentCandidateBundle,
   disposePreparedAgentCandidateExecution,
   recoverExpiredAgentCandidateExecution
-} from "./chunk-SNSMRT6H.js";
+} from "./chunk-CTRA64LY.js";
 import {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "./chunk-TUSOOIDV.js";
+} from "./chunk-C5RTIBNZ.js";
 import "./chunk-SGKPNBXE.js";
 import {
   DEFAULT_ROUTER_BASE_URL,
@@ -54,14 +53,19 @@ import {
   slugifySpeaker,
   turnId
 } from "./chunk-2KGAN2HM.js";
+import {
+  defaultRedactor,
+  defaultRedactorIdentityMaterial,
+  resolveRedactor
+} from "./chunk-OPVWXJ2H.js";
 import {
   createProtectedAgentCandidateModelPort,
   exactProcessProviderAsCandidateExecutor
-} from "./chunk-ZXICDSAK.js";
+} from "./chunk-H5QPIZNX.js";
 import {
   McpSpawnFault,
   connectStdioMcp
-} from "./chunk-3LJF5XSE.js";
+} from "./chunk-WRTOVNN4.js";
 import {
   InMemoryRuntimeSessionStore,
   createIterableBackend,
@@ -82,40 +86,37 @@ import {
   knowledgeReadinessDeliverable,
   runKnowledgeImprovementJob,
   runSupervisedKnowledgeUpdate
-} from "./chunk-ZOYN3JR5.js";
+} from "./chunk-WMTCUOQL.js";
 import "./chunk-5QOB7H74.js";
 import {
   captureAgentCandidateWorkspace,
   captureAgentCandidateWorkspaceFiles,
   createAgentCandidateWorkspacePort,
   sealAgentCandidateBundle
-} from "./chunk-B7K7V22Y.js";
-import "./chunk-5AITUUHO.js";
+} from "./chunk-RDOAVVHY.js";
+import "./chunk-VISA6CI3.js";
 import {
   AGENTIC_PROFILE_RESOURCE_ROOT,
   LIFTED_FINDING_ANALYST_ID,
-  ROLLOUT_POLICY_BOUNDS,
   ROLLOUT_POLICY_EXTENSION,
   agenticGenerator,
   applyRolloutPolicyToProfile,
   commandVerifier,
   defaultBuildPrompt,
-  enumerateNeighborPolicies,
   improve,
-  improvementDriver,
   isAnalystFinding,
   normalizeRolloutPolicy,
   parseRolloutPolicy,
   rawTraceDistiller,
   rawTraceEvidenceProblem,
   requiresRawTraceEvidence,
-  rolloutPolicyProposer,
   serializeRolloutPolicy,
   structuralRolloutPolicyFromProfile,
   summarizeFindings,
   toAnalystFindings,
+  withMethodRuntimeControls,
   worktreeChangedPaths
-} from "./chunk-LFM4JBRW.js";
+} from "./chunk-UHEZW5BU.js";
 import {
   AGENT_CANDIDATE_EXECUTION_SUPPORT,
   CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV,
@@ -134,15 +135,15 @@ import {
   persistCandidateOutputArtifact,
   prepareAgentCandidateExecution,
   verifyAgentCandidateBundle
-} from "./chunk-SBTWKPVR.js";
-import "./chunk-EAQ5YRRY.js";
+} from "./chunk-WSTRQZYQ.js";
+import "./chunk-XBG2W2VW.js";
 import "./chunk-DPEUKJRO.js";
 import {
   buildDriverSystem,
   optimizerMethod,
   researchDriverNote,
   strategyAuthorMethod
-} from "./chunk-QYCKIV6C.js";
+} from "./chunk-YJZA2BIK.js";
 import "./chunk-UPWGXKXB.js";
 import {
   INTELLIGENCE_WIRE_VERSION,
@@ -165,9 +166,9 @@ import {
   notifyRuntimeHookEvent,
   runBrainLoop,
   runLocalHarness
-} from "./chunk-6WZZXQV5.js";
+} from "./chunk-HLKC4UYB.js";
 import "./chunk-ISPWRSEC.js";
-import "./chunk-M6MD6JBS.js";
+import "./chunk-KRBFHMV6.js";
 import "./chunk-3MDZX7YU.js";
 import "./chunk-FD2MBMOH.js";
 import "./chunk-M22PL4GH.js";
@@ -333,161 +334,10 @@ function mcpBuildPrompt(args) {
   ].join("\n");
 }
 
-// src/improvement/campaign-otlp.ts
-import { readdirSync, readFileSync } from "fs";
-import { basename, dirname, join, resolve } from "path";
-import { OPENINFERENCE_SPAN_KIND } from "@tangle-network/agent-eval/traces";
-var MAX_WALK_DEPTH = 4;
-function campaignCellSpansToOtlp(content, cell, opts = {}) {
-  const records = parseCampaignSpans(content, cell.cellId);
-  if (records.length === 0) return [];
-  const serviceName = opts.serviceName ?? "campaign";
-  const key = cell.cellKey ?? cell.cellId;
-  const traceId = foldTo32Hex(key);
-  const rootSpanId = foldTo16Hex(`${key}::root`);
-  const startMs = Math.min(...records.map((r) => r.startMs));
-  const endMs = Math.max(...records.map((r) => r.startMs + (r.durationMs ?? 0)));
-  const anyError = records.some((r) => r.error !== void 0);
-  const resource = {
-    attributes: {
-      "service.name": serviceName,
-      "campaign.cell_id": cell.cellId,
-      ...cell.cellKey ? { "campaign.cell_dir": cell.cellKey } : {}
-    }
-  };
-  const lines = [
-    JSON.stringify({
-      trace_id: traceId,
-      span_id: rootSpanId,
-      parent_span_id: "",
-      name: `cell.${cell.cellId}`,
-      start_time: msToIso(startMs),
-      end_time: msToIso(endMs),
-      status: anyError ? { code: "STATUS_CODE_ERROR", message: "one or more spans errored" } : { code: "STATUS_CODE_OK", message: "" },
-      resource,
-      attributes: {
-        [OPENINFERENCE_SPAN_KIND]: "AGENT",
-        "agent.name": cell.cellId
-      }
-    })
-  ];
-  for (let i = 0; i < records.length; i++) {
-    const r = records[i];
-    lines.push(
-      JSON.stringify({
-        trace_id: traceId,
-        span_id: foldTo16Hex(`${key}::${i}`),
-        parent_span_id: rootSpanId,
-        name: r.name,
-        start_time: msToIso(r.startMs),
-        end_time: msToIso(r.startMs + (r.durationMs ?? 0)),
-        status: r.error === void 0 ? { code: "STATUS_CODE_OK", message: "" } : { code: "STATUS_CODE_ERROR", message: r.error },
-        resource,
-        attributes: r.attributes
-      })
-    );
-  }
-  return lines;
-}
-function convertCampaignDirToOtlp(dir, opts = {}) {
-  const root = resolve(dir);
-  const files = findSpansFiles(root, MAX_WALK_DEPTH);
-  const lines = [];
-  for (const file of files) {
-    let content;
-    try {
-      content = readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    const cellDir = dirname(file);
-    lines.push(
-      ...campaignCellSpansToOtlp(content, { cellId: basename(cellDir), cellKey: cellDir }, opts)
-    );
-  }
-  return lines.length > 0 ? `${lines.join("\n")}
-` : "";
-}
-function campaignTraceResolver(opts) {
-  return (ctx) => {
-    const priorDir = ctx.generation <= 0 ? join(opts.runDir, "baseline") : join(opts.runDir, `gen-${ctx.generation - 1}`);
-    const prior = convertCampaignDirToOtlp(priorDir, opts);
-    if (prior) return prior;
-    return convertCampaignDirToOtlp(opts.runDir, opts);
-  };
-}
-function parseCampaignSpans(content, cellId) {
-  const out = [];
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    let raw;
-    try {
-      raw = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
-    const o = raw;
-    if (typeof o.name !== "string" || typeof o.startMs !== "number") continue;
-    const attributes = { "campaign.cell_id": cellId };
-    for (const [k, v] of Object.entries(o)) {
-      if (k === "name" || k === "cellId" || k === "startMs" || k === "durationMs") continue;
-      attributes[k] = v;
-    }
-    out.push({
-      name: o.name,
-      cellId,
-      startMs: o.startMs,
-      ...typeof o.durationMs === "number" ? { durationMs: o.durationMs } : {},
-      attributes,
-      ...typeof o.error === "string" ? { error: o.error } : {}
-    });
-  }
-  return out;
-}
-function findSpansFiles(dir, depth) {
-  const out = [];
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return out;
-  }
-  for (const entry of entries) {
-    const full = join(dir, entry.name);
-    if (entry.isFile() && entry.name === "spans.jsonl") {
-      out.push(full);
-    } else if (depth > 0 && entry.isDirectory() && !entry.isSymbolicLink()) {
-      out.push(...findSpansFiles(full, depth - 1));
-    }
-  }
-  return out.sort();
-}
-function msToIso(ms) {
-  return Number.isFinite(ms) && ms > 0 ? new Date(ms).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
-}
-function foldTo16Hex(s) {
-  const a = fnv1a(s);
-  const b = fnv1a(`${s}::salt`);
-  return a + b;
-}
-function foldTo32Hex(s) {
-  return foldTo16Hex(s) + foldTo16Hex(`${s}::trace`);
-}
-function fnv1a(s) {
-  let h = 2166136261;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619) >>> 0;
-  }
-  return h.toString(16).padStart(8, "0");
-}
-
 // src/improvement/driver-loop-generator.ts
 import { spawnSync } from "child_process";
-import { readFileSync as readFileSync2, statSync } from "fs";
-import { resolve as resolve2, sep } from "path";
+import { readFileSync, statSync } from "fs";
+import { resolve, sep } from "path";
 var workerOutputTailChars = 2e3;
 var diffMaxChars = 6e3;
 var readFileDefaultBytes = 8192;
@@ -701,15 +551,15 @@ function worktreeDiff(worktreePath) {
 function readWorktreeFile(worktreePath, args) {
   const rel = typeof args.path === "string" ? args.path : "";
   if (rel.length === 0) return "error: read_file requires `path`";
-  const root = resolve2(worktreePath);
-  const target = resolve2(root, rel);
+  const root = resolve(worktreePath);
+  const target = resolve(root, rel);
   if (target !== root && !target.startsWith(root + sep)) {
     return `error: path escapes the worktree: ${rel}`;
   }
   const maxBytes = typeof args.maxBytes === "number" && args.maxBytes > 0 ? Math.min(args.maxBytes, 65536) : readFileDefaultBytes;
   try {
     const size = statSync(target).size;
-    const body = readFileSync2(target, "utf-8").slice(0, maxBytes);
+    const body = readFileSync(target, "utf-8").slice(0, maxBytes);
     return size > maxBytes ? `${body}
 \u2026 (${size - maxBytes} bytes truncated)` : body;
   } catch (e) {
@@ -757,68 +607,362 @@ function mcpServeVerifier(spec) {
   };
 }
 
-// src/improvement/profile-diff-proposer.ts
+// src/improvement/official-optimizers.ts
+import { isDeepStrictEqual } from "util";
 import { canonicalJson } from "@tangle-network/agent-eval";
 import {
-  changedAgentProfileAxes
-} from "@tangle-network/agent-interface";
-function profileDiffProposer(options) {
-  return {
-    kind: "agent-profile-diff",
-    async propose(ctx) {
-      if (typeof ctx.currentSurface !== "string") {
-        throw new Error("profileDiffProposer requires a serialized AgentProfile surface");
-      }
-      const profile = parseSerializedProfile(ctx.currentSurface);
-      const proposals = await options.proposeDiffs({
-        ...ctx,
-        profile
-      });
-      const candidates = [];
-      const normalizedBaseline = applyExactAgentProfileDiff(
-        profile,
-        { kind: "agent-profile-diff" },
-        "profile diff baseline"
+  gepaOptimizationMethod,
+  skillOptOptimizationMethod
+} from "@tangle-network/agent-eval/campaign";
+var defaultMaxFindingsChars = 5e4;
+var pythonClientDocs = "https://github.com/tangle-network/agent-eval/tree/main/clients/python";
+var bridgeInstall = '`python -m pip install "agent-eval-rpc==0.126.6"`';
+var gepaWheelInstall = '`python -m pip install "gepa[full]==0.1.4"`';
+var gepaSourceInstall = '`python -m pip install "gepa[full] @ git+https://github.com/gepa-ai/gepa.git@f919db0a622e2e9f9204779b81fe00cc1b2d808f"`';
+var skillOptInstall = `${bridgeInstall}, then \`python -m pip install "skillopt @ git+https://github.com/microsoft/SkillOpt.git@61735e3922efc2b90c6d6cab561e62e98452ca90"\``;
+var OfficialOptimizerUnavailableError = class extends ConfigError {
+  optimizer;
+  constructor(optimizer, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    const install = optimizer === "gepa" ? [
+      `Install the Python bridge: ${bridgeInstall}.`,
+      `The direct GEPA engine uses the published wheel: ${gepaWheelInstall}.`,
+      `Composed recipes and source-only engines use the tested source revision: ${gepaSourceInstall}.`
+    ].join(" ") : `Install Microsoft SkillOpt: ${skillOptInstall}.`;
+    super(
+      [
+        `Official ${optimizer === "gepa" ? "GEPA" : "SkillOpt"} could not start.`,
+        "Runtime did not use a local fallback.",
+        install,
+        `Setup: ${pythonClientDocs}.`,
+        `Cause: ${detail}`
+      ].join(" "),
+      { cause }
+    );
+    this.optimizer = optimizer;
+  }
+};
+function officialGepa(options) {
+  const {
+    background,
+    includeFindings = true,
+    maxFindingsChars,
+    describeScenario,
+    describeArtifact,
+    redact,
+    authorizeSensitiveCandidate,
+    ...config
+  } = options;
+  const redactor = resolveRedactor(redact);
+  const redactionPolicyRef = optimizerRedactionPolicyRef(redact);
+  assertMaxFindingsChars("officialGepa", maxFindingsChars);
+  const objective = redactOptimizerText("officialGepa", "objective", config.objective, redactor);
+  return (context) => {
+    const externalEvaluationRef = optimizerEvidencePolicyRef({
+      runtimeEvaluationRef: context.evaluationRef,
+      redactionPolicyRef,
+      describeScenario,
+      describeArtifact,
+      authorizeSensitiveCandidate
+    });
+    const method = withDependencyHelp(
+      "gepa",
+      externalEvaluationRef,
+      redactor,
+      redactionPolicyRef,
+      gepaOptimizationMethod({
+        ...config,
+        objective,
+        evaluationId: externalEvaluationRef,
+        background: methodBackground({
+          context,
+          background,
+          includeFindings,
+          maxFindingsChars,
+          label: "officialGepa",
+          redactor
+        }),
+        ...describeScenario ? {
+          describeScenario: (scenario) => redactOptimizerEvidence(
+            "officialGepa",
+            "scenario descriptor",
+            describeScenario(scenario),
+            redactor
+          )
+        } : {},
+        ...describeArtifact ? {
+          describeArtifact: (artifact, scenario) => redactOptimizerEvidence(
+            "officialGepa",
+            "artifact descriptor",
+            describeArtifact(artifact, scenario),
+            redactor
+          )
+        } : {}
+      })
+    );
+    return withMethodRuntimeControls(method, {
+      costAttribution: "optimizer-run",
+      validateCandidate: (input) => assertSafeOptimizerCandidate("officialGepa", input, authorizeSensitiveCandidate)
+    });
+  };
+}
+function officialSkillOpt(options) {
+  const {
+    background,
+    includeFindings = true,
+    maxFindingsChars,
+    describeScenario,
+    describeArtifact,
+    redact,
+    authorizeSensitiveCandidate,
+    ...config
+  } = options;
+  const redactor = resolveRedactor(redact);
+  const redactionPolicyRef = optimizerRedactionPolicyRef(redact);
+  assertMaxFindingsChars("officialSkillOpt", maxFindingsChars);
+  const objective = redactOptimizerText("officialSkillOpt", "objective", config.objective, redactor);
+  return (context) => {
+    const externalEvaluationRef = optimizerEvidencePolicyRef({
+      runtimeEvaluationRef: context.evaluationRef,
+      redactionPolicyRef,
+      describeScenario,
+      describeArtifact,
+      authorizeSensitiveCandidate
+    });
+    const method = withDependencyHelp(
+      "skillopt",
+      externalEvaluationRef,
+      redactor,
+      redactionPolicyRef,
+      skillOptOptimizationMethod({
+        ...config,
+        objective,
+        evaluationId: externalEvaluationRef,
+        background: methodBackground({
+          context,
+          background,
+          includeFindings,
+          maxFindingsChars,
+          label: "officialSkillOpt",
+          redactor
+        }),
+        ...describeScenario ? {
+          describeScenario: (scenario) => redactOptimizerEvidence(
+            "officialSkillOpt",
+            "scenario descriptor",
+            describeScenario(scenario),
+            redactor
+          )
+        } : {},
+        ...describeArtifact ? {
+          describeArtifact: (artifact, scenario) => redactOptimizerEvidence(
+            "officialSkillOpt",
+            "artifact descriptor",
+            describeArtifact(artifact, scenario),
+            redactor
+          )
+        } : {}
+      })
+    );
+    return withMethodRuntimeControls(method, {
+      costAttribution: "optimizer-run",
+      validateCandidate: (input) => assertSafeOptimizerCandidate("officialSkillOpt", input, authorizeSensitiveCandidate)
+    });
+  };
+}
+function assertMaxFindingsChars(label, value) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) {
+    throw new ConfigError(`${label}: maxFindingsChars must be a positive safe integer`);
+  }
+}
+function methodBackground(options) {
+  const {
+    context,
+    background,
+    includeFindings,
+    maxFindingsChars = defaultMaxFindingsChars,
+    label,
+    redactor
+  } = options;
+  const safeBackground = background === void 0 ? void 0 : redactOptimizerText(label, "background", background, redactor);
+  const safeProfileName = context.profile.name === void 0 ? void 0 : redactOptimizerText(label, "profile name", context.profile.name, redactor);
+  const sections = [
+    safeBackground?.trim(),
+    safeProfileName ? `Agent profile: ${safeProfileName}. Surface: ${context.surface}.` : `Agent surface: ${context.surface}.`
+  ].filter((value) => Boolean(value));
+  if (includeFindings && context.findings.length > 0) {
+    let serialized;
+    try {
+      serialized = canonicalJson(
+        redactOptimizerEvidence(label, "findings", context.findings, redactor)
       );
-      const seen = /* @__PURE__ */ new Set([canonicalJson(normalizedBaseline)]);
-      for (const [index, proposal] of proposals.entries()) {
-        if (candidates.length >= ctx.populationSize || ctx.signal.aborted) break;
-        const diff = parseExactAgentProfileDiff(proposal, `profile diff proposal ${index}`);
-        const axes = changedAgentProfileAxes(diff);
-        if (axes.length === 0) continue;
-        const candidate = applyExactAgentProfileDiff(
-          profile,
-          diff,
-          `profile diff candidate ${index}`
-        );
-        const surface = canonicalJson(candidate);
-        if (seen.has(surface)) continue;
-        seen.add(surface);
-        candidates.push({
-          surface,
-          label: diff.title ?? diff.id ?? `Change ${axes.join(", ")}`,
-          rationale: candidateRationale(diff, axes)
-        });
+    } catch (cause) {
+      throw new ConfigError(`${label}: findings must be JSON-serializable`, { cause });
+    }
+    if (serialized.length > maxFindingsChars) {
+      throw new ConfigError(
+        `${label}: serialized findings exceed maxFindingsChars (${serialized.length} > ${maxFindingsChars})`
+      );
+    }
+    sections.push(`Observed failures:
+${serialized}`);
+  }
+  return sections.join("\n\n");
+}
+function assertSafeOptimizerCandidate(label, input, authorizeSensitiveCandidate) {
+  const redactedValue = defaultRedactor(input.value);
+  const redactedSurface = defaultRedactor(input.candidateSurface);
+  if (!isDeepStrictEqual(input.value, redactedValue) || !isDeepStrictEqual(input.candidateSurface, redactedSurface)) {
+    throw new ConfigError(
+      `${label}: the selected profile surface contains a common credential or private value. Store live credentials as provider references, or remove private data before starting an external optimizer.`
+    );
+  }
+  const sensitivePaths = sensitiveProfileSurfacePaths(input);
+  if (sensitivePaths.length === 0) return;
+  let authorized = false;
+  if (authorizeSensitiveCandidate) {
+    try {
+      authorized = authorizeSensitiveCandidate(
+        Object.freeze({
+          ...input,
+          sensitivePaths: Object.freeze([...sensitivePaths])
+        })
+      ) === true;
+    } catch (cause) {
+      throw new ConfigError(`${label}: sensitive candidate authorization failed`, { cause });
+    }
+  }
+  if (!authorized) {
+    throw new ConfigError(
+      `${label}: the selected profile surface contains fields that may carry private values: ${sensitivePaths.slice(0, 8).join(", ")}. Remove them, replace values with safe references, or authorize the exact profile with authorizeSensitiveCandidate.`
+    );
+  }
+}
+function sensitiveProfileSurfacePaths(input) {
+  const paths = /* @__PURE__ */ new Set();
+  if (input.surface === "tools" || input.surface === "mcp" || input.surface === "hooks" || input.surface === "subagents" || input.surface === "agent-profile") {
+    paths.add("$");
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const visit = (current, path) => {
+    if (current === null || typeof current !== "object") return;
+    if (seen.has(current)) return;
+    seen.add(current);
+    if (Array.isArray(current)) {
+      current.forEach((child, index) => {
+        visit(child, `${path}[${index}]`);
+      });
+      return;
+    }
+    for (const [key, child] of Object.entries(current)) {
+      const childPath = `${path}.${key}`;
+      if (["env", "headers", "url", "metadata", "extensions"].includes(key.toLowerCase())) {
+        paths.add(childPath);
+        continue;
       }
-      return candidates;
+      visit(child, childPath);
     }
   };
+  visit(input.value, "$");
+  return [...paths];
 }
-function candidateRationale(diff, axes) {
-  const reason = diff.rationale ?? `Changes profile axes: ${axes.join(", ")}.`;
-  const source = diff.source ? [diff.source.kind, ...diff.source.artifacts ?? []].join(" \xB7 ") : "source unspecified";
-  return `${reason} Source: ${source}. Diff: ${canonicalCandidateDigest(diff)}.`;
-}
-function parseSerializedProfile(surface) {
-  let raw;
+function redactOptimizerEvidence(label, field, value, redactor) {
   try {
-    raw = JSON.parse(surface);
+    return redactor(value);
   } catch (cause) {
-    throw new Error("profileDiffProposer current surface is not valid AgentProfile JSON", {
-      cause
-    });
+    throw new ConfigError(`${label}: ${field} redaction failed`, { cause });
   }
-  return parseExactAgentProfile(raw, "profileDiffProposer current profile");
+}
+function redactOptimizerText(label, field, value, redactor) {
+  const redacted = redactOptimizerEvidence(label, field, value, redactor);
+  if (typeof redacted !== "string" || !redacted.trim()) {
+    throw new ConfigError(`${label}: ${field} redaction must return a non-empty string`);
+  }
+  return redacted;
+}
+function redactJudgeScore(score, redactor) {
+  const notes = redactOptimizerEvidence("official optimizer", "judge notes", score.notes, redactor);
+  return {
+    ...score,
+    notes: typeof notes === "string" ? notes : "[redacted]"
+  };
+}
+function optimizerRedactionPolicyRef(redact, builtInIdentity = defaultRedactorIdentityMaterial()) {
+  if (redact === false) return "caller-approved-raw";
+  return canonicalCandidateDigest({
+    kind: redact === void 0 ? "default-redactor" : "caller-redactor-with-default",
+    builtIn: builtInIdentity,
+    ...redact === void 0 ? {} : {
+      callerSource: Function.prototype.toString.call(redact),
+      composition: Function.prototype.toString.call(resolveRedactor)
+    }
+  });
+}
+function optimizerEvidencePolicyRef(input) {
+  return canonicalCandidateDigest({
+    runtimeEvaluationRef: input.runtimeEvaluationRef,
+    redactionPolicyRef: input.redactionPolicyRef,
+    describeScenario: callbackSource(input.describeScenario),
+    describeArtifact: callbackSource(input.describeArtifact),
+    authorizeSensitiveCandidate: callbackSource(input.authorizeSensitiveCandidate)
+  });
+}
+function callbackSource(callback) {
+  return typeof callback === "function" ? Function.prototype.toString.call(callback) : null;
+}
+function withDependencyHelp(optimizer, evaluationRef, redactor, redactionPolicyRef, method) {
+  return {
+    ...method,
+    async optimize(input) {
+      try {
+        const judges = input.judges.map(
+          (judge) => Object.freeze({
+            ...judge,
+            judgeVersion: canonicalCandidateDigest({
+              evaluationRef,
+              name: judge.name,
+              dimensions: judge.dimensions,
+              judgeVersion: judge.judgeVersion ?? null,
+              outwardEvidence: redactionPolicyRef
+            }),
+            async score(scoreInput) {
+              return redactJudgeScore(await judge.score(scoreInput), redactor);
+            }
+          })
+        );
+        return await method.optimize({
+          ...input,
+          judges: Object.freeze(judges)
+        });
+      } catch (cause) {
+        if (isMissingDependency(optimizer, cause)) {
+          throw new OfficialOptimizerUnavailableError(optimizer, cause);
+        }
+        throw cause;
+      }
+    }
+  };
+}
+function isMissingDependency(optimizer, cause) {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  const common = [
+    `${optimizer === "gepa" ? "GEPA" : "SkillOpt"} bridge could not start`,
+    "source inspection could not start",
+    "No module named 'agent_eval_rpc'",
+    `No module named 'agent_eval_rpc.${optimizer === "gepa" ? "gepa_bridge" : "skillopt_bridge"}'`
+  ];
+  const specific = optimizer === "gepa" ? [
+    "requires GEPA",
+    "requires GEPA's Optimize Anything",
+    "No module named 'gepa'",
+    "gepa is importable but its package metadata is unavailable"
+  ] : [
+    "requires skillopt",
+    "requires SkillOpt",
+    "No module named 'skillopt'",
+    "skillopt is importable but its package metadata is unavailable"
+  ];
+  return [...common, ...specific].some((fragment) => message.includes(fragment));
 }
 
 // src/improvement/reflective-generator.ts
@@ -1925,9 +2069,9 @@ export {
   JudgeError,
   LIFTED_FINDING_ANALYST_ID,
   NotFoundError,
+  OfficialOptimizerUnavailableError,
   PlannerError,
   RESEARCH_SUPERVISOR_SYSTEM_PROMPT,
-  ROLLOUT_POLICY_BOUNDS,
   ROLLOUT_POLICY_EXTENSION,
   RuntimeRunStateError,
   SqlConversationJournal,
@@ -1945,8 +2089,6 @@ export {
   buildLoopOtelSpans,
   buildLoopSpanNodes,
   buildRuntimeEventOtelSpans,
-  campaignCellSpansToOtlp,
-  campaignTraceResolver,
   candidateExecutionClaim,
   candidateKnowledgeExecutionPaths,
   captureAgentCandidateWorkspace,
@@ -1955,7 +2097,6 @@ export {
   commandVerifier,
   composeRuntimeHooks,
   computeBackoff,
-  convertCampaignDirToOtlp,
   createAgentCandidateWorkspacePort,
   createAgentKnowledgeReadinessCheck,
   createConversationBackend,
@@ -1977,7 +2118,6 @@ export {
   deriveExecutionId,
   disposePreparedAgentCandidateExecution,
   driverLoopGenerator,
-  enumerateNeighborPolicies,
   exactProcessProviderAsCandidateExecutor,
   executePreparedAgentCandidate,
   exportEvalRuns,
@@ -1986,7 +2126,6 @@ export {
   getModels,
   handleChatTurn,
   improve,
-  improvementDriver,
   isAnalystFinding,
   isDelegatedLoopMode,
   isDepthExceeded,
@@ -2000,6 +2139,8 @@ export {
   normalizeRolloutPolicy,
   notifyRuntimeDecisionPoint,
   notifyRuntimeHookEvent,
+  officialGepa,
+  officialSkillOpt,
   optimizerMethod,
   parseExactAgentProfile,
   parseExactAgentProfileDiff,
@@ -2007,7 +2148,6 @@ export {
   parseRolloutPolicy,
   persistCandidateOutputArtifact,
   prepareAgentCandidateExecution,
-  profileDiffProposer,
   rawTraceDistiller,
   readDepth,
   readinessServerSentEvent,
@@ -2018,7 +2158,6 @@ export {
   resolveAgentBackend,
   resolveChatModel,
   resolveRouterBaseUrl,
-  rolloutPolicyProposer,
   runAgentTask,
   runAgentTaskStream,
   runConversation,
@@ -2035,7 +2174,6 @@ export {
   sanitizeKnowledgeReadinessReport,
   sanitizeRuntimeStreamEvent,
   sealAgentCandidateBundle,
-  selfImproveLoopRunner,
   serializeRolloutPolicy,
   sleep,
   slugifySpeaker,