@tangle-network/agent-runtime 0.103.1 → 0.105.0

package/dist/{improve-B40dRu0X.d.ts → redact-BuFjxBUJ.d.ts}

@@ -1,27 +1,14 @@
-import { LabeledScenarioStore, WorktreeAdapter, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
-import { Scenario, SelfImproveOptions, SurfaceProposer as SurfaceProposer$1, MutableSurface, SelfImproveResult } from '@tangle-network/agent-eval/contract';
-import { AgentProfile, ReasoningEffort } from '@tangle-network/agent-interface';
-import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionEvidence, b as LocalHarnessResult, r as runLocalHarness } from './local-harness-CtK9dSny.js';
+import { LabeledScenarioStore, WorktreeAdapter, OptimizationMethod, CompareOptimizationMethodsOptions, OptimizationMethodComparison } from '@tangle-network/agent-eval/campaign';
+import { MutableSurface, Scenario, SelfImproveResult, SelfImproveOptions, SelfImproveBudget } from '@tangle-network/agent-eval/contract';
+import { AgentProfile, ReasoningEffort, Sha256Digest } from '@tangle-network/agent-interface';
+import { L as LocalHarness, C as CodexTokenUsage, b as CodexExecutionEvidence, c as LocalHarnessResult, r as runLocalHarness } from './local-harness-BDNcl6jI.js';
 import { AnalystFinding, CostLedgerHandle, MaximumCharge } from '@tangle-network/agent-eval';
 
 /**
+ * Code-only candidate driver for Runtime-owned git worktrees.
  *
- * `improvementDriver` — the ONE reflective/agentic improvement proposer for
- * agent-eval's improvement loop. It implements `SurfaceProposer` and owns
- * the candidate lifecycle (worktree create → generate → finalize/discard,
- * × populationSize); it delegates the only thing that genuinely varies — HOW
- * a candidate change is produced — to a pluggable `CandidateGenerator`.
- *
- * There is no separate "analyst driver" vs "autoresearch driver": those are
- * the SAME driver at two settings of a dial.
- *   - cheap reflective path  → `reflectiveGenerator` (shots=1, no sandbox;
- *                              applies pre-drafted patches)
- *   - full agentic path      → `agenticGenerator` (shots=N, multi-shot
- *                              verify-in-session loop; an agent reads code +
- *                              report, edits, and re-tries on verifier failure)
- * Both emit changes into a worktree the driver finalizes into a
- * `CodeSurface{ worktreeRef }` the loop measures on the holdout. See
- * agent-eval's `docs/design/self-improvement-engine.md`.
+ * A `CandidateGenerator` edits an isolated checkout. This driver finalizes each
+ * accepted edit as a `CodeSurface` and disposes rejected worktrees.
  *
  * @experimental
  */
@@ -56,7 +43,7 @@ interface CandidateGenerator {
          *  reflective generator ignores it). */
         maxShots: number;
         signal: AbortSignal;
-        /** Improvement-loop coordinates. Present when called through improvementDriver. */
+        /** Generation coordinates supplied by Runtime's internal code candidate driver. */
         generation?: number;
         candidateIndex?: number;
         /** Shared run-wide paid-call account supplied by agent-eval 0.117+. */
@@ -75,24 +62,10 @@ interface CandidateGenerator {
         rationale?: string;
     }>;
 }
