@tangle-network/agent-runtime 0.102.0 → 0.102.2

package/dist/index.js

@@ -1,14 +1,26 @@
+import {
+  DELEGATED_LOOP_MODES,
+  auditLoopRunner,
+  isDelegatedLoopMode,
+  parseLoopRunnerArgv,
+  researchLoopRunner,
+  runDelegatedLoop,
+  runLoopRunnerCli,
+  selfImproveLoopRunner,
+  worktreeLoopRunner
+} from "./chunk-SCOHHMKU.js";
 import {
   FileAgentCandidateExecutionClaimStore,
   buildAgentCandidateBundle,
   createProtectedAgentCandidateModelPort,
   disposePreparedAgentCandidateExecution,
   recoverExpiredAgentCandidateExecution
-} from "./chunk-DA7YL6I4.js";
+} from "./chunk-CK76OZPM.js";
 import {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "./chunk-KSBUSEUA.js";
+} from "./chunk-EKUMRQNR.js";
+import "./chunk-SGKPNBXE.js";
 import {
   DEFAULT_ROUTER_BASE_URL,
   cleanModelId,
@@ -17,18 +29,6 @@ import {
   resolveRouterBaseUrl,
   validateChatModelId
 } from "./chunk-NURIQBJQ.js";
-import {
-  DELEGATED_LOOP_MODES,
-  auditLoopRunner,
-  isDelegatedLoopMode,
-  parseLoopRunnerArgv,
-  researchLoopRunner,
-  runDelegatedLoop,
-  runLoopRunnerCli,
-  selfImproveLoopRunner,
-  worktreeLoopRunner
-} from "./chunk-N2CEE5Q3.js";
-import "./chunk-SGKPNBXE.js";
 import {
   CircuitBreakerState,
   CircuitOpenError,
@@ -57,8 +57,11 @@ import {
 } from "./chunk-2KGAN2HM.js";
 import {
   exactProcessProviderAsCandidateExecutor
-} from "./chunk-SPCD4IQQ.js";
-import "./chunk-MAONWP4R.js";
+} from "./chunk-377GOJHJ.js";
+import {
+  McpSpawnFault,
+  connectStdioMcp
+} from "./chunk-QCXD7NHM.js";
 import {
   InMemoryRuntimeSessionStore,
   createIterableBackend,
@@ -79,23 +82,40 @@ import {
   knowledgeReadinessDeliverable,
   runKnowledgeImprovementJob,
   runSupervisedKnowledgeUpdate
-} from "./chunk-23Z7N5IG.js";
+} from "./chunk-J6V6DWWS.js";
 import "./chunk-5QOB7H74.js";
 import {
   captureAgentCandidateWorkspace,
   captureAgentCandidateWorkspaceFiles,
   createAgentCandidateWorkspacePort,
   sealAgentCandidateBundle
-} from "./chunk-AIBIRAJ6.js";
-import "./chunk-LKKIM5QD.js";
+} from "./chunk-KSM6GFHP.js";
+import "./chunk-3DW5DEKQ.js";
 import {
   AGENTIC_PROFILE_RESOURCE_ROOT,
+  LIFTED_FINDING_ANALYST_ID,
+  ROLLOUT_POLICY_BOUNDS,
+  ROLLOUT_POLICY_EXTENSION,
   agenticGenerator,
+  applyRolloutPolicyToProfile,
   commandVerifier,
+  defaultBuildPrompt,
+  enumerateNeighborPolicies,
   improve,
   improvementDriver,
-  rawTraceDistiller
-} from "./chunk-4AMAFNUD.js";
+  isAnalystFinding,
+  normalizeRolloutPolicy,
+  parseRolloutPolicy,
+  rawTraceDistiller,
+  rawTraceEvidenceProblem,
+  requiresRawTraceEvidence,
+  rolloutPolicyProposer,
+  serializeRolloutPolicy,
+  structuralRolloutPolicyFromProfile,
+  summarizeFindings,
+  toAnalystFindings,
+  worktreeChangedPaths
+} from "./chunk-7FJJUC73.js";
 import {
   AGENT_CANDIDATE_EXECUTION_SUPPORT,
   CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV,
@@ -113,14 +133,16 @@ import {
   persistCandidateOutputArtifact,
   prepareAgentCandidateExecution,
   verifyAgentCandidateBundle
-} from "./chunk-TGDHHHH4.js";
-import {
-  composeRuntimeHooks,
-  defineRuntimeHooks,
-  notifyRuntimeDecisionPoint,
-  notifyRuntimeHookEvent
-} from "./chunk-KVJQV342.js";
+} from "./chunk-LJLG734E.js";
+import "./chunk-ZUCUAFVF.js";
 import "./chunk-DPEUKJRO.js";
