@tangle-network/agent-runtime 0.94.6 → 0.94.8

package/dist/{chunk-JMT5VYY3.js → chunk-7NCP74SL.js}

@@ -1,6 +1,6 @@
 import {
   agenticGenerator
-} from "./chunk-4WWSICFY.js";
+} from "./chunk-GHXW56PO.js";
 import {
   assertModelAllowed
 } from "./chunk-ISTDY47H.js";
@@ -9,9 +9,13 @@ import {
 } from "./chunk-YEJR7IXO.js";
 
 // src/improvement/improvement-driver.ts
+import { spawnSync } from "child_process";
+import {
+  verifyCodeSurface
+} from "@tangle-network/agent-eval/campaign";
 function improvementDriver(opts) {
   const baseRef = opts.baseRef ?? "main";
-  const finalized = /* @__PURE__ */ new Map();
+  const owned = /* @__PURE__ */ new Map();
   return {
     kind: `improvement:${opts.generator.kind}`,
     async propose(ctx) {
@@ -20,32 +24,56 @@ function improvementDriver(opts) {
         return [];
       }
       const surfaces = [];
+      const incumbent = verifiedCodeIncumbent(ctx.currentSurface);
+      const proposalBaseRef = incumbent?.baseCommit ?? baseRef;
       for (let i = 0; i < ctx.populationSize; i++) {
         if (ctx.signal.aborted) break;
         const wt = await opts.worktree.create({
-          baseRef,
+          baseRef: proposalBaseRef,
           label: `${opts.generator.kind}-gen${ctx.generation}-cand${i}`
         });
+        owned.set(wt.path, wt);
         try {
+          if (incumbent) advanceToIncumbent(wt, incumbent);
           const { applied, summary } = await opts.generator.generate({
             worktreePath: wt.path,
             report: ctx.report,
             findings,
             dataset: ctx.dataset,
             maxShots: ctx.maxImprovementShots ?? 1,
-            signal: ctx.signal
+            signal: ctx.signal,
+            generation: ctx.generation,
+            candidateIndex: i,
+            ...ctx.costLedger ? { costLedger: ctx.costLedger } : {},
+            ...ctx.costPhase ? { costPhase: ctx.costPhase } : {}
           });
           if (!applied) {
             await opts.worktree.discard(wt);
+            owned.delete(wt.path);
             continue;
           }
           const surface = await opts.worktree.finalize(wt, summary);
           surfaces.push(surface);
-          finalized.set(surface.worktreeRef, wt);
+          owned.delete(wt.path);
+          owned.set(surface.worktreeRef, wt);
         } catch (err) {
-          await opts.worktree.discard(wt).catch(() => {
-          });
-          throw err;
+          const cleanupErrors = [];
+          for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+              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`
+          );
         }
       }
       return surfaces;
@@ -53,11 +81,11 @@ function improvementDriver(opts) {
     async cleanup(retainWorktreeRefs = []) {
       const retained = new Set(retainWorktreeRefs);
       const errors = [];
-      for (const [worktreeRef, worktree] of finalized) {
+      for (const [worktreeRef, worktree] of owned) {
         if (retained.has(worktreeRef)) continue;
         try {
           await opts.worktree.discard(worktree);
-          finalized.delete(worktreeRef);
+          owned.delete(worktreeRef);
         } catch (cause) {
           errors.push(cause);
         }
@@ -68,6 +96,38 @@ function improvementDriver(opts) {
     }
   };
 }
+function verifiedCodeIncumbent(surface) {
+  if (typeof surface !== "object" || surface.kind !== "code") return void 0;
+  verifyCodeSurface(surface);
+  return surface;
+}
+function advanceToIncumbent(worktree, incumbent) {
+  if (worktree.baseCommit !== incumbent.baseCommit || worktree.baseTree !== incumbent.baseTree) {
+    throw new Error("improvementDriver: candidate worktree does not match incumbent base identity");
+  }
+  if (worktree.baseCommit === incumbent.candidateCommit) return;
+  const merge = spawnSync("git", ["merge", "--ff-only", incumbent.candidateCommit], {
+    cwd: worktree.path,
+    encoding: "utf8"
+  });
+  if (merge.error) {
+    throw new Error(
+      `improvementDriver: failed to start candidate from incumbent: ${merge.error.message}`
+    );
+  }
+  if (merge.status !== 0) {
+    throw new Error(
+      `improvementDriver: could not fast-forward candidate to incumbent ${incumbent.candidateCommit}: ${merge.stderr.trim()}`
+    );
+  }
+  const head = spawnSync("git", ["rev-parse", "--verify", "HEAD"], {
+    cwd: worktree.path,
+    encoding: "utf8"
+  });
+  if (head.error || head.status !== 0 || head.stdout.trim() !== incumbent.candidateCommit) {
+    throw new Error("improvementDriver: candidate worktree did not reach the incumbent commit");
+  }
+}
 function resolveFindings(ctx) {
   const report = ctx.report;
   if (report && typeof report === "object" && "findings" in report) {
@@ -342,48 +402,88 @@ 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"
+  );
+}
 function isCodeSurface(surface) {
   return typeof surface === "object" && surface !== null && surface.kind === "code";
 }
-async function prepareCodeRun(code, proposerOverride) {
+async function prepareCodeRun(code) {
   const baseRef = code.baseRef ?? "main";
-  const worktree = gitWorktreeAdapter({
+  const worktree = code.worktree ?? gitWorktreeAdapter({
     repoRoot: code.repoRoot,
     ...code.worktreeDir ? { worktreeDir: code.worktreeDir } : {}
   });
   const baselineWorktree = await worktree.create({ baseRef, label: "incumbent-baseline" });
-  const baseline = await worktree.finalize(baselineWorktree, "Incumbent code checkout");
-  let managed;
-  if (!proposerOverride) {
+  try {
+    const baseline = await worktree.finalize(baselineWorktree, "Incumbent code checkout");
+    let baselineDiscarded = false;
     const generator = code.generator ?? agenticGenerator({
       ...code.harness ? { harness: code.harness } : {},
       ...code.verify ? { verify: code.verify } : {},
       ...code.timeoutMs ? { timeoutMs: code.timeoutMs } : {}
     });
-    managed = improvementDriver({ worktree, generator, baseRef });
-  }
-  const proposer = proposerOverride ?? managed;
-  if (!proposer) {
-    throw new ConfigError("improve(): code candidate generator could not be constructed");
-  }
-  return {
-    baseline,
-    proposer,
-    async cleanup(retainedWinner) {
-      const errors = [];
-      try {
-        await managed?.cleanup(isCodeSurface(retainedWinner) ? [retainedWinner.worktreeRef] : []);
-      } catch (cause) {
-        errors.push(cause);
-      }
-      try {
-        await worktree.discard(baselineWorktree);
-      } catch (cause) {
-        errors.push(cause);
-      }
-      if (errors.length > 0) {
-        throw new AggregateError(errors, "improve(): failed to clean code improvement worktrees");
+    const managed = improvementDriver({ worktree, generator, baseRef });
+    return {
+      baseline,
+      proposer: managed,
+      async cleanup(retainedWinner) {
+        const errors = [];
+        const retainedWorktreeRef = isCodeSurface(retainedWinner) ? retainedWinner.worktreeRef : void 0;
+        try {
+          await managed?.cleanup(retainedWorktreeRef ? [retainedWorktreeRef] : []);
+        } catch (cause) {
+          errors.push(cause);
+        }
+        if (!baselineDiscarded && retainedWorktreeRef !== baseline.worktreeRef) {
+          try {
+            await worktree.discard(baselineWorktree);
+            baselineDiscarded = true;
+          } catch (cause) {
+            errors.push(cause);
+          }
+        }
+        if (errors.length > 0) {
+          throw new AggregateError(errors, "improve(): failed to clean code improvement worktrees");
+        }
       }
+    };
+  } catch (cause) {
+    return discardPreparedBaseline(worktree, baselineWorktree, cause);
+  }
+}
+function idempotentDispose(dispose) {
+  let disposed = false;
+  let inFlight;
+  return async () => {
+    if (disposed) return;
+    if (inFlight) return inFlight;
+    inFlight = (async () => {
+      await dispose();
+      disposed = true;
+    })();
+    try {
+      await inFlight;
+    } finally {
+      inFlight = void 0;
     }
   };
 }
@@ -465,6 +565,11 @@ async function improve(profile, findings, opts) {
   if (surface === "memory" && !memory) {
     throw new ConfigError("improve(): surface 'memory' requires opts.memory.document");
   }
+  if (surface === "code" && generator) {
+    throw new ConfigError(
+      "improve(): surface 'code' forbids opts.generator because an external SurfaceProposer cannot transfer checkout ownership; pass opts.code.generator instead"
+    );
+  }
   const usesReflectionModel = !generator && (surface === "prompt" || surface === "skills");
   if (usesReflectionModel) {
     assertModelAllowed(sharedOptions.llm?.model ?? defaultReflectionModel, allowedModels);
@@ -476,7 +581,7 @@ async function improve(profile, findings, opts) {
         "improve(): surface 'code' requires opts.code.repoRoot so the incumbent can run from an isolated checkout"
       );
     }
-    preparedCode = await prepareCodeRun(code, generator);
+    preparedCode = await prepareCodeRun(code);
   }
   const proposer = preparedCode?.proposer ?? generator ?? defaultGeneratorFor(surface, sharedOptions.llm);
   if (!proposer) {
@@ -500,19 +605,33 @@ async function improve(profile, findings, opts) {
     });
   } catch (cause) {
     if (!preparedCode) throw cause;
+    return rethrowAfterCleanup(
+      cause,
+      () => preparedCode.cleanup(),
+      "improve(): code improvement failed and its worktrees could not be cleaned"
+    );
+  }
+  const shipped = raw.gateDecision === "ship";
+  const winnerSurface = raw.winner.surface;
+  if (preparedCode) {
     try {
-      await preparedCode.cleanup();
+      await preparedCode.cleanup(winnerSurface);
     } catch (cleanupCause) {
+      try {
+        await preparedCode.cleanup();
+      } catch (finalCleanupCause) {
+        throw new AggregateError(
+          [cleanupCause, finalCleanupCause],
+          "improve(): code result cleanup failed, including the final all-worktree retry"
+        );
+      }
       throw new AggregateError(
-        [cause, cleanupCause],
-        "improve(): code improvement failed and its worktrees could not be cleaned"
+        [cleanupCause],
+        "improve(): code result cleanup failed; the final all-worktree retry succeeded"
       );
     }
-    throw cause;
   }
-  const shipped = raw.gateDecision === "ship";
-  const winnerSurface = raw.winner.surface;
-  await preparedCode?.cleanup(shipped ? winnerSurface : void 0);
+  const dispose = idempotentDispose(async () => preparedCode?.cleanup());
   const externalDocument = surface === "skills" && skills ? skills : surface === "memory" && memory ? memory : void 0;
   if (shipped && externalDocument) {
     if (typeof winnerSurface !== "string") {
@@ -523,7 +642,14 @@ async function improve(profile, findings, opts) {
     await externalDocument.writeBack?.(winnerSurface);
   }
   const nextProfile = shipped && !externalDocument ? applyImprovementWinnerToProfile(profile, surface, winnerSurface) : profile;
-  return { profile: nextProfile, shipped, lift: raw.lift, gateDecision: raw.gateDecision, raw };
+  return {
+    profile: nextProfile,
+    shipped,
+    lift: raw.lift,
+    gateDecision: raw.gateDecision,
+    raw,
+    dispose
+  };
 }
 
 export {
@@ -532,4 +658,4 @@ export {
   applyImprovementWinnerToProfile,
   improve
 };
-//# sourceMappingURL=chunk-JMT5VYY3.js.map
+//# sourceMappingURL=chunk-7NCP74SL.js.map

package/dist/chunk-7NCP74SL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/improvement/improvement-driver.ts","../src/improvement/raw-trace-distiller.ts","../src/improvement/improve.ts"],"sourcesContent":["/**\n *\n * `improvementDriver` — the ONE reflective/agentic improvement proposer for\n * agent-eval's improvement loop. It implements `SurfaceProposer` and owns\n * the candidate lifecycle (worktree create → generate → finalize/discard,\n * × populationSize); it delegates the only thing that genuinely varies — HOW\n * a candidate change is produced — to a pluggable `CandidateGenerator`.\n *\n * There is no separate \"analyst driver\" vs \"autoresearch driver\": those are\n * the SAME driver at two settings of a dial.\n *   - cheap reflective path  → `reflectiveGenerator` (shots=1, no sandbox;\n *                              applies pre-drafted patches)\n *   - full agentic path      → `agenticGenerator` (shots=N, multi-shot\n *                              verify-in-session loop; an agent reads code +\n *                              report, edits, and re-tries on verifier failure)\n * Both emit changes into a worktree the driver finalizes into a\n * `CodeSurface{ worktreeRef }` the loop measures on the holdout. See\n * agent-eval's `docs/design/self-improvement-engine.md`.\n *\n * @experimental\n */\n\nimport { spawnSync } from 'node:child_process'\nimport type { AnalystFinding, CostLedger } from '@tangle-network/agent-eval'\nimport {\n  type CodeSurface,\n  type LabeledScenarioStore,\n  type ProposeContext,\n  type SurfaceProposer,\n  verifyCodeSurface,\n  type Worktree,\n  type WorktreeAdapter,\n} from '@tangle-network/agent-eval/campaign'\n\n/** The byte-producing seam — the ONE thing that differs between the cheap\n *  reflective path and the full agentic path. A generator makes (uncommitted)\n *  changes inside `worktreePath`; the driver commits them via the worktree\n *  adapter's `finalize`. */\nexport interface CandidateGenerator {\n  kind: string\n  /** Whether this generator can produce a candidate from an EMPTY findings set\n   *  and no phase-2 report — i.e. it draws its change signal from the repo and\n   *  the raw-trace filesystem context on disk, not only from pre-summarized\n   *  findings. An agentic coder (`agenticGenerator`) sets this: the seed repo +\n   *  raw traces ARE the signal, so it must still run the full `populationSize`\n   *  when the distiller yielded nothing (this is the meta-harness contract — the\n   *  agent diagnoses from the raw traces itself). A patch-applier\n   *  (`reflectiveGenerator`) leaves it unset — with no findings there is no\n   *  patch to draft, so the driver short-circuits rather than spin up worktrees\n   *  for a guaranteed no-op. Default `false`. */\n  proposesWithoutFindings?: boolean\n  generate(args: {\n    /** The candidate worktree — a clean checkout of the current incumbent. */\n    worktreePath: string\n    /** Phase-2 research report (analyst findings + diff), opaque. */\n    report: unknown\n    /** Findings resolved from the report or the loop context. */\n    findings: AnalystFinding[]\n    /** Handle to all captured data, to ground the change. */\n    dataset?: LabeledScenarioStore\n    /** DEPTH: max iterations the generator may take (agentic uses this; the\n     *  reflective generator ignores it). */\n    maxShots: number\n    signal: AbortSignal\n    /** Improvement-loop coordinates. Present when called through improvementDriver. */\n    generation?: number\n    candidateIndex?: number\n    /** Shared run-wide paid-call account supplied by agent-eval 0.117+. */\n    costLedger?: CostLedger\n    /** Receipt attribution phase supplied alongside `costLedger`. */\n    costPhase?: string\n  }): Promise<{ applied: boolean; summary: string }>\n}\n\nexport interface ImprovementDriverOptions {\n  worktree: WorktreeAdapter\n  generator: CandidateGenerator\n  /** Root ref for first-generation/direct callers. Default `main`.\n   *  Later code generations retain the incumbent's original root. */\n  baseRef?: string\n}\n\nexport interface ManagedImprovementDriver extends SurfaceProposer<AnalystFinding> {\n  /** Remove every owned candidate except explicitly retained finalized winners. */\n  cleanup(retainWorktreeRefs?: readonly string[]): Promise<void>\n}\n\n/** The one reflective/agentic improvement proposer (`SurfaceProposer`): owns the candidate worktree lifecycle and delegates HOW a change is produced to a pluggable `CandidateGenerator`. */\nexport function improvementDriver(opts: ImprovementDriverOptions): ManagedImprovementDriver {\n  const baseRef = opts.baseRef ?? 'main'\n  const owned = new Map<string, Worktree>()\n\n  return {\n    kind: `improvement:${opts.generator.kind}`,\n    async propose(ctx: ProposeContext<AnalystFinding>) {\n      const findings = resolveFindings(ctx)\n      // No findings AND no report AND a generator that can only act on findings\n      // (the reflective patch-applier) — propose nothing rather than spin up\n      // worktrees for a guaranteed no-op. An agentic coder draws its signal from\n      // the repo + raw traces on disk, so it opts in via `proposesWithoutFindings`\n      // and still runs the full populationSize even on an empty findings set —\n      // otherwise the FIRST generation (whose seed findings are empty and whose\n      // rawTraceDistiller has not run yet) would always generate ZERO candidates.\n      if (\n        findings.length === 0 &&\n        ctx.report === undefined &&\n        !opts.generator.proposesWithoutFindings\n      ) {\n        return []\n      }\n\n      const surfaces: CodeSurface[] = []\n      const incumbent = verifiedCodeIncumbent(ctx.currentSurface)\n      const proposalBaseRef = incumbent?.baseCommit ?? baseRef\n      for (let i = 0; i < ctx.populationSize; i++) {\n        if (ctx.signal.aborted) break\n        const wt = await opts.worktree.create({\n          baseRef: proposalBaseRef,\n          label: `${opts.generator.kind}-gen${ctx.generation}-cand${i}`,\n        })\n        owned.set(wt.path, wt)\n        // Once a worktree exists it MUST be accounted for: finalized into a\n        // surface, or discarded. A throw from generate()/finalize() must not\n        // leak the worktree + branch — discard best-effort, then rethrow loud.\n        try {\n          if (incumbent) advanceToIncumbent(wt, incumbent)\n          const { applied, summary } = await opts.generator.generate({\n            worktreePath: wt.path,\n            report: ctx.report,\n            findings,\n            dataset: ctx.dataset,\n            maxShots: ctx.maxImprovementShots ?? 1,\n            signal: ctx.signal,\n            generation: ctx.generation,\n            candidateIndex: i,\n            ...(ctx.costLedger ? { costLedger: ctx.costLedger } : {}),\n            ...(ctx.costPhase ? { costPhase: ctx.costPhase } : {}),\n          })\n          if (!applied) {\n            await opts.worktree.discard(wt)\n            owned.delete(wt.path)\n            continue\n          }\n          const surface = await opts.worktree.finalize(wt, summary)\n          surfaces.push(surface)\n          owned.delete(wt.path)\n          owned.set(surface.worktreeRef, wt)\n        } catch (err) {\n          const cleanupErrors: unknown[] = []\n          for (let attempt = 0; attempt < 2; attempt += 1) {\n            try {\n              await opts.worktree.discard(wt)\n              owned.delete(wt.path)\n              break\n            } catch (cause) {\n              cleanupErrors.push(cause)\n            }\n          }\n          if (cleanupErrors.length === 0) throw err\n          const failure = err instanceof Error ? err.message : String(err)\n          const cleanupSucceeded = !owned.has(wt.path)\n          throw new AggregateError(\n            [err, ...cleanupErrors],\n            cleanupSucceeded\n              ? `improvementDriver: ${failure}; candidate cleanup retry succeeded`\n              : `improvementDriver: ${failure}; candidate worktree could not be cleaned`,\n          )\n        }\n      }\n      return surfaces\n    },\n    async cleanup(retainWorktreeRefs = []) {\n      const retained = new Set(retainWorktreeRefs)\n      const errors: unknown[] = []\n      for (const [worktreeRef, worktree] of owned) {\n        if (retained.has(worktreeRef)) continue\n        try {\n          await opts.worktree.discard(worktree)\n          owned.delete(worktreeRef)\n        } catch (cause) {\n          errors.push(cause)\n        }\n      }\n      if (errors.length > 0) {\n        throw new AggregateError(errors, 'improvementDriver: failed to discard candidate worktrees')\n      }\n    },\n  }\n}\n\n/** A code incumbent must still match the immutable identity that was measured. */\nfunction verifiedCodeIncumbent(surface: ProposeContext['currentSurface']): CodeSurface | undefined {\n  if (typeof surface !== 'object' || surface.kind !== 'code') return undefined\n  verifyCodeSurface(surface)\n  return surface\n}\n\n/** Start at the root commit recorded by the incumbent, then fast-forward the\n *  fresh branch to the incumbent commit. The worktree stays clean for the\n *  generator while `finalize()` still emits one cumulative root-to-candidate\n *  patch that can be applied or rolled back independently of prior branches. */\nfunction advanceToIncumbent(worktree: Worktree, incumbent: CodeSurface): void {\n  if (worktree.baseCommit !== incumbent.baseCommit || worktree.baseTree !== incumbent.baseTree) {\n    throw new Error('improvementDriver: candidate worktree does not match incumbent base identity')\n  }\n  if (worktree.baseCommit === incumbent.candidateCommit) return\n\n  const merge = spawnSync('git', ['merge', '--ff-only', incumbent.candidateCommit], {\n    cwd: worktree.path,\n    encoding: 'utf8',\n  })\n  if (merge.error) {\n    throw new Error(\n      `improvementDriver: failed to start candidate from incumbent: ${merge.error.message}`,\n    )\n  }\n  if (merge.status !== 0) {\n    throw new Error(\n      `improvementDriver: could not fast-forward candidate to incumbent ${incumbent.candidateCommit}: ${merge.stderr.trim()}`,\n    )\n  }\n\n  const head = spawnSync('git', ['rev-parse', '--verify', 'HEAD'], {\n    cwd: worktree.path,\n    encoding: 'utf8',\n  })\n  if (head.error || head.status !== 0 || head.stdout.trim() !== incumbent.candidateCommit) {\n    throw new Error('improvementDriver: candidate worktree did not reach the incumbent commit')\n  }\n}\n\n/** Phase-2 report carries `findings` when present; else fall back to the\n *  loop's `ctx.findings`. The report is opaque to the substrate, so probe it\n *  structurally. */\nfunction resolveFindings(ctx: ProposeContext<AnalystFinding>): AnalystFinding[] {\n  const report = ctx.report\n  if (report && typeof report === 'object' && 'findings' in report) {\n    const f = (report as { findings: unknown }).findings\n    if (Array.isArray(f) && f.length > 0) return f as AnalystFinding[]\n  }\n  return ctx.findings\n}\n","/**\n *\n * `rawTraceDistiller` — the meta-harness `analyzeGeneration` producer.\n *\n * The default `generationFailureDistiller` (in `improve.ts`) COMPRESSES each\n * generation's failing cells into ~400-char structured findings before the next\n * proposal round. That is the ACE-style recipe: a small summary is the proposer's\n * whole view of what went wrong. This producer does the opposite — the\n * meta-harness recipe (yoonholee.com/meta-harness): it does NOT summarize. It\n * points the coding-agent proposer at the generation's RAW run traces already on\n * disk under `runDir` — the durable per-cell `spans.jsonl` event logs,\n * `cached-result.json` scores, and any artifacts the substrate persisted — and\n * instructs the agent to `grep`/`cat`/`ls` them to diagnose the failures itself\n * (up to the harness's full context, ~millions of tokens, vs a ~400-char digest).\n *\n * It emits `AnalystFinding[]` so it drops into the SAME `opts.analyzeGeneration`\n * slot the default distiller uses, and renders through the same\n * `agenticGenerator` prompt path (`claim` + `recommended_action`). The findings\n * carry ABSOLUTE paths — the coding harness runs with `cwd` = a candidate\n * worktree, so a relative `runDir` would be uncattable from there.\n *\n * Runtime layout it reads (written by agent-eval's optimization loop):\n *\n *   <runDir>/gen-<N>/                     ← the generation dir (input.runDir)\n *     candidate-<i>/                      ← one candidate campaign (campaign.runDir)\n *       <sanitized cellId>/               ← one scenario×rep cell\n *         spans.jsonl                     ← the raw trace (event/span log)\n *         cached-result.json              ← the cell's score + artifact ref\n *         <artifacts…>                    ← whatever the dispatch wrote\n *\n * @experimental\n */\n\nimport { type Dirent, existsSync, readdirSync } from 'node:fs'\nimport { basename, join, resolve } from 'node:path'\nimport { type AnalystFinding, makeFinding } from '@tangle-network/agent-eval'\nimport type { Scenario, SelfImproveOptions } from '@tangle-network/agent-eval/contract'\n\nconst ANALYST_ID = 'raw-trace-distiller'\n/** A cell counts as \"failing\" below this mean composite (matches the default\n *  distiller's near-perfect threshold) or when it recorded an `error`. */\nconst PASS_THRESHOLD = 0.999\n\nexport interface RawTraceDistillerOptions {\n  /** Anchor the emitted paths at this run root instead of the generation `runDir`\n   *  the loop passes in. Normally unset — each call points at that generation's\n   *  own directory (`input.runDir`). Pass an absolute path when you construct the\n   *  producer ahead of the loop and want a fixed anchor (e.g. a test fixture). */\n  runDir?: string\n  /** Max candidates to surface trace paths for, worst-scoring first. Default 12. */\n  maxCandidates?: number\n  /** Max failing cells to enumerate per candidate before collapsing the rest into\n   *  an \"ls the candidate dir\" pointer. Default 8. */\n  maxCellsPerCandidate?: number\n  /** Max concrete file paths to list per cell (the agent can always `ls` the dir\n   *  for the rest). Default 24. */\n  maxFilesPerCell?: number\n  /** Findings to fall back to when the generation had NO failing cells, so a\n   *  clean round never wipes the proposer's steering context. Mirrors the default\n   *  distiller's static-seed fallback. Default: a single instruction finding. */\n  fallbackFindings?: unknown[]\n}\n\ninterface CellTrace {\n  scenarioId: string\n  composite: number\n  error?: string\n  cellDir: string\n  files: string[]\n  truncatedFiles: boolean\n}\n\n/**\n * Build an `analyzeGeneration` producer that feeds the proposer RAW-TRACE\n * FILESYSTEM CONTEXT — paths into the prior generation's real run traces plus a\n * grep/cat-to-diagnose instruction — instead of a pre-summarized digest.\n *\n * Drop-in for `opts.analyzeGeneration` on `improve()` / `selfImprove()`:\n *\n *   await improve(profile, seedFindings, {\n *     surface: 'code',\n *     code: { repoRoot },\n *     runDir: '/abs/run',                 // MUST be a real path — the traces live here\n *     analyzeGeneration: rawTraceDistiller(),\n *     scenarios, judge, agent,\n *   })\n */\nexport function rawTraceDistiller<TScenario extends Scenario = Scenario, TArtifact = unknown>(\n  options: RawTraceDistillerOptions = {},\n): NonNullable<SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration']> {\n  const maxCandidates = options.maxCandidates ?? 12\n  const maxCellsPerCandidate = options.maxCellsPerCandidate ?? 8\n  const maxFilesPerCell = options.maxFilesPerCell ?? 24\n\n  return async (input) => {\n    const genRoot = absoluteRunDir(options.runDir ?? input.runDir)\n    const durable = isDurable(genRoot)\n\n    // Rank candidates worst-first; the worst failures are the highest-signal\n    // context for the next edit. Stable sort keeps equal-composite order.\n    const ranked = [...input.candidates]\n      .map((c) => ({\n        surfaceHash: c.surfaceHash,\n        composite: c.composite,\n        campaignDir: absoluteRunDir(c.campaign.runDir),\n        cells: failingCells(c.campaign, maxCellsPerCandidate, maxFilesPerCell),\n      }))\n      .sort((a, b) => a.composite - b.composite)\n      .slice(0, maxCandidates)\n\n    const totalFailingCells = ranked.reduce((n, c) => n + c.cells.length, 0)\n\n    // A clean generation: keep the proposer's steering context rather than\n    // wiping it (parity with the default distiller's static-seed fallback). An\n    // EMPTY fallback array means there is no STATIC seed to preserve — it must NOT\n    // wipe the context to nothing. Fall through to the default raw-trace\n    // instruction so the meta-harness discipline stays live (the agent still\n    // inspects the on-disk traces next round, and the finding's `raw-trace-context`\n    // area keeps the agenticGenerator's diagnosis-evidence gate armed). A bare\n    // `??` would return the empty array and silently disable both.\n    if (totalFailingCells === 0) {\n      if (options.fallbackFindings && options.fallbackFindings.length > 0) {\n        return options.fallbackFindings\n      }\n      return [\n        makeFinding({\n          analyst_id: ANALYST_ID,\n          severity: 'info',\n          area: 'raw-trace-context',\n          confidence: 1,\n          claim: `Generation ${input.generation} had no failing cells. The full raw run traces are on disk under ${genRoot}.`,\n          recommended_action: `To keep improving, grep/cat the raw traces under ${genRoot} (per-cell spans.jsonl + cached-result.json) to find the weakest passing runs, then make a targeted harness-code edit.`,\n          evidence_refs: [{ kind: 'artifact', uri: genRoot }],\n          metadata: { generation: input.generation, runDir: genRoot, failingCells: 0 },\n        }),\n      ]\n    }\n\n    const findings: AnalystFinding[] = []\n\n    // 1. The meta-harness instruction: diagnose from the RAW traces, not a digest.\n    findings.push(\n      makeFinding({\n        analyst_id: ANALYST_ID,\n        severity: 'high',\n        area: 'raw-trace-context',\n        confidence: 1,\n        claim: `Generation ${input.generation} produced ${totalFailingCells} failing/low-scoring cell(s) across ${ranked.length} candidate(s). Their FULL RAW run traces are on disk under ${genRoot} — the actual event logs (spans.jsonl), scores (cached-result.json), and artifacts, not a summary.${\n          durable\n            ? ''\n            : ' (WARNING: this run root does not exist on disk — it looks like an in-memory run; pass a real runDir to improve() to get raw-trace context.)'\n        }`,\n        recommended_action: `Do NOT rely on a pre-summarized finding. Before editing, DIAGNOSE from the raw traces: run \\`grep\\`/\\`cat\\`/\\`ls\\` over the trace files and directories named in the following findings to see exactly what each failing run did and why it scored low, then make the smallest harness-code edit that fixes the dominant failure. Start with \\`grep -rIn \"error\" ${genRoot}\\` then \\`cat\\` the spans.jsonl of the worst cell.`,\n        evidence_refs: [{ kind: 'artifact', uri: genRoot }],\n        metadata: {\n          generation: input.generation,\n          runDir: genRoot,\n          failingCells: totalFailingCells,\n          candidates: ranked.length,\n        },\n      }),\n    )\n\n    // 2. One finding per failing candidate: its campaign dir + the concrete raw\n    //    trace files to grep/cat.\n    for (const cand of ranked) {\n      if (cand.cells.length === 0) continue\n      const scenarioList = cand.cells.map((c) => c.scenarioId).join(', ')\n      const fileLines = cand.cells\n        .map((c) => {\n          const header = `  cell ${c.scenarioId} (composite ${c.composite.toFixed(3)}${\n            c.error ? `, error: ${truncate(c.error, 160)}` : ''\n          }) — dir ${c.cellDir}`\n          const files = c.files.map((f) => `    - ${f}`).join('\\n')\n          const more = c.truncatedFiles ? `\\n    - …(ls ${c.cellDir} for the rest)` : ''\n          return c.files.length > 0 ? `${header}\\n${files}${more}` : header\n        })\n        .join('\\n')\n\n      findings.push(\n        makeFinding({\n          analyst_id: ANALYST_ID,\n          severity: cand.composite < 0.5 ? 'critical' : 'high',\n          area: 'raw-trace-context',\n          confidence: 1,\n          subject: cand.surfaceHash,\n          claim: `Candidate ${cand.surfaceHash} scored composite ${cand.composite.toFixed(3)} with ${cand.cells.length} failing cell(s) [${scenarioList}]. Its raw traces are under ${cand.campaignDir}.`,\n          recommended_action: `grep/cat these raw trace files to diagnose WHY this candidate failed before editing:\\n${fileLines}\\nOr scan the whole candidate at once: \\`grep -rIn . ${cand.campaignDir}\\` and \\`ls -R ${cand.campaignDir}\\`.`,\n          evidence_refs: [\n            { kind: 'artifact', uri: cand.campaignDir },\n            ...cand.cells.flatMap((c) =>\n              c.files.map((f) => ({ kind: 'artifact' as const, uri: f })),\n            ),\n          ],\n          metadata: {\n            surfaceHash: cand.surfaceHash,\n            composite: cand.composite,\n            campaignDir: cand.campaignDir,\n            cells: cand.cells.map((c) => ({\n              scenarioId: c.scenarioId,\n              composite: c.composite,\n              cellDir: c.cellDir,\n              files: c.files,\n              ...(c.error ? { error: c.error } : {}),\n            })),\n          },\n        }),\n      )\n    }\n\n    return findings\n  }\n}\n\n/** The failing cells of a candidate campaign, each with its on-disk trace files.\n *  Mirrors the default distiller's per-cell composite (mean of judge composites,\n *  0 when a cell produced no judge score) and its failing predicate. */\nfunction failingCells(\n  campaign: {\n    runDir: string\n    cells: ReadonlyArray<{\n      cellId: string\n      scenarioId: string\n      error?: string\n      judgeScores: Record<string, { composite?: number }>\n    }>\n    artifactsByPath?: Record<string, string>\n  },\n  maxCells: number,\n  maxFiles: number,\n): CellTrace[] {\n  const campaignDir = absoluteRunDir(campaign.runDir)\n  const durable = isDurable(campaignDir)\n  const out: CellTrace[] = []\n  for (const cell of campaign.cells) {\n    const scores = Object.values(cell.judgeScores ?? {})\n    const composite =\n      scores.length === 0\n        ? 0\n        : scores.reduce((sum, s) => sum + (s.composite ?? 0), 0) / scores.length\n    if (!cell.error && composite >= PASS_THRESHOLD) continue\n\n    const cellDir = join(campaignDir, sanitizeCellId(cell.cellId))\n    const artifactPaths = artifactPathsForCell(campaign.artifactsByPath, cell.cellId)\n    const discovered = durable ? listTraceFiles(cellDir) : []\n    // Canonical anchors the substrate always writes, kept even when a mem:// run\n    // never flushed them to disk (so the agent still learns the expected path).\n    const canonical = [join(cellDir, 'spans.jsonl'), join(cellDir, 'cached-result.json')]\n    const files = dedupeSorted([...discovered, ...artifactPaths, ...canonical])\n\n    out.push({\n      scenarioId: cell.scenarioId,\n      composite: Number(composite.toFixed(3)),\n      ...(cell.error ? { error: cell.error } : {}),\n      cellDir,\n      files: files.slice(0, maxFiles),\n      truncatedFiles: files.length > maxFiles,\n    })\n    if (out.length >= maxCells) break\n  }\n  return out\n}\n\n/** Absolute paths of artifacts the campaign recorded for a cell. `artifactsByPath`\n *  is keyed `${cellId}/${relPath}` → absolute path. */\nfunction artifactPathsForCell(\n  artifactsByPath: Record<string, string> | undefined,\n  cellId: string,\n): string[] {\n  if (!artifactsByPath) return []\n  const prefix = `${cellId}/`\n  return Object.entries(artifactsByPath)\n    .filter(([key]) => key.startsWith(prefix))\n    .map(([, absPath]) => resolve(absPath))\n}\n\n/** Real files directly under `dir` and one level of sub-directories (artifacts\n *  are sometimes nested). Absolute paths, sorted. `[]` when the dir is absent,\n *  stale, unreadable, or contains symlinked dirs — trace context is advisory and\n *  the canonical anchors below still tell the proposer where to inspect. */\nfunction listTraceFiles(dir: string): string[] {\n  const out: string[] = []\n  for (const entry of safeReadDir(dir)) {\n    const full = join(dir, entry.name)\n    if (entry.isFile()) {\n      out.push(full)\n    } else if (!entry.isSymbolicLink() && entry.isDirectory()) {\n      for (const sub of safeReadDir(full)) {\n        if (sub.isFile()) out.push(join(full, sub.name))\n      }\n    }\n  }\n  return out\n}\n\nfunction safeReadDir(dir: string): Dirent[] {\n  try {\n    return readdirSync(dir, { withFileTypes: true })\n  } catch {\n    return []\n  }\n}\n\n/** Substrate cell-dir sanitization — must match agent-eval's\n *  `cellId.replace(/[^a-zA-Z0-9_-]/g, '_')` so the computed dir matches disk. */\nfunction sanitizeCellId(cellId: string): string {\n  return cellId.replace(/[^a-zA-Z0-9_-]/g, '_')\n}\n\n/** A run root is durable (has real files) when it is not an in-memory sentinel\n *  and exists on disk. `mem://` runs keep everything in-process — no traces. */\nfunction isDurable(runDir: string): boolean {\n  return !runDir.startsWith('mem://') && existsSync(runDir)\n}\n\n/** Resolve a run dir to absolute (the coding harness runs from a worktree cwd, so\n *  relative paths are uncattable there). `mem://` sentinels pass through untouched. */\nfunction absoluteRunDir(runDir: string): string {\n  return runDir.startsWith('mem://') ? runDir : resolve(runDir)\n}\n\nfunction dedupeSorted(paths: string[]): string[] {\n  return [...new Set(paths)].sort((a, b) => {\n    // Group by directory then filename for a stable, readable listing.\n    const da = a.slice(0, a.length - basename(a).length)\n    const db = b.slice(0, b.length - basename(b).length)\n    return da === db ? basename(a).localeCompare(basename(b)) : da.localeCompare(db)\n  })\n}\n\nfunction truncate(s: string, n: number): string {\n  return s.length <= n ? s : `${s.slice(0, n - 1)}…`\n}\n","/**\n *\n * `improve` — the ONE public, surface-pluggable RSI verb.\n *\n * A thin facade over agent-eval's `selfImprove` (the held-out-gated closed\n * loop). It removes the two things a caller otherwise has to know to drive the\n * loop by hand: WHICH `MutableSurface` of the profile is being optimized, and\n * WHICH `SurfaceProposer` mutates that surface. You name a `surface`; the\n * facade picks the matching default proposer, extracts the baseline surface from\n * the profile, runs `selfImprove`, and (on a ship verdict) writes the promoted\n * winner back into the corresponding profile field.\n *\n *   - `surface: 'prompt'` → `gepaProposer` mutates `profile.prompt.systemPrompt`.\n *   - `surface: 'skills'` → `skillOptProposer` mutates a skills document string.\n *   - `surface: 'memory'` → `memoryCurationProposer` curates a bounded durable\n *     lesson document supplied through `opts.memory`.\n *   - `surface: 'agent-profile'` → caller-supplied proposer mutates the complete\n *     canonical AgentProfile JSON in one candidate.\n *   - `surface` ∈ {`tools`, `mcp`, `hooks`, `subagents`, `agent-profile`} → no zero-config default\n *     proposer exists (a code/config proposer needs caller-supplied wiring — a\n *     worktree repo root, a candidate generator, a serializer). The facade\n *     requires an explicit `opts.generator` for these and throws a `ConfigError`\n *     otherwise. This is a designed boundary, not a missing default: there is\n *     no safe value the facade could invent for those surfaces. Code instead\n *     requires `opts.code.repoRoot` and accepts only the runtime-owned\n *     `opts.code.generator` path so every isolated checkout can be released.\n *\n * Everything else (`scenarios`, `judge`, `agent`, `budget`, `llm`) passes\n * straight through to `selfImprove`.\n *\n * @experimental\n */\n\nimport { canonicalJson } from '@tangle-network/agent-eval'\nimport {\n  gepaProposer,\n  gitWorktreeAdapter,\n  memoryCurationProposer,\n  skillOptProposer,\n  type Worktree,\n  type WorktreeAdapter,\n} from '@tangle-network/agent-eval/campaign'\nimport {\n  type CodeSurface,\n  type MutableSurface,\n  type Scenario,\n  type SelfImproveBudget,\n  type SelfImproveLlm,\n  type SelfImproveOptions,\n  type SelfImproveResult,\n  type SurfaceProposer,\n  selfImprove,\n} from '@tangle-network/agent-eval/contract'\nimport { type AgentProfile, agentProfileSchema } from '@tangle-network/agent-interface'\nimport { ConfigError } from '../errors'\nimport type { LocalHarness } from '../mcp/local-harness'\nimport { assertModelAllowed } from '../runtime/supervise/model-policy'\nimport { agenticGenerator, type Verifier } from './agentic-generator'\nimport {\n  type CandidateGenerator,\n  improvementDriver,\n  type ManagedImprovementDriver,\n} from './improvement-driver'\nimport { rawTraceDistiller } from './raw-trace-distiller'\n\n/** The executable agent lever `improve` optimizes. Profile fields remain\n *  portable AgentProfile coordinates; implementation and orchestration files\n *  use the code surface so a winner can be sealed into an exact candidate. */\nexport type ImproveSurface =\n  | 'prompt'\n  | 'skills'\n  | 'tools'\n  | 'mcp'\n  | 'hooks'\n  | 'subagents'\n  | 'agent-profile'\n  | 'memory'\n  | 'code'\n\nexport type ImproveOptions<TScenario extends Scenario, TArtifact> = Omit<\n  SelfImproveOptions<TScenario, TArtifact>,\n  'analyzeGeneration' | 'baselineSurface' | 'findings' | 'gate' | 'proposer'\n> & {\n  /** Which profile lever to optimize. Default `'prompt'`. Selects the default\n   *  generator + the baseline-surface extraction shape. */\n  surface?: ImproveSurface\n  /** The `SurfaceProposer` that mutates a profile surface. When unset, the facade\n   *  picks the default for prompt, skills, and memory; surfaces\n   *  with no default REQUIRE this (fail-loud otherwise). Forbidden for code;\n   *  use `code.generator` so the runtime owns candidate cleanup. */\n  generator?: SurfaceProposer\n  /** Gate mode. `'holdout'` (default) runs the held-out promotion gate;\n   *  `'none'` is a baseline-only run (`budget.generations = 0`). */\n  gate?: 'holdout' | 'none'\n  /** Restrict the run to this subset of models. When set, the reflection model\n   *  (`llm.model`, or the default when unset) must be a member, or `improve()` throws\n   *  a `ConfigError` before the generator is built. Unset = unrestricted. */\n  allowedModels?: readonly string[]\n  /** Per-generation findings producer passthrough (see selfImprove.analyzeGeneration).\n   *  DEFAULT: the built-in failure distiller — after each generation it turns the\n   *  worst-scoring/errored cells into structured findings ({ scenario, composite,\n   *  notes, error }) for the NEXT proposal round, so the proposer reasons over what\n   *  actually failed instead of a static seed. Pass your own producer (e.g. a\n   *  trace-analyst over the runDir's traces) to replace it; pass `null` to disable\n   *  and keep the static `findings` all the way through. */\n  analyzeGeneration?: SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration'] | null\n  /** META-HARNESS mode: instead of the ~400-char distilled findings, feed the\n   *  proposer RAW-TRACE FILESYSTEM CONTEXT — the PATHS into the prior generation's\n   *  real run traces under `runDir` (per-cell `spans.jsonl` event logs +\n   *  `cached-result.json` scores + artifacts) plus a `grep`/`cat`-to-diagnose\n   *  instruction — so the coding agent reads the actual failures itself rather than\n   *  a pre-summary. Requires a REAL `runDir` (that is where the traces live).\n   *  Ignored when `analyzeGeneration` is set explicitly (that wins) or is `null`\n   *  (disabled). Equivalent to `analyzeGeneration: rawTraceDistiller()`; this flag\n   *  is the one-line enable. Default `false` (the distiller stays the default). */\n  rawTraceContext?: boolean\n  /** CODE-surface wiring: name `surface: 'code'`, point at a repo, and the\n   *  facade assembles the whole candidate pipeline — an isolated incumbent plus git worktrees\n   *  (`gitWorktreeAdapter`) driven by `improvementDriver` with the full agentic\n   *  generator (a real coding harness edits each candidate worktree; a `verify`\n   *  hook gates candidates before they are ever measured). Ignored when\n   *  `opts.generator` is supplied. Required for every code run because a real\n   *  repository and base ref are necessary to measure the incumbent. */\n  code?: ImproveCodeOptions\n  /** SKILLS-surface wiring for real skill-DOCUMENT optimization. Without this,\n   *  `surface: 'skills'` optimizes the profile's skills REFS array (file pointers)\n   *  — which `skillOptProposer` (a document patcher) cannot meaningfully edit.\n   *  Provide the document CONTENT to optimize + a `writeBack` to persist the\n   *  shipped winner (the profile ref points at a file the caller owns). This is\n   *  what makes skillOpt reachable through improve(). */\n  skills?: ImproveSkillsOptions\n  /** MEMORY-surface wiring for a curated durable memory document. The default\n   *  deterministic proposer deduplicates and ranks lessons from findings, then\n   *  replaces its managed block instead of growing memory without bound. */\n  memory?: ImproveMemoryOptions\n  /** Custom held-back-exam decision. The string `gate` above controls whether\n   *  the exam runs; this callback controls how its evidence decides promotion. */\n  promotionGate?: SelfImproveOptions<TScenario, TArtifact>['gate']\n}\n\nexport interface ImproveSkillsOptions {\n  /** The skill document's current text — the baseline `skillOptProposer` patches. */\n  document: string\n  /** Persist the shipped winner document (write the file the profile ref points at).\n   *  Called only on a ship verdict. When omitted, the winner is still returned in\n   *  `result.raw.winner.surface` for the caller to materialize. */\n  writeBack?: (winnerDocument: string) => void | Promise<void>\n}\n\nexport interface ImproveMemoryOptions {\n  /** Current durable memory text used as the measured baseline. */\n  document: string\n  /** Persist the promoted memory document. Never called on hold or error. */\n  writeBack?: (winnerDocument: string) => void | Promise<void>\n}\n\nexport interface ImproveCodeOptions {\n  /** Repo root candidate worktrees fork from. */\n  repoRoot: string\n  /** Base ref candidates fork from. Default `main`. */\n  baseRef?: string\n  /** Directory worktrees are created under. Default `<repoRoot>/.worktrees`. */\n  worktreeDir?: string\n  /** Git-compatible adapter override, primarily for tests. Candidate advancement\n   *  still requires normal Git worktree and commit semantics. */\n  worktree?: WorktreeAdapter\n  /** Coding harness the agentic generator runs in each worktree. Default `claude`. */\n  harness?: LocalHarness\n  /** Verify a candidate worktree before it becomes a measurable surface; failures\n   *  feed the next shot (see `agenticGenerator.verify` / `commandVerifier`). */\n  verify?: Verifier\n  /** Per-shot wall-clock timeout for the harness (ms). */\n  timeoutMs?: number\n  /** Byte-producer override — the test seam and the escape hatch for custom\n   *  candidate production. When set, `harness`/`verify`/`timeoutMs` are unused. */\n  generator?: CandidateGenerator\n}\n\nexport interface ImproveResult<TScenario extends Scenario, TArtifact> {\n  /** The profile after improvement: the winner surface applied back into the\n   *  matching field when the gate shipped, else the input profile unchanged. */\n  profile: AgentProfile\n  /** True when `gateDecision === 'ship'`. */\n  shipped: boolean\n  /** Held-out lift (`winner − baseline` composite). */\n  lift: number\n  /** The five-valued gate verdict from `selfImprove`. */\n  gateDecision: SelfImproveResult<TScenario, TArtifact>['gateDecision']\n  /** Full `selfImprove` result for advanced inspection. For code runs,\n   *  `raw.winner.surface.worktreeRef` remains live after return whether the\n   *  candidate shipped or held; call `dispose()` after consuming it. */\n  raw: SelfImproveResult<TScenario, TArtifact>\n  /** Release resources owned by this result. Idempotent; currently disposes\n   *  the returned code worktree and is a no-op for profile-only surfaces. */\n  dispose(): Promise<void>\n}\n\n/** Default model id for the reflective drivers when `llm.model` is unset — a model the Tangle\n *  router actually serves (callers should pass their own `llm.model`). */\nconst defaultReflectionModel = 'deepseek-v4-flash'\n\n/** The reflective proposers (`gepaProposer`/`skillOptProposer`) take a full\n *  `LlmClientOptions`; `SelfImproveLlm` is the thin user-facing subset. */\nfunction llmClientOptions(llm: SelfImproveLlm | undefined): { baseUrl?: string; apiKey?: string } {\n  return { baseUrl: llm?.baseUrl, apiKey: llm?.apiKey }\n}\n\n/** The default proposer for a surface, or `undefined` when the surface has no\n *  zero-config default (the caller must supply `opts.generator`). */\nfunction defaultGeneratorFor(\n  surface: ImproveSurface,\n  llm: SelfImproveLlm | undefined,\n): SurfaceProposer | undefined {\n  const model = llm?.model ?? defaultReflectionModel\n  switch (surface) {\n    case 'prompt':\n      return gepaProposer({ llm: llmClientOptions(llm), model, target: 'agent system prompt' })\n    case 'skills':\n      return skillOptProposer({ llm: llmClientOptions(llm), model, target: 'agent skill document' })\n    case 'memory':\n      return memoryCurationProposer()\n    default:\n      return undefined\n  }\n}\n\n/** Extract the baseline surface a driver mutates from the profile field that\n *  backs `surface`. Prompt, skills, and memory are text surfaces; config\n *  surfaces serialize the matching profile record. */\nfunction baselineSurfaceFor(\n  profile: AgentProfile,\n  surface: ImproveSurface,\n  skills?: ImproveSkillsOptions,\n  memory?: ImproveMemoryOptions,\n): MutableSurface {\n  switch (surface) {\n    case 'prompt':\n      return profile.prompt?.systemPrompt ?? ''\n    case 'skills':\n      // With a document supplied, optimize its CONTENT (the real skillOpt path);\n      // otherwise fall back to the refs-array surface for back-compat.\n      return skills?.document ?? JSON.stringify(profile.resources?.skills ?? [])\n    case 'tools':\n      return JSON.stringify(profile.tools ?? {})\n    case 'mcp':\n      return JSON.stringify(profile.mcp ?? {})\n    case 'hooks':\n      return JSON.stringify(profile.hooks ?? {})\n    case 'subagents':\n      return JSON.stringify(profile.subagents ?? {})\n    case 'agent-profile':\n      return canonicalJson(profile)\n    case 'memory':\n      if (!memory) {\n        throw new ConfigError(\"improve(): surface 'memory' requires opts.memory.document\")\n      }\n      return memory.document\n    case 'code':\n      throw new ConfigError(\n        'improve(): code requires the isolated baseline created from opts.code.repoRoot',\n      )\n  }\n}\n\n/** The default `analyzeGeneration`: distill each generation's failing cells into\n *  findings for the next proposal round. Deliberately dependency-free — judge notes\n *  and errors are already the domain's own diagnosis (executable gates put their\n *  reasons there); a trace-analyst can replace this wholesale via\n *  `opts.analyzeGeneration`. Falls back to the static seed findings when the\n *  generation had no failures, so a clean round never wipes the seed context. */\nfunction generationFailureDistiller<TScenario extends Scenario, TArtifact>(\n  staticFindings: unknown[],\n): NonNullable<SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration']> {\n  const CAP = 12\n  return async (input) => {\n    const failures: Array<{\n      scenario: string\n      composite: number\n      notes: string\n      claim?: string\n      error?: string\n    }> = []\n    for (const candidate of input.candidates) {\n      for (const rawCell of candidate.campaign.cells) {\n        const cell = rawCell as unknown as Record<string, unknown>\n        const scenario = String(cell.scenarioId ?? 'unknown')\n        const error = typeof cell.error === 'string' ? cell.error : undefined\n        const judgeScores =\n          cell.judgeScores && typeof cell.judgeScores === 'object'\n            ? Object.values(\n                cell.judgeScores as Record<string, { composite?: number; notes?: string }>,\n              )\n            : []\n        const composite =\n          judgeScores.length === 0\n            ? 0\n            : judgeScores.reduce((sum, j) => sum + (j.composite ?? 0), 0) / judgeScores.length\n        if (!error && composite >= 0.999) continue\n        const notes = judgeScores\n          .map((j) => j.notes)\n          .filter((n): n is string => typeof n === 'string' && n.length > 0)\n          .join('; ')\n          .slice(0, 400)\n        const claim = notes || (error ? `Scenario ${scenario} failed: ${error.slice(0, 200)}` : '')\n        failures.push({\n          scenario,\n          composite: Number(composite.toFixed(3)),\n          notes,\n          ...(claim ? { claim } : {}),\n          ...(error ? { error: error.slice(0, 200) } : {}),\n        })\n      }\n    }\n    if (failures.length === 0) return staticFindings\n    failures.sort((a, b) => a.composite - b.composite)\n    return failures.slice(0, CAP)\n  }\n}\n\n/** Memory accumulates durable lessons, so keep the caller's seed findings while\n * adding fresh judge failures. Curator proposers consume `claim`; the generic\n * distiller retains the richer diagnostic fields for reflective proposers. */\nfunction memoryGenerationDistiller<TScenario extends Scenario, TArtifact>(\n  staticFindings: unknown[],\n): NonNullable<SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration']> {\n  const distillFailures = generationFailureDistiller<TScenario, TArtifact>(staticFindings)\n  return async (input) => {\n    const fresh = await distillFailures(input)\n    return fresh === staticFindings ? staticFindings : [...staticFindings, ...fresh]\n  }\n}\n\ninterface PreparedCodeRun {\n  baseline: CodeSurface\n  proposer: SurfaceProposer\n  cleanup(retainedWinner?: MutableSurface): Promise<void>\n}\n\n/** Preserve the primary failure while making two best-effort cleanup attempts.\n * A failed first attempt is retained in the thrown AggregateError even when the\n * retry succeeds, so callers can diagnose degraded cleanup without losing the\n * error that caused cleanup to run. */\nasync function rethrowAfterCleanup(\n  cause: unknown,\n  cleanup: () => Promise<void>,\n  message: string,\n): Promise<never> {\n  const cleanupErrors: unknown[] = []\n  for (let attempt = 0; attempt < 2; attempt += 1) {\n    try {\n      await cleanup()\n    } catch (cleanupCause) {\n      cleanupErrors.push(cleanupCause)\n      continue\n    }\n    if (cleanupErrors.length === 0) throw cause\n    throw new AggregateError([cause, ...cleanupErrors], `${message}; the cleanup retry succeeded`)\n  }\n  throw new AggregateError([cause, ...cleanupErrors], message)\n}\n\nasync function discardPreparedBaseline(\n  worktree: WorktreeAdapter,\n  baselineWorktree: Worktree,\n  cause: unknown,\n): Promise<never> {\n  return rethrowAfterCleanup(\n    cause,\n    () => worktree.discard(baselineWorktree),\n    'improve(): code preparation failed and its baseline worktree could not be cleaned',\n  )\n}\n\nfunction isCodeSurface(surface: MutableSurface | undefined): surface is CodeSurface {\n  return typeof surface === 'object' && surface !== null && surface.kind === 'code'\n}\n\n/** Create a clean incumbent checkout and the candidate producer for a code run. */\nasync function prepareCodeRun(code: ImproveCodeOptions): Promise<PreparedCodeRun> {\n  const baseRef = code.baseRef ?? 'main'\n  const worktree =\n    code.worktree ??\n    gitWorktreeAdapter({\n      repoRoot: code.repoRoot,\n      ...(code.worktreeDir ? { worktreeDir: code.worktreeDir } : {}),\n    })\n  const baselineWorktree = await worktree.create({ baseRef, label: 'incumbent-baseline' })\n  try {\n    const baseline = await worktree.finalize(baselineWorktree, 'Incumbent code checkout')\n    let baselineDiscarded = false\n    const generator =\n      code.generator ??\n      agenticGenerator({\n        ...(code.harness ? { harness: code.harness } : {}),\n        ...(code.verify ? { verify: code.verify } : {}),\n        ...(code.timeoutMs ? { timeoutMs: code.timeoutMs } : {}),\n      })\n    const managed: ManagedImprovementDriver = improvementDriver({ worktree, generator, baseRef })\n\n    return {\n      baseline,\n      proposer: managed,\n      async cleanup(retainedWinner) {\n        const errors: unknown[] = []\n        const retainedWorktreeRef = isCodeSurface(retainedWinner)\n          ? retainedWinner.worktreeRef\n          : undefined\n        try {\n          await managed?.cleanup(retainedWorktreeRef ? [retainedWorktreeRef] : [])\n        } catch (cause) {\n          errors.push(cause)\n        }\n        if (!baselineDiscarded && retainedWorktreeRef !== baseline.worktreeRef) {\n          try {\n            await worktree.discard(baselineWorktree)\n            baselineDiscarded = true\n          } catch (cause) {\n            errors.push(cause)\n          }\n        }\n        if (errors.length > 0) {\n          throw new AggregateError(errors, 'improve(): failed to clean code improvement worktrees')\n        }\n      },\n    }\n  } catch (cause) {\n    return discardPreparedBaseline(worktree, baselineWorktree, cause)\n  }\n}\n\nfunction idempotentDispose(dispose: () => Promise<void>): () => Promise<void> {\n  let disposed = false\n  let inFlight: Promise<void> | undefined\n  return async () => {\n    if (disposed) return\n    if (inFlight) return inFlight\n    inFlight = (async () => {\n      await dispose()\n      disposed = true\n    })()\n    try {\n      await inFlight\n    } finally {\n      inFlight = undefined\n    }\n  }\n}\n\n/** Parse a JSON winner surface (`tools`/`mcp`/`hooks`/`subagents`/`agent-profile`) with a typed,\n *  contextual error. A malformed generator output must fail loud here, not throw\n *  a raw `SyntaxError` to the caller after a ship verdict. */\nfunction parseWinnerJson<T>(winner: string, surface: ImproveSurface): T {\n  try {\n    return JSON.parse(winner) as T\n  } catch (cause) {\n    throw new ConfigError(\n      `improve(): the shipped '${surface}' winner is not valid JSON, so it cannot be applied back to the profile: ${\n        (cause as Error).message\n      }`,\n    )\n  }\n}\n\n/** Apply a promoted winner surface back into the profile field for `surface`.\n *  Returns a shallow copy; never mutates the input profile. */\nexport function applyImprovementWinnerToProfile(\n  profile: AgentProfile,\n  surface: ImproveSurface,\n  winner: MutableSurface,\n): AgentProfile {\n  // Only string surfaces map cleanly back onto a profile field. A `CodeSurface`\n  // winner (the `code` lever) is a worktree ref, not a profile value — the\n  // caller materializes it from `raw.winner.surface`; the returned profile is\n  // unchanged for that lever.\n  if (typeof winner !== 'string') return profile\n  let candidate: AgentProfile\n  switch (surface) {\n    case 'prompt':\n      candidate = { ...profile, prompt: { ...profile.prompt, systemPrompt: winner } }\n      break\n    case 'skills':\n      candidate = {\n        ...profile,\n        resources: { ...profile.resources, skills: parseWinnerJson(winner, surface) },\n      }\n      break\n    case 'tools':\n      candidate = { ...profile, tools: parseWinnerJson(winner, surface) }\n      break\n    case 'mcp':\n      candidate = { ...profile, mcp: parseWinnerJson(winner, surface) }\n      break\n    case 'hooks':\n      candidate = { ...profile, hooks: parseWinnerJson(winner, surface) }\n      break\n    case 'subagents':\n      candidate = { ...profile, subagents: parseWinnerJson(winner, surface) }\n      break\n    case 'agent-profile':\n      candidate = parseWinnerJson(winner, surface)\n      break\n    case 'memory':\n      return profile\n    case 'code':\n      return profile\n  }\n  const parsed = agentProfileSchema.safeParse(candidate)\n  if (!parsed.success) {\n    throw new ConfigError(\n      `improve(): the shipped '${surface}' winner does not produce a valid AgentProfile: ${parsed.error.message}`,\n    )\n  }\n  return parsed.data\n}\n\n/**\n * Run the held-out-gated self-improvement loop on ONE profile surface.\n *\n * @example Optimize the system prompt, default holdout gate:\n *\n *   const out = await improve(profile, findings, {\n *     surface: 'prompt',\n *     scenarios,\n *     judge,\n *     agent: (surface, scenario, ctx) => runAgent(surface, scenario, ctx.signal),\n *   })\n *   if (out.shipped) deploy(out.profile)\n */\nexport async function improve<TScenario extends Scenario, TArtifact>(\n  profile: AgentProfile,\n  findings: unknown[],\n  opts: ImproveOptions<TScenario, TArtifact>,\n): Promise<ImproveResult<TScenario, TArtifact>> {\n  const {\n    surface = 'prompt',\n    gate = 'holdout',\n    generator,\n    allowedModels,\n    rawTraceContext,\n    code,\n    skills,\n    memory,\n    promotionGate,\n    analyzeGeneration,\n    ...sharedOptions\n  } = opts\n\n  const parsedProfile = agentProfileSchema.safeParse(profile)\n  if (!parsedProfile.success) {\n    throw new ConfigError(\n      `improve(): input is not a valid AgentProfile: ${parsedProfile.error.message}`,\n    )\n  }\n  if (surface === 'skills' && !generator && !skills) {\n    throw new ConfigError(\n      'improve(): the default skills optimizer requires opts.skills.document; pass the skill text or an explicit generator that understands resource refs',\n    )\n  }\n  if (surface === 'memory' && !memory) {\n    throw new ConfigError(\"improve(): surface 'memory' requires opts.memory.document\")\n  }\n  if (surface === 'code' && generator) {\n    throw new ConfigError(\n      \"improve(): surface 'code' forbids opts.generator because an external SurfaceProposer cannot transfer checkout ownership; pass opts.code.generator instead\",\n    )\n  }\n  const usesReflectionModel = !generator && (surface === 'prompt' || surface === 'skills')\n  if (usesReflectionModel) {\n    assertModelAllowed(sharedOptions.llm?.model ?? defaultReflectionModel, allowedModels)\n  }\n\n  let preparedCode: PreparedCodeRun | undefined\n  if (surface === 'code') {\n    if (!code) {\n      throw new ConfigError(\n        \"improve(): surface 'code' requires opts.code.repoRoot so the incumbent can run from an isolated checkout\",\n      )\n    }\n    preparedCode = await prepareCodeRun(code)\n  }\n  const proposer =\n    preparedCode?.proposer ?? generator ?? defaultGeneratorFor(surface, sharedOptions.llm)\n  if (!proposer) {\n    throw new ConfigError(\n      `improve(): surface '${surface}' has no default generator — pass opts.generator (a SurfaceProposer) explicitly`,\n    )\n  }\n\n  const budget: SelfImproveBudget =\n    gate === 'none' ? { ...sharedOptions.budget, generations: 0 } : { ...sharedOptions.budget }\n\n  let raw: SelfImproveResult<TScenario, TArtifact>\n  try {\n    raw = await selfImprove<TScenario, TArtifact>({\n      ...sharedOptions,\n      baselineSurface:\n        preparedCode?.baseline ?? baselineSurfaceFor(profile, surface, skills, memory),\n      proposer,\n      budget,\n      findings,\n      ...(promotionGate !== undefined ? { gate: promotionGate } : {}),\n      ...(analyzeGeneration === null\n        ? {}\n        : {\n            analyzeGeneration:\n              analyzeGeneration ??\n              (rawTraceContext\n                ? rawTraceDistiller<TScenario, TArtifact>({ fallbackFindings: findings })\n                : surface === 'memory'\n                  ? memoryGenerationDistiller<TScenario, TArtifact>(findings)\n                  : generationFailureDistiller<TScenario, TArtifact>(findings)),\n          }),\n    })\n  } catch (cause) {\n    if (!preparedCode) throw cause\n    return rethrowAfterCleanup(\n      cause,\n      () => preparedCode.cleanup(),\n      'improve(): code improvement failed and its worktrees could not be cleaned',\n    )\n  }\n\n  const shipped = raw.gateDecision === 'ship'\n  const winnerSurface = raw.winner.surface\n  if (preparedCode) {\n    try {\n      await preparedCode.cleanup(winnerSurface)\n    } catch (cleanupCause) {\n      try {\n        await preparedCode.cleanup()\n      } catch (finalCleanupCause) {\n        throw new AggregateError(\n          [cleanupCause, finalCleanupCause],\n          'improve(): code result cleanup failed, including the final all-worktree retry',\n        )\n      }\n      throw new AggregateError(\n        [cleanupCause],\n        'improve(): code result cleanup failed; the final all-worktree retry succeeded',\n      )\n    }\n  }\n  const dispose = idempotentDispose(async () => preparedCode?.cleanup())\n  // When a skill DOCUMENT was optimized, the winner is document text — persist it\n  // via writeBack (the profile ref points at the caller's file, unchanged) rather\n  // than parsing it as a refs array. Otherwise use the standard field write-back.\n  const externalDocument =\n    surface === 'skills' && skills ? skills : surface === 'memory' && memory ? memory : undefined\n  if (shipped && externalDocument) {\n    if (typeof winnerSurface !== 'string') {\n      throw new ConfigError(\n        `improve(): the shipped '${surface}' winner must be text before it can be persisted`,\n      )\n    }\n    await externalDocument.writeBack?.(winnerSurface)\n  }\n  const nextProfile =\n    shipped && !externalDocument\n      ? applyImprovementWinnerToProfile(profile, surface, winnerSurface)\n      : profile\n\n  return {\n    profile: nextProfile,\n    shipped,\n    lift: raw.lift,\n    gateDecision: raw.gateDecision,\n    raw,\n    dispose,\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-WQA5Y6PD.js → chunk-EP6RVHMX.js}

@@ -255,7 +255,7 @@ function harnessInvocation(harness, profile, taskPrompt, options = {}) {
   if (reasoningEffort !== void 0 && invocation.reasoningArgs) {
     args.push(...invocation.reasoningArgs(reasoningEffort));
   }
-  return { command: invocation.command, args };
+  return { command: invocation.command, args, prompt: composedPrompt };
 }
 var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
 var processKillGraceMs = 250;
@@ -280,7 +280,7 @@ async function runLocalHarness(options) {
   const requestedCommand = options.invocation?.command ?? invocation.command;
   const args = options.invocation ? [...options.invocation.args] : buildHarnessArgs(harness, taskPrompt, options);
   if (options.codexReproducible) assertCodexReproducibleInvocation(requestedCommand, args);
-  const baseEnv = options.env ?? process.env;
+  const baseEnv = { ...options.env ?? process.env, PWD: cwd };
   const isolated = options.codexReproducible ? await isolateCodexHome({
     baseEnv,
     cwd,
@@ -1097,4 +1097,4 @@ export {
   runLocalHarness,
   parseCodexTokenUsage
 };
-//# sourceMappingURL=chunk-WQA5Y6PD.js.map
+//# sourceMappingURL=chunk-EP6RVHMX.js.map