-interface ImprovementDriverOptions {
-    worktree: WorktreeAdapter;
-    generator: CandidateGenerator;
-    /** Root ref for first-generation/direct callers. Default `main`.
-     *  Later code generations retain the incumbent's original root. */
-    baseRef?: string;
-}
-interface ManagedImprovementDriver extends SurfaceProposer<AnalystFinding> {
-    /** Remove every owned candidate except explicitly retained finalized winners. */
-    cleanup(retainWorktreeRefs?: readonly string[]): Promise<void>;
-}
-/** The one reflective/agentic improvement proposer (`SurfaceProposer`): owns the candidate worktree lifecycle and delegates HOW a change is produced to a pluggable `CandidateGenerator`. */
-declare function improvementDriver(opts: ImprovementDriverOptions): ManagedImprovementDriver;
 
 /**
  *
- * `agenticGenerator` — the full-agentic `CandidateGenerator`: the
- * `shots=N, sandbox=on` setting of the one `improvementDriver`. It runs a real
+ * `agenticGenerator` — the full-agentic `CandidateGenerator`. It runs a real
  * coding harness (claude / codex / opencode) inside the candidate worktree the
  * driver already created, letting the agent read the codebase + the research
  * report and make the change in place. The driver then commits the worktree
@@ -107,7 +80,7 @@ declare function improvementDriver(opts: ImprovementDriverOptions): ManagedImpro
  * problem that does not need solving here).
  *
  * `maxShots` is the DEPTH dial — a multi-shot verify-in-session loop, NOT the
- * kernel `runLoop`. Each shot runs one full harness session in the (persistent)
+ * kernel `runAgentRounds`. Each shot runs one full harness session in the (persistent)
  * worktree; between shots the loop refines based on what the last shot produced:
  *   - empty tree   → "you changed nothing, make the edits" → retry
  *   - dirty + `verify` fails → feed the verifier's failure into the next shot
@@ -270,106 +243,113 @@ declare function defaultBuildPrompt(args: {
  *  silent fallback). */
 declare function commandVerifier(command: string, args?: string[], timeoutMs?: number): Verifier;
 
-/**
- *
- * `improve` — the ONE public, surface-pluggable RSI verb.
- *
- * A thin facade over agent-eval's `selfImprove` (the held-out-gated closed
- * loop). It removes the two things a caller otherwise has to know to drive the
- * loop by hand: WHICH `MutableSurface` of the profile is being optimized, and
- * WHICH `SurfaceProposer` mutates that surface. You name a `surface`; the
- * facade picks the matching default proposer, extracts the baseline surface from
- * the profile, and runs `selfImprove`. It returns a frozen candidate and never
- * changes the input profile or caller-owned state.
- *
- *   - `surface: 'prompt'` → `gepaProposer` mutates `profile.prompt.systemPrompt`.
- *   - `surface: 'skills'` → `skillOptProposer` mutates one named inline skill.
- *   - `surface: 'memory'` → `memoryCurationProposer` curates the profile's
- *     additional instructions as bounded durable lessons.
- *   - `surface: 'rollout-policy'` → `rolloutPolicyProposer` mutates the
- *     inference-time `StructuralRolloutPolicy` dials ({ k, repairRounds, testgen })
- *     persisted in `profile.extensions['structural-rollout']` — deterministic
- *     bounded neighbor enumeration; the held-out gate does the deciding. No-op
- *     (nothing proposed, nothing shipped) when the profile has no such extension.
- *   - `surface: 'agent-profile'` → caller-supplied proposer mutates the complete
- *     canonical AgentProfile JSON in one candidate.
- *   - `surface` ∈ {`tools`, `mcp`, `hooks`, `subagents`, `agent-profile`} → no zero-config default
- *     proposer exists (a code/config proposer needs caller-supplied wiring — a
- *     worktree repo root, a candidate generator, a serializer). The facade
- *     requires an explicit `opts.generator` for these and throws a `ConfigError`
- *     otherwise. This is a designed boundary, not a missing default: there is
- *     no safe value the facade could invent for those surfaces. Code instead
- *     requires `opts.code.repoRoot` and accepts only the runtime-owned
- *     `opts.code.generator` path so every isolated checkout can be released.
- *
- * Everything else (`scenarios`, `judge`, `agent`, `budget`, `llm`) passes
- * straight through to `selfImprove`.
- *
- * @experimental
- */
+type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer TItem)[] ? readonly DeepReadonly<TItem>[] : T extends object ? {
+    readonly [TKey in keyof T]: DeepReadonly<T[TKey]>;
+} : T;
+/** Complete immutable profile value used during measured execution. */
+type ReadonlyAgentProfile = DeepReadonly<AgentProfile>;
 
 /** The executable agent lever `improve` optimizes. Profile fields remain
- *  portable AgentProfile coordinates; implementation and orchestration files
- *  use the code surface so a winner can be sealed into an exact candidate.
- *  `rollout-policy` is the inference-time structuralRollout dials
- *  (`profile.extensions['structural-rollout']`). */
+ * portable AgentProfile coordinates; implementation and orchestration files
+ * use the code surface so a winner can be sealed into an exact candidate.
+ * `rollout-policy` is the inference-time structuralRollout dials
+ * (`profile.extensions['structural-rollout']`). */
 type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'subagents' | 'agent-profile' | 'memory' | 'code' | 'rollout-policy';