+import {
+  buildDriverSystem,
+  optimizerMethod,
+  researchDriverNote,
+  strategyAuthorMethod
+} from "./chunk-ROILMKDL.js";
+import "./chunk-UPWGXKXB.js";
 import {
   INTELLIGENCE_WIRE_VERSION,
   buildLoopOtelSpans,
@@ -135,7 +157,14 @@ import {
   sanitizeKnowledgeReadinessReport,
   sanitizeRuntimeStreamEvent
 } from "./chunk-2VZYRB55.js";
-import "./chunk-IKGCKPDX.js";
+import {
+  composeRuntimeHooks,
+  defineRuntimeHooks,
+  notifyRuntimeDecisionPoint,
+  notifyRuntimeHookEvent,
+  runBrainLoop,
+  runLocalHarness
+} from "./chunk-SQ3ZJH3Y.js";
 import "./chunk-IMSNJSXH.js";
 import "./chunk-M6MD6JBS.js";
 import "./chunk-3MDZX7YU.js";
@@ -248,130 +277,483 @@ function findingLines(findings) {
 }
 function toolBuildPrompt(args) {
   return [
-    "You are building a new TOOL for this codebase to address the gaps below.",
-    "Write the tool as a small, self-contained module PLUS tests that exercise it.",
-    "The tool must compile and its tests must pass \u2014 they will be run automatically;",
-    "if verification fails you will get the error and another attempt. Do not commit;",
-    "leave the changes in the working tree.",
+    "You are building a new TOOL for this codebase \u2014 a capability the agent measurably lacks,",
+    "evidenced by the failure findings at the bottom. The tool is an experiment: after it is",
+    "built and verified, its marginal lift is measured on held-out tasks, and only a real lift",
+    "promotes it.",
+    "",
+    optimizerMethod,
+    "",
+    "THE SURFACE \u2014 what a deliverable tool looks like here:",
+    "- ONE small, self-contained module PLUS tests that exercise its contract (what callers rely",
+    "  on), not its internals. The tests are the experiment for sub-goal correctness \u2014 write the",
+    "  test that would fail if your hypothesis about the gap were wrong.",
+    "- It must compile and its tests must pass \u2014 they run automatically; on failure you get the",
+    "  verifier output and another attempt, resuming on top of your own edits (fix in place, do",
+    "  not start over).",
+    "- Match the codebase grain: reuse its existing helpers, style, and test framework; a tool",
+    "  that fights the codebase is the wrong tool even if it passes.",
+    "- Do not commit; leave the changes in the working tree.",
     "",
-    "Gaps the tool should close:",
+    "FINDINGS \u2014 ranked evidence from real failed runs (the gaps the tool must close):",
     ...findingLines(args.findings)
   ].join("\n");
 }
 function mcpBuildPrompt(args) {
   return [
-    "You are building a new MCP SERVER (Model Context Protocol) that exposes",
-    "tool(s) addressing the gaps below, so any harness can mount it.",
-    "Requirements that WILL be checked by booting the server:",
+    "You are building a new MCP SERVER (Model Context Protocol) exposing tool(s) that close the",
+    "capability gaps evidenced by the failure findings at the bottom, so any harness can mount",
+    "them. The server is an experiment: after it is built and boot-verified, its marginal lift is",
+    "measured on held-out tasks, and only a real lift promotes it.",
+    "",
+    optimizerMethod,
+    "",
+    "RESEARCH FIRST \u2014 ADOPT BEFORE BUILD: you may discover and ADOPT an existing external MCP",
+    "server if it fits the gaps better than building one. Registries and vendor docs list",
+    "maintained servers for most common capabilities (web search, fetch, GitHub, filesystems,",
+    "databases). To adopt, deliver a short adoption note instead of an implementation: the",
+    "server's launch command or HTTP endpoint, and the API key it needs BY NAME (e.g.",
+    "EXA_API_KEY) \u2014 never a key value; provisioning injects the value at materialize time. If",
+    "your environment has no web access, decide from what you already know and say so.",
+    "",
+    "THE SURFACE \u2014 what a deliverable MCP server looks like here (checked by BOOTING it):",
     "- it starts over stdio and answers the MCP `initialize` handshake,",
-    "- `tools/list` returns at least one tool with a valid input schema.",
-    "Newline-delimited JSON-RPC 2.0, protocol version 2024-11-05. Include a start",
-    "command (e.g. a package.json `start` script or a clear entrypoint). If the",
-    "boot-and-probe fails you will get the error and another attempt. Do not",
-    "commit; leave the changes in the working tree.",
+    "- `tools/list` returns at least one tool with a valid input schema,",
+    "- newline-delimited JSON-RPC 2.0, protocol version 2024-11-05,",
+    "- a clear start command (a package.json `start` script or an obvious entrypoint).",
+    "Design the tool surface for the FINDINGS, not for generality: each exposed tool should map to",
+    "a named failure mechanism, with a description that tells the agent when to reach for it (a",
+    "tool the agent never calls measures zero). If the boot-and-probe fails you get the error and",
+    "another attempt, resuming on top of your own edits. Do not commit; leave the changes in the",
+    "working tree.",
     "",
-    "Capabilities the server should provide:",
+    "FINDINGS \u2014 ranked evidence from real failed runs (the capabilities the server must provide):",
     ...findingLines(args.findings)
   ].join("\n");
 }
 
-// src/improvement/mcp-serve-verifier.ts
-import { spawn } from "child_process";
-import { createInterface } from "readline";
-var PROTOCOL_VERSION = "2024-11-05";
-function mcpServeVerifier(spec) {
-  const timeoutMs = spec.timeoutMs ?? 3e4;
-  const minTools = spec.minTools ?? 1;
-  return (worktreePath) => new Promise((resolve, reject) => {
-    const child = spawn(spec.command, spec.args ?? [], {
-      cwd: worktreePath,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env, ...spec.env }
-    });
-    const stderr = [];
-    let settled = false;
-    let nextId = 1;
-    const initId = nextId++;
-    let listId = -1;
-    const settle = (fn) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      rl.close();
-      child.kill("SIGKILL");
-      fn();
-    };
-    const withStderr = (msg) => stderr.length > 0 ? `${msg}
-stderr:
-${stderr.join("").slice(-2e3)}` : msg;
-    const pass = () => settle(() => resolve({ ok: true }));
-    const failCandidate = (msg) => settle(() => resolve({ ok: false, feedback: withStderr(msg) }));
-    const setupFault = (err) => settle(() => reject(err));
-    const failStdin = (err) => failCandidate(`writing to MCP server stdin failed: ${err.message}`);
-    const send = (msg) => {
-      try {
-        child.stdin.write(`${JSON.stringify(msg)}
-`);
-        return true;
-      } catch (err) {
-        failStdin(err);
-        return false;
+// 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
       }
-    };
-    child.on("error", (err) => {
-      const code = err.code;
-      setupFault(
-        code === "ENOENT" ? new Error(
-          `mcpServeVerifier: '${spec.command}' not found in PATH (setup bug, not a failed candidate)`
-        ) : new Error(`mcpServeVerifier: '${spec.command}' failed to spawn: ${err.message}`)
-      );
-    });
-    child.on("exit", (code, signal) => {
-      failCandidate(`MCP server exited (code ${code}, signal ${signal}) before serving`);
+    })
+  ];
+  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 } : {}
     });