-type ImproveOptions<TScenario extends Scenario, TArtifact> = Omit<SelfImproveOptions<TScenario, TArtifact>, 'analyzeGeneration' | 'baselineSurface' | 'findings' | 'gate' | 'proposer'> & {
-    /** Which profile lever to optimize. Default `'prompt'`. Selects the default
-     *  generator + the baseline-surface extraction shape. */
-    surface?: ImproveSurface;
-    /** The `SurfaceProposer` that mutates a profile surface. When unset, the facade
-     *  picks the default for prompt, skills, and memory; surfaces
-     *  with no default REQUIRE this (fail-loud otherwise). Forbidden for code;
-     *  use `code.generator` so the runtime owns candidate cleanup. */
-    generator?: SurfaceProposer$1;
+type ImproveProfileSurface = Exclude<ImproveSurface, 'code'>;
+interface ImproveMethodContext {
+    /** Validated baseline profile. */
+    readonly profile: ReadonlyAgentProfile;
+    /** Runtime-derived identity for upstream optimizer resume state. */
+    readonly evaluationRef: Sha256Digest;
+    /** Exact profile coordinate being optimized. */
+    readonly surface: ImproveProfileSurface;
+    /** Exact bytes supplied to the optimization method. */
+    readonly baselineSurface: MutableSurface;
+    /** Structured value represented by `baselineSurface`, before serialization. */
+    readonly baselineValue: unknown;
+    /** Findings produced before this search, if any. */
+    readonly findings: readonly unknown[];
+}
+/** Build a complete method after trace findings are available. */
+type ImproveMethodFactory<TScenario extends Scenario, TArtifact> = (context: ImproveMethodContext) => OptimizationMethod<TScenario, TArtifact>;
+type ImproveMethodSource<TScenario extends Scenario, TArtifact> = OptimizationMethod<TScenario, TArtifact> | ImproveMethodFactory<TScenario, TArtifact>;
+/** Runs one exact materialized profile on one scenario. */
+type ImproveProfileAgent<TScenario extends Scenario, TArtifact> = (profile: ReadonlyAgentProfile, scenario: TScenario, ctx: Parameters<CompareOptimizationMethodsOptions<TScenario, TArtifact>['dispatchWithSurface']>[2]) => Promise<TArtifact>;
+/** Exact materialized profile presented for validation before any candidate run. */
+interface ImproveCandidateValidationInput {
+    profile: ReadonlyAgentProfile;
+    surface: ImproveProfileSurface;
+    candidateSurface: MutableSurface;
+    value: unknown;
+    isBaseline: boolean;
+}
+type ImproveCandidateValidator = (input: ImproveCandidateValidationInput) => void;
+type ImproveOptimizationRunOptions<TScenario extends Scenario, TArtifact> = Omit<NonNullable<CompareOptimizationMethodsOptions<TScenario, TArtifact>['optimizationRunOptions']>, 'dispatchRef'>;
+/** Complete-method configuration for every non-code profile surface. */
+type ImproveMethodOptions<TScenario extends Scenario, TArtifact> = Omit<CompareOptimizationMethodsOptions<TScenario, TArtifact>, 'baselineSurface' | 'dispatchRef' | 'dispatchWithSurface' | 'methods' | 'optimizationConcurrency' | 'optimizationRunOptions'> & {
+    /** Exact profile coordinate optimized by `method`. Default `'prompt'`. */
+    surface?: ImproveProfileSurface;
+    /**
+     * Immutable digest of `agent`, profile component mapping, models, tools, and
+     * every closure or external setting that can change measured behavior.
+     */
+    executionRef: Sha256Digest;
+    /** A complete optimizer or a factory that can incorporate current findings. */
+    method: ImproveMethodSource<TScenario, TArtifact>;
+    /** Runs the exact complete profile materialized from one candidate surface. */
+    agent: ImproveProfileAgent<TScenario, TArtifact>;
+    /** Reject a materialized profile before it reaches the agent callback. */
+    validateCandidate?: ImproveCandidateValidator;
+    /** Trace or analyst findings available to a method factory. */
+    findings?: readonly unknown[];
+    /** Select the exact inline skill document for `surface: 'skills'`. */
+    skills?: ImproveSkillsOptions;
+    /**
+     * Map a profile to named text components and apply the winning components.
+     * Valid only with `surface: 'agent-profile'`.
+     */
+    profileComponents?: ImproveProfileComponents;
+    /** Shared settings for method train and selection calls. */
+    optimizationRunOptions?: ImproveOptimizationRunOptions<TScenario, TArtifact>;
+    /** Ship only when the paired final-test interval is entirely above this lift. Default `0`. */
+    minimumLift?: number;
+};
+/** Runtime-owned code search in isolated git worktrees. */
+type ImproveCodeRunOptions<TScenario extends Scenario, TArtifact> = Omit<SelfImproveOptions<TScenario, TArtifact>, 'analyzeGeneration' | 'baselineSurface' | 'budget' | 'findings' | 'gate' | 'llm' | 'method' | 'mutationPrimitives' | 'proposer' | 'proposerTarget' | 'selectionScenarios'> & {
+    surface: 'code';
+    /** Local code-search budget. Method-only selection controls do not apply. */
+    budget?: Omit<SelfImproveBudget, 'selectionFraction'>;
+    /** Findings supplied to Runtime's code candidate driver. */
+    findings?: readonly unknown[];
     /** Gate mode. `'holdout'` (default) runs the held-out promotion gate;
-     *  `'none'` is a baseline-only run (`budget.generations = 0`). */
+     * `'none'` is a baseline-only run (`budget.generations = 0`). */
     gate?: 'holdout' | 'none';
-    /** Restrict the run to this subset of models. When set, the reflection model
-     *  (`llm.model`, or the default when unset) must be a member, or `improve()` throws
-     *  a `ConfigError` before the generator is built. Unset = unrestricted. */
-    allowedModels?: readonly string[];
-    /** Per-generation findings producer passthrough (see selfImprove.analyzeGeneration).
-     *  DEFAULT: with a real (non-`mem://`) `runDir`, the raw-trace distiller
-     *  (`rawTraceDistiller`) — typed `AnalystFinding`s pointing the proposer at the
-     *  prior generation's actual on-disk traces; for in-memory runs (no traces on
-     *  disk to point at), the built-in failure distiller — the worst-scoring/errored
-     *  cells distilled into typed `AnalystFinding`s for the NEXT proposal round.
-     *  Pass your own producer to replace either; pass `null` to disable and keep the
-     *  static `findings` all the way through. */
+    /** Per-generation findings producer for Runtime's code search.
+     * Pass your own producer to replace the code-trace distiller; pass `null`
+     * to keep the static findings for every generation. */
     analyzeGeneration?: SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration'] | null;
-    /** META-HARNESS mode: instead of the distilled findings, feed the proposer
-     *  RAW-TRACE FILESYSTEM CONTEXT — the PATHS into the prior generation's
-     *  real run traces under `runDir` (per-cell `spans.jsonl` event logs +
-     *  `cached-result.json` scores + artifacts) plus a `grep`/`cat`-to-diagnose
-     *  instruction — so the coding agent reads the actual failures itself rather than
-     *  a pre-summary. Unset (default): raw-trace findings whenever the run is durable
-     *  (a real `runDir` — that is where the traces live), the distilled failure digest
-     *  otherwise; the `memory` surface always defaults to its curation distiller.
-     *  `true` forces `rawTraceDistiller()` even for an in-memory run (it emits a loud
-     *  warning finding instead of paths); `false` forces the digest distiller even
-     *  with a real `runDir`. Ignored when `analyzeGeneration` is set explicitly
-     *  (that wins) or is `null` (disabled). */
+    /** Feed code candidates paths to prior raw traces instead of a failure digest.
+     * Defaults to true for durable runs and false for in-memory runs. */
     rawTraceContext?: boolean;
-    /** CODE-surface wiring: name `surface: 'code'`, point at a repo, and the
-     *  facade assembles the whole candidate pipeline — an isolated incumbent plus git worktrees
-     *  (`gitWorktreeAdapter`) driven by `improvementDriver` with the full agentic
-     *  generator (a real coding harness edits each candidate worktree; a `verify`
-     *  hook gates candidates before they are ever measured). Ignored when
-     *  `opts.generator` is supplied. Required for every code run because a real
-     *  repository and base ref are necessary to measure the incumbent. */
-    code?: ImproveCodeOptions;
-    /** Select the exact inline skill document to optimize. */
-    skills?: ImproveSkillsOptions;
+    /** Isolated repository and candidate generator settings. */
+    code: ImproveCodeOptions;
     /** Custom held-back-exam decision. The string `gate` above controls whether
-     *  the exam runs; this callback controls how its evidence decides promotion. */
+     * the exam runs; this callback controls how its evidence decides promotion. */
     promotionGate?: SelfImproveOptions<TScenario, TArtifact>['gate'];
 };
+/** The canonical improvement API: complete methods for profiles, worktrees for code. */
+type ImproveOptions<TScenario extends Scenario, TArtifact> = ImproveMethodOptions<TScenario, TArtifact> | ImproveCodeRunOptions<TScenario, TArtifact>;
 interface ImproveSkillsOptions {
     /** `name` of one inline entry in `profile.resources.skills`. */
     resourceName: string;
 }
+/** Caller-owned mapping for optimizing several profile fields as one candidate. */
+interface ImproveProfileComponents {
+    /** Extract the exact named text components optimized together. */
+    read(profile: ReadonlyAgentProfile): Readonly<Record<string, string>>;
+    /** Apply a complete winning component map to a detached profile. */
+    apply(profile: ReadonlyAgentProfile, components: Readonly<Record<string, string>>): ReadonlyAgentProfile;
+}
 interface ImproveCodeOptions {
     /** Repo root candidate worktrees fork from. */
     repoRoot: string;
@@ -378,57 +358,124 @@ interface ImproveCodeOptions {
     /** Directory worktrees are created under. Default `<repoRoot>/.worktrees`. */
     worktreeDir?: string;
     /** Git-compatible adapter override, primarily for tests. Candidate advancement
-     *  still requires normal Git worktree and commit semantics. */
+     * still requires normal Git worktree and commit semantics. */
     worktree?: WorktreeAdapter;
     /** Coding harness the agentic generator runs in each worktree. Default `claude`. */
     harness?: LocalHarness;
     /** Verify a candidate worktree before it becomes a measurable surface; failures
-     *  feed the next shot (see `agenticGenerator.verify` / `commandVerifier`). */
+     * feed the next shot (see `agenticGenerator.verify` / `commandVerifier`). */
     verify?: Verifier;
     /** Per-shot wall-clock timeout for the harness (ms). */
     timeoutMs?: number;
-    /** Byte-producer override — the test seam and the escape hatch for custom
-     *  candidate production. When set, `harness`/`verify`/`timeoutMs` are unused. */
+    /** Byte-producer override, used for tests and custom candidate production.
+     * When set, `harness`, `verify`, and `timeoutMs` are unused. */
     generator?: CandidateGenerator;
 }
-interface ImprovementCandidate {
+interface ImprovementProfileCandidate {
     /** Surface searched by this run. */
-    surface: ImproveSurface;
+    surface: ImproveProfileSurface;
     /** Exact winning value returned by agent-eval. */
     value: MutableSurface;
-    /** Detached profile candidate when the surface maps directly to AgentProfile. */
-    profile?: AgentProfile;
+    /** Exact complete profile instance measured on the final cases. */
+    profile: ReadonlyAgentProfile;
+}
+interface ImprovementCodeCandidate {
+    surface: 'code';
+    value: MutableSurface;
+    profile?: never;
+}
+type ImprovementCandidate = ImprovementProfileCandidate | ImprovementCodeCandidate;
+/** Normalized spend reported for one Runtime improvement run. */
+interface ImproveCost {
+    totalCostUsd: number;
+    accountingComplete: boolean;
+    incompleteReasons: string[];
+}
+/** Optimizer ancestry sealed into downstream candidate experiments. */
+interface ImproveLineage {
+    /** Unique Runtime invocation used to isolate this run's cost receipts. */
+    invocationId: string;
+    /** Upstream optimizer run when reported, otherwise this Runtime optimization invocation. */
+    runId: string;
+    /** Exact train-plus-selection scenario payloads exposed to candidate selection. */
+    developmentSplitDigest: Sha256Digest;
+    /** Complete callback, materializer, model, tool, and closure identity for a profile run. */
+    executionRef?: Sha256Digest;
+    /** Complete baseline profile identity for a profile run. */
+    baselineProfileDigest?: Sha256Digest;
 }
-interface ImproveResult<TScenario extends Scenario, TArtifact> {
+interface ImproveResultBase<TCandidate extends ImprovementCandidate> {
     /** Frozen candidate only. Live state is changed through an approved activation. */
-    candidate: ImprovementCandidate;
-    /** Held-out decision for this search result. */
-    decision: SelfImproveResult<TScenario, TArtifact>['gateDecision'];
-    /** Held-out lift (`winner − baseline` composite). Absent iff
-     *  `budget.holdout === 'deferred'` — no held-out measurement ran, so there
-     *  is no lift to report (never a fabricated 0). */
+    candidate: TCandidate;
+    /** Final-test decision for this search result. */
+    decision: SelfImproveResult<Scenario, unknown>['gateDecision'];
+    /** Final-test lift when one was measured. */
     lift?: number;
-    /** Full `selfImprove` result for advanced inspection. For code runs,
-     *  `raw.winner.surface.worktreeRef` remains live after return whether the
-     *  candidate passed or held; call `dispose()` after consuming it. */
-    raw: SelfImproveResult<TScenario, TArtifact>;
+    /** Paired final-test confidence interval for method-based profile runs. */
+    liftInterval?: {
+        low: number;
+        high: number;
+    };
+    /** Full search and final-test spend. */
+    cost: ImproveCost;
+    /** Full wall-clock duration. */
+    durationMs: number;
+    /** Optimizer ancestry used when sealing a candidate experiment. */
+    lineage: ImproveLineage;
+    /** Number of generations explored by Runtime's code path. */
+    generationsExplored?: number;
     /** Release resources owned by this result. Idempotent; currently disposes
-     *  the returned code worktree and is a no-op for profile-only surfaces. */
+     * the returned code worktree and is a no-op for profile-only surfaces. */
     dispose(): Promise<void>;
 }
+interface ImproveMethodResult extends ImproveResultBase<ImprovementProfileCandidate> {
+    mode: 'method';
+    method: string;
+    /** External optimizer package and resumable run identity, when reported. */
+    provenance?: OptimizationMethodComparison['best']['provenance'];
+    decision: 'ship' | 'hold';
+    lift: number;
+    liftInterval: {
+        low: number;
+        high: number;
+    };
+    raw: OptimizationMethodComparison;
+}
+interface ImproveCodeResult<TScenario extends Scenario, TArtifact> extends ImproveResultBase<ImprovementCodeCandidate> {
+    mode: 'code';
+    raw: SelfImproveResult<TScenario, TArtifact>;
+}
+type ImproveResult<TScenario extends Scenario, TArtifact> = ImproveMethodResult | ImproveCodeResult<TScenario, TArtifact>;
+
 /**
- * Run the held-out-gated self-improvement loop on ONE profile surface.
  *
- * @example Optimize the system prompt, default holdout gate:
+ * Redaction for values that may leave the Runtime process. The default scrubs
+ * common leak classes (API keys, bearer tokens, emails, private keys) from
+ * strings and walks nested objects and arrays. A customer with domain-specific
+ * PII supplies their own `redact` hook.
  *
- *   const out = await improve(profile, findings, {
- *     surface: 'prompt',
- *     scenarios,
- *     judge,
- *     agent: (surface, scenario, ctx) => runAgent(surface, scenario, ctx.signal),
- *   })
- *   if (out.decision === 'ship') console.log(out.candidate)
+ * This is intentionally narrower than `src/sanitize.ts` (which redacts the
+ * runtime's *event envelope* field-by-field): here the value is opaque
+ * customer payload, so the scrub is value-shaped, not schema-shaped.
+ *
+ * @experimental
+ */
+/** A redactor maps an arbitrary trace value to a safe-to-export value. Pure;
+ *  must not throw on cyclic input (the default tolerates cycles). */
+type Redactor = (value: unknown) => unknown;
+/**
+ * The built-in redactor. Walks objects and arrays; replaces values under
+ * secret-bearing keys wholesale; scrubs in-value patterns from every string.
+ * Cycle-safe (a seen-set short-circuits self-referential payloads to
+ * `'[circular]'`), depth-bounded, and total — never throws on customer input.
+ */
+declare function defaultRedactor(value: unknown): unknown;
+/**
+ * Resolve the redactor a client uses. A caller-supplied hook handles
+ * domain-specific values first, then the built-in scrubber still removes
+ * common credentials and email addresses. Returning `false` is the explicit
+ * opt-out for already-reviewed public values.
  */
-declare function improve<TScenario extends Scenario, TArtifact>(profile: AgentProfile, findings: unknown[], opts: ImproveOptions<TScenario, TArtifact>): Promise<ImproveResult<TScenario, TArtifact>>;
+declare function resolveRedactor(redact: Redactor | false | undefined): Redactor;
 
-export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImproveOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type ImproveResult as a, type AgenticGeneratorOptions as b, type AgenticGeneratorShotDisposition as c, type AgenticGeneratorShotExecution as d, type AgenticGeneratorShotReceipt as e, type ImproveCodeOptions as f, type ImproveSkillsOptions as g, type ImproveSurface as h, type ImprovementCandidate as i, type ImprovementDriverOptions as j, type VerifyResult as k, agenticGenerator as l, commandVerifier as m, defaultBuildPrompt as n, improve as o, improvementDriver as p };
+export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type ImprovementCandidate as B, type CandidateGenerator as C, type DeepReadonly as D, type ImprovementCodeCandidate as E, type ImprovementProfileCandidate as F, type VerifyResult as G, agenticGenerator as H, type ImproveOptions as I, commandVerifier as J, defaultBuildPrompt as K, type Redactor as R, type Verifier as V, type ImproveResult as a, type ImproveMethodResult as b, type ImproveMethodOptions as c, defaultRedactor as d, type ImproveCodeRunOptions as e, type ImproveCodeResult as f, type ImproveCandidateValidationInput as g, type ImproveMethodFactory as h, type ReadonlyAgentProfile as i, type AgenticGeneratorOptions as j, type AgenticGeneratorShotDisposition as k, type AgenticGeneratorShotExecution as l, type AgenticGeneratorShotReceipt as m, type ImproveCandidateValidator as n, type ImproveCodeOptions as o, type ImproveCost as p, type ImproveLineage as q, resolveRedactor as r, type ImproveMethodContext as s, type ImproveMethodSource as t, type ImproveOptimizationRunOptions as u, type ImproveProfileAgent as v, type ImproveProfileComponents as w, type ImproveProfileSurface as x, type ImproveSkillsOptions as y, type ImproveSurface as z };

package/dist/{structural-rollout-BFPIy3iw.d.ts → structural-rollout-DEh6CEsa.d.ts}

@@ -1,6 +1,6 @@
-import { R as RuntimeHooks, a as SelectionReceipt } from './types-DK11_O4L.js';
-import { C as Corpus, O as Outcome } from './worktree-fanout-DiiJWjJO.js';
-import { A as Agent, B as Budget, S as Scope } from './types-lZTE_LBd.js';
+import { R as RuntimeHooks, S as SelectionReceipt } from './types-BCoemcXU.js';
+import { C as Corpus, O as Outcome } from './worktree-fanout-DxhAWr5Z.js';
+import { A as Agent, B as Budget, S as Scope } from './types-CvNwMzQt.js';
 
 /**
  * The general agentic primitive — sequential (depth) and parallel (breadth) over a shared,
@@ -266,7 +266,7 @@ declare function runAgentic(opts: RunAgenticOptions): Promise<AgenticRunResult>;
  *    poison repair at saturation — the glm /47,/116 regressions).
  *
  * Placement rule: this is an INFERENCE-TIME capability (it wraps the model call via the
- * strategy seam). It does not belong in improve()/selfImprove (training-time); improve()
+ * strategy seam). It does not belong in `improve()` (training-time); `improve()`
  * may later tune `StructuralRolloutPolicy` as an optimizable surface.
  */
 

package/dist/{supervise-Cp8bNcJi.d.ts → supervise-4_48wwvy.d.ts}

@@ -1,7 +1,7 @@
-import { W as WorkerProgress, S as Scope, a as Settled, b as ResultBlobStore, B as Budget, A as Agent, c as SpawnJournal, d as WaitProbeRegistry, e as SupervisedResult } from './types-lZTE_LBd.js';
-import { M as MakeWorkerAgent, A as AnalystRegistry, W as WorkerWatchOptions, E as ExecutorConfig } from './coordination-DTehA977.js';
+import { W as WorkerProgress, S as Scope, a as Settled, b as ResultBlobStore, B as Budget, A as Agent, c as SpawnJournal, d as WaitProbeRegistry, e as SupervisedResult } from './types-CvNwMzQt.js';
+import { M as MakeWorkerAgent, A as AnalystRegistry, W as WorkerWatchOptions, E as ExecutorConfig } from './coordination-BZZSVYpZ.js';
 import { R as RouterConfig, T as ToolLoopChat, a as ToolLoopCompactionOptions } from './sanitize-DEbPNtyI.js';
-import { D as DeliverableSpec } from './completion-gate-DLINnrkM.js';
+import { D as DeliverableSpec } from './completion-gate-BMy5LGoP.js';
 
 /**
  *

package/dist/testing.js

@@ -1,10 +1,10 @@
 import {
   verifyAgentImprovementProposal
-} from "./chunk-LFM4JBRW.js";
-import "./chunk-SBTWKPVR.js";
-import "./chunk-QYCKIV6C.js";
+} from "./chunk-UHEZW5BU.js";
+import "./chunk-WSTRQZYQ.js";
+import "./chunk-YJZA2BIK.js";
 import "./chunk-UPWGXKXB.js";
-import "./chunk-6WZZXQV5.js";
+import "./chunk-HLKC4UYB.js";
 import "./chunk-ISPWRSEC.js";
 import "./chunk-3MDZX7YU.js";
 import "./chunk-FD2MBMOH.js";
@@ -14,7 +14,7 @@ import "./chunk-YEJR7IXO.js";
 // src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
   changedSurfaces: ["prompt"],
-  digest: "sha256:e62706513d285835a6a447f33ee158ea2d6c3ce59cccd0ddf7029d3270ce083e",
+  digest: "sha256:1f223831184b2b53fe1be2b950a63856acb5abe887e5022a6114b5165a4f1802",
   evaluation: {
     decision: {
       contributingChecks: [
@@ -2486,7 +2486,7 @@ var agent_improvement_proposal_default = {
     ],
     metadata: {
       fixture: "agent-improvement-proposal",
-      runtimeVersion: "0.103.1"
+      runtimeVersion: "0.105.0"
     },
     objectives: [
       {
@@ -2597,8 +2597,8 @@ var agent_improvement_proposal_default = {
       baselineContentHash: "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
       candidateContentHash: "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
       kind: "agent-eval-loop",
-      recordDigest: "sha256:349ce5f4eed607ee58b901b239696c5b3b64d39d76f79b97c0910cc512336377",
-      runId: "agent-runtime-0.103.1-proposal-fixture",
+      recordDigest: "sha256:0e732c488490a383c61f092698759f8a32979f739b3e3689bf6466fb8fb10c3b",
+      runId: "agent-runtime-0.105.0-proposal-fixture",
       schema: "agent-candidate-experiment"
     }
   },
@@ -2624,7 +2624,7 @@ var agent_improvement_proposal_default = {
   ],
   kind: "agent-improvement-proposal",
   proposedAt: "2026-07-10T01:00:00.000Z",
-  runId: "agent-runtime-0.103.1-proposal-fixture"
+  runId: "agent-runtime-0.105.0-proposal-fixture"
 };
 
 // src/testing/index.ts