-    child.stdin.on("error", failStdin);
-    child.stderr.on("data", (d) => stderr.push(String(d)));
-    const rl = createInterface({ input: child.stdout });
-    rl.on("line", (line) => {
-      let msg;
-      try {
-        msg = JSON.parse(line);
-      } catch {
-        return;
-      }
-      if (!msg || typeof msg !== "object") return;
-      if (msg.id === initId) {
-        if (msg.error) return failCandidate(`initialize errored: ${JSON.stringify(msg.error)}`);
-        if (!send({ jsonrpc: "2.0", method: "notifications/initialized" })) return;
-        listId = nextId++;
-        send({ jsonrpc: "2.0", id: listId, method: "tools/list" });
-        return;
-      }
-      if (msg.id === listId) {
-        if (msg.error) return failCandidate(`tools/list errored: ${JSON.stringify(msg.error)}`);
-        const tools = msg.result?.tools;
-        if (!Array.isArray(tools)) return failCandidate("tools/list result has no tools array");
-        if (tools.length < minTools) {
-          return failCandidate(`tools/list returned ${tools.length} tool(s), need >= ${minTools}`);
+  }
+  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";
+var workerOutputTailChars = 2e3;
+var diffMaxChars = 6e3;
+var readFileDefaultBytes = 8192;
+var researchResultMaxChars = 8e3;
+function driverLoopGenerator(opts) {
+  const harness = opts.harness ?? "claude";
+  const buildPrompt = opts.buildPrompt ?? defaultBuildPrompt;
+  const run = opts.runHarness ?? runLocalHarness;
+  const changed = opts.changedPaths ?? worktreeChangedPaths;
+  const readDiff = opts.readDiff ?? worktreeDiff;
+  const verify = opts.verify;
+  return {
+    kind: `driver-loop:${harness}`,
+    async generate({ worktreePath, report, findings, maxShots, signal }) {
+      signal.throwIfAborted();
+      const briefing = buildPrompt({ report, findings });
+      const needsRawTraceEvidence = requiresRawTraceEvidence(findings);
+      const sessionCap = Math.max(1, maxShots);
+      let sessionsUsed = 0;
+      const groundVerify = async () => {
+        signal.throwIfAborted();
+        if (changed(worktreePath).length === 0) {
+          return { ok: false, feedback: "the working tree has no changes \u2014 nothing to verify" };
+        }
+        if (needsRawTraceEvidence) {
+          const problem = rawTraceEvidenceProblem(worktreePath, findings);
+          if (problem) return { ok: false, feedback: problem };
+        }
+        if (!verify) {
+          return { ok: true, feedback: "no verifier configured: a dirty tree is the candidate" };
         }
-        return pass();
+        const result = await verify(worktreePath, signal);
+        signal.throwIfAborted();
+        return result;
+      };
+      const execute = async (name, args) => {
+        signal.throwIfAborted();
+        switch (name) {
+          case "run_worker": {
+            const instruction = typeof args.instruction === "string" ? args.instruction.trim() : "";
+            if (instruction.length === 0) {
+              return "error: run_worker requires a non-empty `instruction`";
+            }
+            if (sessionsUsed >= sessionCap) {
+              return `error: worker-session budget exhausted (${sessionsUsed}/${sessionCap} used). Inspect and verify what exists, then stop with your final assessment.`;
+            }
+            sessionsUsed += 1;
+            const result = await run({
+              harness,
+              cwd: worktreePath,
+              taskPrompt: instruction,
+              ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+              signal
+            });
+            signal.throwIfAborted();
+            if (result.aborted) {
+              throw new Error("driverLoopGenerator: worker session was cancelled by the caller");
+            }
+            return JSON.stringify({
+              session: `${sessionsUsed}/${sessionCap}`,
+              exitCode: result.exitCode,
+              timedOut: result.timedOut,
+              aborted: result.aborted ?? false,
+              killedBySignal: result.killedBySignal,
+              durationMs: result.durationMs,
+              changedPaths: changed(worktreePath),
+              stdoutTail: tail(result.stdout, workerOutputTailChars),
+              stderrTail: tail(result.stderr, workerOutputTailChars)
+            });
+          }
+          case "inspect_worktree": {
+            const paths = changed(worktreePath);
+            const diff = truncate(readDiff(worktreePath), diffMaxChars);
+            return JSON.stringify({
+              changedPaths: paths,
+              diff: diff.length > 0 ? diff : "(no tracked-file diff \u2014 new files are untracked; read_file them)"
+            });
+          }
+          case "read_file":
+            return readWorktreeFile(worktreePath, args);
+          case "research": {
+            if (!opts.research) return "error: research tool is not provisioned in this run";
+            const query = typeof args.query === "string" ? args.query.trim() : "";
+            if (query.length === 0) return "error: research requires a non-empty `query`";
+            const result = await opts.research(query);
+            signal.throwIfAborted();
+            return truncate(result, researchResultMaxChars);
+          }
+          case "run_verifier": {
+            const result = await groundVerify();
+            return JSON.stringify({
+              ok: result.ok,
+              feedback: truncate(result.feedback ?? "", 4e3)
+            });
+          }
+          default:
+            return `error: unknown tool: ${name}`;
+        }
+      };
+      await runBrainLoop({
+        chat: opts.brain,
+        tools: opts.research ? [...driverToolSpecs, researchToolSpec] : driverToolSpecs,
+        execute,
+        initialMessages: [
+          {
+            role: "system",
+            content: opts.research ? `${buildDriverSystem}
+
+${researchDriverNote}` : buildDriverSystem
+          },
+          {
+            role: "user",
+            content: [
+              `THE BUILD BRIEF (the contract your workers must satisfy \u2014 fold what each needs into its instruction; workers never see this brief):`,
+              "",
+              briefing,
+              "",
+              `Worker-session budget: ${sessionCap}. The worktree is a fresh checkout at ${worktreePath}.`
+            ].join("\n")
+          }
+        ],
+        maxTurns: opts.maxTurns ?? Math.max(8, 2 + sessionCap * 3),
+        hooks: { stopBefore: () => signal.aborted }
+      });
+      signal.throwIfAborted();
+      const verdict = await groundVerify();
+      signal.throwIfAborted();
+      if (!verdict.ok) return { applied: false, summary: "" };
+      return { applied: true, summary: summarizeFindings(findings) };
+    }
+  };
+}
+var driverToolSpecs = [
+  {
+    type: "function",
+    function: {
+      name: "run_worker",
+      description: "Run ONE coding-harness session in the worktree with your instruction as its entire goal. The worktree persists between sessions. Sessions are capped \u2014 author each instruction richly (outcome, context, placement, the check it is held to).",
+      parameters: {
+        type: "object",
+        properties: {
+          instruction: {
+            type: "string",
+            description: "The complete, self-contained goal for this worker session."
+          }
+        },
+        required: ["instruction"]
       }
-    });
-    const timer = setTimeout(
-      () => failCandidate(`MCP server did not complete the handshake within ${timeoutMs}ms`),
-      timeoutMs
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "inspect_worktree",
+      description: "Current git state of the worktree: changed paths + the tracked-file diff (truncated). New untracked files show in changedPaths only \u2014 read_file them.",
+      parameters: { type: "object", properties: {} }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read one file from the worktree (paths are worktree-relative).",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Worktree-relative file path." },
+          maxBytes: { type: "number", description: "Byte cap (default 8192)." }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "run_verifier",
+      description: "Run the intrinsic check of the surface (compile+tests / boot-and-probe). Its result \u2014 not your judgment \u2014 decides whether the candidate is kept.",
+      parameters: { type: "object", properties: {} }
+    }
+  }
+];
+var researchToolSpec = {
+  type: "function",
+  function: {
+    name: "research",
+    description: "Search external sources (MCP registries, vendor docs) for an EXISTING server that closes the capability gap \u2014 the adopt-not-build check. Returns text findings.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "What capability / server to search for." }
+      },
+      required: ["query"]
+    }
+  }
+};
+function worktreeDiff(worktreePath) {
+  const result = spawnSync("git", ["diff"], { cwd: worktreePath, encoding: "utf-8" });
+  if (result.error) {
+    throw new Error(
+      `driverLoopGenerator: git diff failed to spawn in ${worktreePath}: ${result.error.message}`
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `driverLoopGenerator: git diff exited ${result.status} in ${worktreePath}: ${result.stderr.trim()}`
     );
-    send({
-      jsonrpc: "2.0",
-      id: initId,
-      method: "initialize",
-      params: {
-        protocolVersion: PROTOCOL_VERSION,
-        capabilities: {},
-        clientInfo: { name: "agent-runtime-mcp-verify", version: "0" }
+  }
+  return result.stdout;
+}
+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);
+  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);
+    return size > maxBytes ? `${body}
+\u2026 (${size - maxBytes} bytes truncated)` : body;
+  } catch (e) {
+    return `error: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+function tail(s, n) {
+  const trimmed = s.trim();
+  return trimmed.length <= n ? trimmed : `\u2026${trimmed.slice(-n)}`;
+}
+function truncate(s, n) {
+  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
+}
+
+// src/improvement/mcp-serve-verifier.ts
+function mcpServeVerifier(spec) {
+  const minTools = spec.minTools ?? 1;
+  return async (worktreePath) => {
+    let conn;
+    try {
+      conn = await connectStdioMcp({
+        command: spec.command,
+        ...spec.args ? { args: spec.args } : {},
+        cwd: worktreePath,
+        ...spec.env ? { env: spec.env } : {},
+        ...spec.timeoutMs !== void 0 ? { timeoutMs: spec.timeoutMs } : {}
+      });
+    } catch (err) {
+      if (err instanceof McpSpawnFault) {
+        throw new Error(`mcpServeVerifier: ${err.message}`);
       }
-    });
-  });
+      return { ok: false, feedback: err instanceof Error ? err.message : String(err) };
+    }
+    try {
+      if (conn.tools.length < minTools) {
+        return {
+          ok: false,
+          feedback: `tools/list returned ${conn.tools.length} tool(s), need >= ${minTools}`
+        };
+      }
+      return { ok: true };
+    } finally {
+      await conn.close();
+    }
+  };
 }
 
 // src/improvement/profile-diff-proposer.ts
@@ -439,7 +821,7 @@ function parseSerializedProfile(surface) {
 }
 
 // src/improvement/reflective-generator.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 function reflectiveGenerator(opts) {
   return {
     kind: "reflective",
@@ -457,7 +839,7 @@ function reflectiveGenerator(opts) {
   };
 }
 function applyPatch(patch, cwd) {
-  const result = spawnSync("git", ["apply", "--whitespace=fix", "-p0", "-"], {
+  const result = spawnSync2("git", ["apply", "--whitespace=fix", "-p0", "-"], {
     cwd,
     input: patch,
     encoding: "utf-8"
@@ -1540,22 +1922,29 @@ export {
   InMemoryConversationJournal,
   InMemoryRuntimeSessionStore,
   JudgeError,
+  LIFTED_FINDING_ANALYST_ID,
   NotFoundError,
   PlannerError,
   RESEARCH_SUPERVISOR_SYSTEM_PROMPT,
+  ROLLOUT_POLICY_BOUNDS,
+  ROLLOUT_POLICY_EXTENSION,
   RuntimeRunStateError,
   SqlConversationJournal,
   ValidationError,
   agenticGenerator,
   applyExactAgentProfileDiff,
+  applyRolloutPolicyToProfile,
   applyRunRecordDefaults,
   auditLoopRunner,
   buildAgentCandidateBundle,
+  buildDriverSystem,
   buildForwardHeaders,
   buildKnowledgeImprovementExperimentBundles,
   buildLoopOtelSpans,
   buildLoopSpanNodes,
   buildRuntimeEventOtelSpans,
+  campaignCellSpansToOtlp,
+  campaignTraceResolver,
   candidateExecutionClaim,
   candidateKnowledgeExecutionPaths,
   captureAgentCandidateWorkspace,
@@ -1564,6 +1953,7 @@ export {
   commandVerifier,
   composeRuntimeHooks,
   computeBackoff,
+  convertCampaignDirToOtlp,
   createAgentCandidateWorkspacePort,
   createAgentKnowledgeReadinessCheck,
   createConversationBackend,
@@ -1578,19 +1968,24 @@ export {
   createSupervisedKnowledgeUpdater,
   d1ToSqlAdapter,
   decideKnowledgeReadiness,
+  defaultBuildPrompt,
   defaultIsRetryable,
   defineConversation,
   defineRuntimeHooks,
   deriveExecutionId,
   disposePreparedAgentCandidateExecution,
+  driverLoopGenerator,
+  enumerateNeighborPolicies,
   exactProcessProviderAsCandidateExecutor,
   executePreparedAgentCandidate,
   exportEvalRuns,
+  findingLines,
   formatSupervisedKnowledgeTask,
   getModels,
   handleChatTurn,
   improve,
   improvementDriver,
+  isAnalystFinding,
   isDelegatedLoopMode,
   isDepthExceeded,
   knowledgeReadinessDeliverable,
@@ -1600,11 +1995,14 @@ export {
   mcpServeVerifier,
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset,
+  normalizeRolloutPolicy,
   notifyRuntimeDecisionPoint,
   notifyRuntimeHookEvent,
+  optimizerMethod,
   parseExactAgentProfile,
   parseExactAgentProfileDiff,
   parseLoopRunnerArgv,
+  parseRolloutPolicy,
   persistCandidateOutputArtifact,
   prepareAgentCandidateExecution,
   profileDiffProposer,
@@ -1613,10 +2011,12 @@ export {
   readinessServerSentEvent,
   recoverExpiredAgentCandidateExecution,
   reflectiveGenerator,
+  researchDriverNote,
   researchLoopRunner,
   resolveAgentBackend,
   resolveChatModel,
   resolveRouterBaseUrl,
+  rolloutPolicyProposer,
   runAgentTask,
   runAgentTaskStream,
   runConversation,
@@ -1634,10 +2034,14 @@ export {
   sanitizeRuntimeStreamEvent,
   sealAgentCandidateBundle,
   selfImproveLoopRunner,
+  serializeRolloutPolicy,
   sleep,
   slugifySpeaker,
   startRuntimeRun,
+  strategyAuthorMethod,
   streamToolLoop,
+  structuralRolloutPolicyFromProfile,
+  toAnalystFindings,
   toolBuildPrompt,
   turnId,
   validateChatModelId,