@tangle-network/agent-runtime 0.104.0 → 0.106.0

package/dist/environment-provider.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/improve--2A0gK1-.d.ts

@@ -1,440 +0,0 @@
-import { LabeledScenarioStore, WorktreeAdapter, SurfaceProposer, ProfileDispatchFn } 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 { AnalystFinding, CostLedgerHandle, MaximumCharge } from '@tangle-network/agent-eval';
-
-/**
- *
- * `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`.
- *
- * @experimental
- */
-
-/** The byte-producing seam — the ONE thing that differs between the cheap
- *  reflective path and the full agentic path. A generator makes (uncommitted)
- *  changes inside `worktreePath`; the driver commits them via the worktree
- *  adapter's `finalize`. */
-interface CandidateGenerator {
-    kind: string;
-    /** Whether this generator can produce a candidate from an EMPTY findings set
-     *  and no phase-2 report — i.e. it draws its change signal from the repo and
-     *  the raw-trace filesystem context on disk, not only from pre-summarized
-     *  findings. An agentic coder (`agenticGenerator`) sets this: the seed repo +
-     *  raw traces ARE the signal, so it must still run the full `populationSize`
-     *  when the distiller yielded nothing (this is the meta-harness contract — the
-     *  agent diagnoses from the raw traces itself). A patch-applier
-     *  (`reflectiveGenerator`) leaves it unset — with no findings there is no
-     *  patch to draft, so the driver short-circuits rather than spin up worktrees
-     *  for a guaranteed no-op. Default `false`. */
-    proposesWithoutFindings?: boolean;
-    generate(args: {
-        /** The candidate worktree — a clean checkout of the current incumbent. */
-        worktreePath: string;
-        /** Phase-2 research report (analyst findings + diff), opaque. */
-        report: unknown;
-        /** Findings resolved from the report or the loop context. */
-        findings: AnalystFinding[];
-        /** Handle to all captured data, to ground the change. */
-        dataset?: LabeledScenarioStore;
-        /** DEPTH: max iterations the generator may take (agentic uses this; the
-         *  reflective generator ignores it). */
-        maxShots: number;
-        signal: AbortSignal;
-        /** Improvement-loop coordinates. Present when called through improvementDriver. */
-        generation?: number;
-        candidateIndex?: number;
-        /** Shared run-wide paid-call account supplied by agent-eval 0.117+. */
-        costLedger?: CostLedgerHandle;
-        /** Receipt attribution phase supplied alongside `costLedger`. */
-        costPhase?: string;
-    }): Promise<{
-        applied: boolean;
-        summary: string;
-        /** Short slug for the candidate. When present (with `rationale`), the
-         *  driver returns a `ProposedCandidate` wrapper so the label survives to
-         *  `GenerationRecord` and the emitted provenance. */
-        label?: string;
-        /** Why this change was proposed — bounded, derived from the findings the
-         *  shot addressed. Paired with `label`. */
-        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
- * 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
- * into a `CodeSurface`.
- *
- * Mechanism: identical to the proven Phase-2.8 in-process executor — spawn the
- * harness as a subprocess with `cwd` = the worktree, on the same filesystem,
- * so edits land in place (no sandbox-mount round-trip). `runLocalHarness` is
- * the verified primitive. The OUTER sandbox is the improvement loop's own
- * execution context; the generator does not nest a second sandbox per
- * candidate (which would reintroduce a host↔sandbox worktree-transport
- * problem that does not need solving here).
- *
- * `maxShots` is the DEPTH dial — a multi-shot verify-in-session loop, NOT the
- * 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
- *       (the worktree persists, so the harness RESUMES atop its own failing
- *       edits with the error in hand — no `--resume` session plumbing needed,
- *       and harness-agnostic across claude/codex/opencode)
- *   - dirty + `verify` ok (or no verifier configured) → return the candidate
- * A candidate that never verifies within `maxShots` is discarded (`applied:
- * false`), never shipped — if you configured a verifier, a non-passing tree is
- * not a candidate. With no verifier the legacy behavior holds: first dirty shot
- * is the candidate.
- *
- * @experimental
- */
-
-/** Dedicated ephemeral root for generic author-profile files. Every declared
- * file must live below this root so cleanup cannot alter candidate-owned files. */
-declare const AGENTIC_PROFILE_RESOURCE_ROOT = ".agent-runtime-profile-resources";
-/** Outcome of verifying a candidate worktree. `feedback` (compiler errors,
- *  failing test output) is fed into the next shot when `ok` is false. */
-interface VerifyResult {
-    ok: boolean;
-    feedback?: string;
-}
-/** Verifies the edited worktree. Sync or async; throws only on a setup fault
- *  (a candidate that fails verification returns `{ok:false}`, it does not
- *  throw). */
-type Verifier = (worktreePath: string, signal?: AbortSignal) => Promise<VerifyResult> | VerifyResult;
-interface AgenticGeneratorShotReceipt {
-    readonly generation: number | null;
-    readonly candidateIndex: number | null;
-    /** One-based shot number within this candidate. */
-    readonly shot: number;
-    readonly maxShots: number;
-    readonly harness: LocalHarness;
-    readonly model: string | null;
-    readonly reasoningEffort: ReasoningEffort | null;
-    readonly promptSha256: `sha256:${string}`;
-    readonly startedAt: string;
-    readonly completedAt: string;
-    readonly durationMs: number;
-    readonly exitCode: number | null;
-    readonly timedOut: boolean;
-    /** True when caller cancellation reached the author process; absent in older receipts. */
-    readonly aborted?: boolean;
-    readonly killedBySignal: NodeJS.Signals | null;
-    readonly stdoutBytes: number | null;
-    readonly stdoutSha256: `sha256:${string}` | null;
-    readonly stderrBytes: number | null;
-    readonly stderrSha256: `sha256:${string}` | null;
-    readonly usage: CodexTokenUsage | null;
-    /** Digest of the exact profile-file workspace plan applied for this shot. */
-    readonly profileWorkspacePlanDigest: string | null;
-    readonly profileWorkspaceFileCount: number;
-    /** Shared run-ledger call id for this exact shot. */
-    readonly costCallId: string | null;
-    /** Whether dollars came from the provider, the pricing table, or are unknown. */
-    readonly costBasis: 'provider-reported' | 'estimated-pricing' | 'unknown';
-    readonly costUsd: number | null;
-    /** True only for a provider-reported amount, never for a pricing estimate. */
-    readonly costUsdKnown: boolean;
-    readonly evidence: CodexExecutionEvidence | null;
-    readonly error: {
-        readonly name: string;
-        readonly message: string;
-    } | null;
-}
-/** Frozen exact harness result for an author shot: full streams, process state,
- *  token usage, and execution-policy evidence.
- *  The `onShotCompleted` callback receives `null` when execution failed before
- *  the harness returned. */
-type AgenticGeneratorShotExecution = Readonly<Omit<LocalHarnessResult, 'usage' | 'evidence'> & {
-    readonly usage?: Readonly<CodexTokenUsage>;
-    readonly evidence?: Readonly<Omit<CodexExecutionEvidence, 'readDeniedPaths' | 'policy'>> & {
-        readonly readDeniedPaths: ReadonlyArray<string>;
-        readonly policy: Readonly<CodexExecutionEvidence['policy']>;
-    };
-}>;
-/** Worktree decision emitted before a completed shot is retried, accepted, or
- *  discarded. The callback runs while `worktreePath` is still available, so
- *  callers can persist the exact diff. */
-type AgenticGeneratorShotDisposition = {
-    readonly kind: 'clean';
-    readonly worktreePath: string;
-} | {
-    readonly kind: 'rejected';
-    readonly worktreePath: string;
-    readonly stage: 'raw-trace-evidence' | 'verification';
-    readonly feedback: string | null;
-} | {
-    readonly kind: 'accepted';
-    readonly worktreePath: string;
-    readonly verified: boolean;
-} | {
-    readonly kind: 'setup-error';
-    readonly worktreePath: string;
-    readonly stage: 'worktree-inspection' | 'raw-trace-evidence' | 'verification';
-    readonly error: {
-        readonly name: string;
-        readonly message: string;
-    };
-};
-interface AgenticGeneratorOptions {
-    /** Local coding harness to run in the worktree. Default `claude`. */
-    harness?: LocalHarness;
-    /** Author profile rendered through the canonical harness mapper. Required
-     *  for reproducible Codex so model and reasoning settings are explicit. */
-    profile?: AgentProfile;
-    /** Run Codex with isolated configuration, exact prompt evidence, and required
-     *  terminal token usage. Requires `harness: 'codex'` and `profile`. */
-    codexReproducible?: boolean;
-    /** Absolute paths reproducible Codex must not read. A function can derive
-     *  candidate-specific paths after the driver creates its worktree. */
-    codexReadDeniedPaths?: ReadonlyArray<string> | ((worktreePath: string) => ReadonlyArray<string>);
-    /** Awaited once for every attempted author shot, including process failures.
-     *  The second argument preserves the exact harness result, including stdout
-     *  and stderr, before worktree inspection or verification can reject the
-     *  shot. Throwing aborts the candidate so evidence persistence fails closed. */
-    onShotCompleted?: (receipt: AgenticGeneratorShotReceipt, execution: AgenticGeneratorShotExecution | null) => void | Promise<void>;
-    /** Awaited after worktree inspection and before the shot is accepted,
-     *  retried, or discarded. Throwing aborts the candidate. */
-    onShotDisposition?: (receipt: AgenticGeneratorShotReceipt, disposition: AgenticGeneratorShotDisposition) => void | Promise<void>;
-    /** Optional hard upper bound passed to the run-wide CostLedger before each
-     *  author shot. This MUST be enforced by the provider or executor; a planning
-     *  estimate is not an admissible bound. Omit for an uncapped ledger. A capped
-     *  ledger rejects before model dispatch when this is absent. */
-    maximumCharge?: MaximumCharge;
-    /** Per-shot wall-clock timeout (ms). Default = `runLocalHarness` default (5m). */
-    timeoutMs?: number;
-    /** Build the harness task prompt from the report + findings. Override for
-     *  domain phrasing; the default turns findings into a concrete coder task. */
-    buildPrompt?: (args: {
-        report: unknown;
-        findings: AnalystFinding[];
-    }) => string;
-    /** Verify the worktree after each dirtying shot. When set, a candidate that
-     *  fails verification is NOT returned — the failure feeds the next shot
-     *  (verify-in-session), up to `maxShots`; a candidate that never verifies is
-     *  discarded (`applied:false`), never shipped. Omitted ⇒ legacy behavior:
-     *  the first dirty shot is the candidate. See `commandVerifier`. */
-    verify?: Verifier;
-    /** Test seam — inject the harness runner (defaults to `runLocalHarness`). */
-    runHarness?: typeof runLocalHarness;
-    /** Test seam — inject the worktree-dirty check (defaults to `git status`). */
-    isDirty?: (worktreePath: string) => boolean;
-}
-/** Full-agentic `CandidateGenerator` (the `shots=N, sandbox=on` setting): run a real coding harness inside the candidate worktree so the agent makes the change in place. */
-declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGenerator;
-/** Turn the analyst's findings (+ optional report) into a concrete coder task —
- *  the senior scientific-method framing shared with the tool/MCP build prompts. */
-declare function defaultBuildPrompt(args: {
-    report: unknown;
-    findings: AnalystFinding[];
-}): string;
-/** A `Verifier` that runs a command in the worktree: exit 0 ⇒ ok, any other
- *  exit ⇒ failed with stdout+stderr as feedback. The common case — verify by
- *  `tsc --noEmit`, `pnpm build`, or a test command. A timeout is treated as a
- *  FAILED candidate (a change that hangs the build is a bad change); a missing
- *  binary or spawn fault throws (a setup bug, not a failed candidate — no
- *  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
- */
-
-/** 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']`). */
-type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'subagents' | 'agent-profile' | 'memory' | 'code' | 'rollout-policy';
-interface ImproveOptions<TScenario extends Scenario, TArtifact> extends Omit<SelfImproveOptions<TScenario, TArtifact>, 'agent' | 'analyzeGeneration' | 'baselineSurface' | 'findings' | 'gate' | 'proposer'> {
-    /** Dispatch the mutable surface directly when the host already owns that seam.
-     * Exactly one of `agent` or `profileDispatch` is required. */
-    agent?: SelfImproveOptions<TScenario, TArtifact>['agent'];
-    /** Dispatch each baseline or candidate as its complete AgentProfile.
-     * Exactly one of `agent` or `profileDispatch` is required. */
-    profileDispatch?: ProfileDispatchFn<TScenario, TArtifact>;
-    /** 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;
-    /** Gate mode. `'holdout'` (default) runs the held-out promotion gate;
-     *  `'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. */
-    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). */
-    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;
-    /** Custom held-back-exam decision. The string `gate` above controls whether
-     *  the exam runs; this callback controls how its evidence decides promotion. */
-    promotionGate?: SelfImproveOptions<TScenario, TArtifact>['gate'];
-}
-interface ImproveSkillsOptions {
-    /** `name` of one inline entry in `profile.resources.skills`. */
-    resourceName: string;
-}
-interface ImproveCodeOptions {
-    /** Repo root candidate worktrees fork from. */
-    repoRoot: string;
-    /** Base ref candidates fork from. Default `main`. */
-    baseRef?: string;
-    /** 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. */
-    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`). */
-    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. */
-    generator?: CandidateGenerator;
-}
-interface ImprovementCandidate {
-    /** Surface searched by this run. */
-    surface: ImproveSurface;
-    /** Exact winning value returned by agent-eval. */
-    value: MutableSurface;
-    /** Detached profile candidate when the surface maps directly to AgentProfile. */
-    profile?: AgentProfile;
-}
-interface ImproveResult<TScenario extends Scenario, TArtifact> {
-    /** 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). */
-    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>;
-    /** Release resources owned by this result. Idempotent; currently disposes
-     *  the returned code worktree and is a no-op for profile-only surfaces. */
-    dispose(): Promise<void>;
-}
-/**
- * Run the held-out-gated self-improvement loop on ONE profile surface.
- *
- * @example Optimize the system prompt, default holdout gate:
- *
- *   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)
- */
-declare function improve<TScenario extends Scenario, TArtifact>(profile: AgentProfile, findings: unknown[], opts: ImproveOptions<TScenario, TArtifact>): Promise<ImproveResult<TScenario, TArtifact>>;
-
-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 };

package/dist/improvement-adapter-HAZz-7vK.d.ts

@@ -1,203 +0,0 @@
-import { FindingSubject, AnalystFinding } from '@tangle-network/agent-eval';
-import { I as ImprovementProposalSource } from './types-CmYCMbFT.js';
-
-/**
- * `AgentSurfaces` — declarative map of the mutable file/directory paths
- * the self-improvement loop can edit on behalf of an agent.
- *
- * The substrate uses this map to resolve every parsed `FindingSubject`
- * (from agent-eval) to a real on-disk path. No per-vertical glue;
- * no fabricated paths; no silent `existsSync(...)` skips that hide
- * misconfiguration from the operator.
- *
- * Surfaces are validated at `defineAgent` time — missing paths fail
- * loud with a list of every offender. A surface that's not needed
- * (e.g. an agent with no RAG corpora) is simply omitted; the loop
- * refuses to route those subjects rather than fabricating a target.
- */
-
-/**
- * Surface declarations. Every path is repo-relative (or absolute) at
- * `defineAgent` time. At resolution time, paths are joined against the
- * agent's `repoRoot`.
- *
- * `systemPrompt`, `tools`, `personas` are DIRECTORIES; the loop appends
- * `<section>.md`, `<tool>/README.md`, `<persona-id>.yaml` etc.
- * `rubric`, `outputSchema` are SINGLE FILES; the loop edits them in
- * place.
- *
- * `knowledge` is the agent-knowledge root (typically `.agent-knowledge`);
- * `applyKnowledgeWriteBlocks` writes pages relative to it.
- *
- * Optional surfaces (`scaffolding`, `memory`, `rag`, `outputSchema`)
- * can be omitted — the loop will reject findings targeting them with a
- * clear log message instead of fabricating a path.
- */
-interface AgentSurfaces {
-    /** Directory containing one markdown file per system-prompt section. */
-    systemPrompt: string;
-    /** Directory containing one subdir per tool (`<tool>/README.md`). */
-    tools: string;
-    /** Single file (TypeScript module) defining the rubric weights + dimensions. */
-    rubric: string;
-    /** Knowledge-base root; typically `.agent-knowledge`. */
-    knowledge: string;
-    /** Directory containing one YAML/JSON file per persona. */
-    personas: string;
-    /** Optional: directory containing scaffolding rules (precondition checks, retry policies). */
-    scaffolding?: string;
-    /** Optional: memory store path (JSONL / SQLite / DB). */
-    memory?: string;
-    /** Optional: directory containing RAG corpora (`<corpus>/<doc-id>.md`). */
-    rag?: string;
-    /** Optional: single file defining the output schema (Zod / JSON Schema). */
-    outputSchema?: string;
-    /** Optional: directory containing Agent Skill packages. */
-    skills?: string;
-    /** Optional: directory containing MCP server/tool configuration. */
-    mcp?: string;
-    /** Optional: directory containing hook definitions. */
-    hooks?: string;
-    /** Optional: directory containing subagent definitions. */
-    subagents?: string;
-    /** Optional: directory containing orchestration/workflow policies. */
-    workflows?: string;
-    /** Optional: single file containing rollout-policy settings. */
-    rolloutPolicy?: string;
-    /** Optional: single canonical AgentProfile file. */
-    agentProfile?: string;
-    /** Optional: source root for code findings. */
-    code?: string;
-}
-interface ResolvedSurface {
-    /** Absolute filesystem path the operator can `cat` / `vim`. */
-    absolutePath: string;
-    /** Repo-relative path for PR descriptions, diffs, audit logs. */
-    repoRelativePath: string;
-    /** Whether the path currently exists on disk. */
-    exists: boolean;
-    /** The substrate's intent: edit an existing file or create a new one. */
-    intent: 'edit-existing' | 'create-new';
-}
-/**
- * Resolve a parsed `FindingSubject` to the file path the substrate
- * should edit (or create) on disk.
- *
- * Returns `null` when:
- *   - the subject targets a surface the agent didn't declare
- *     (e.g. `rag:*` when `surfaces.rag` is undefined), OR
- *   - the subject is a `cluster` (failure-mode emits these as evidence,
- *     not actionable mutations — they don't route to a file).
- *
- * Returns a `ResolvedSurface` with `intent: 'create-new'` when the
- * subject names a path that doesn't yet exist (e.g. a new wiki page).
- * The caller chooses whether to honour the create — for tightly-managed
- * surfaces like `systemPrompt` it's usually a contract violation
- * (the analyst named a section that doesn't exist); for `knowledge`
- * it's the whole point.
- */
-declare function resolveSubjectPath(subject: FindingSubject, surfaces: AgentSurfaces, repoRoot: string): ResolvedSurface | null;
-/**
- * Validate that every declared surface exists on disk under `repoRoot`.
- *
- * Returns an array of `SurfaceValidationIssue` — empty when all required
- * surfaces resolve. `defineAgent` throws with the issues rendered, so
- * a misconfigured manifest fails at startup (not at the first finding
- * the loop produces 20 minutes later).
- */
-interface SurfaceValidationIssue {
-    surface: keyof AgentSurfaces;
-    path: string;
-    reason: 'missing' | 'not-directory' | 'not-file';
-}
-/** Validate an `AgentSurfaces` map on disk — missing paths fail loud at `defineAgent` time instead of silently skipping self-improvement edits. */
-declare function validateSurfaces(surfaces: AgentSurfaces, repoRoot: string): ReadonlyArray<SurfaceValidationIssue>;
-/** Format a list of surface validation issues into a human-readable error string. */
-declare function renderSurfaceIssues(issues: ReadonlyArray<SurfaceValidationIssue>, repoRoot: string): string;
-
-/**
- * Surface improvement proposer — resolves analyst findings into LLM-drafted
- * candidate patches without changing the caller's repository.
- *
- * The proposer parses each finding's `subject` via
- * `parseFindingSubject` (agent-eval), resolves it to a real file path
- * via the agent's `AgentSurfaces`, reads the current content, and asks
- * an LLM to draft a unified-diff patch given the finding + current
- * content + per-kind editing-discipline rules.
- *
- * Fail-loud rules:
- *   - Findings whose subject doesn't parse → counted in `errors`.
- *   - Findings whose subject targets an undeclared surface → counted in
- *     `errors` with the offending kind in the message.
- *   - Findings whose target path doesn't exist AND the kind isn't a
- *     create-new variant (`new-tool`, `knowledge.wiki`) → counted in
- *     `errors` with the resolved path in the message.
- *   - LLM drafts that fail JSON-schema validation → counted in
- *     `errors` with the schema issue.
- *
- * No silent skips. Every dropped finding has a recorded reason the
- * loop's report surfaces.
- */
-
-interface SurfaceImprovementEdit {
-    /** Stable id derived from the source finding so re-proposals are idempotent. */
-    id: string;
-    /** The finding that produced this edit — for revert + audit trail. */
-    sourceFindingId: string;
-    /** Parsed subject; included so the apply step doesn't re-parse. */
-    subject: FindingSubject;
-    /** Resolved on-disk target. */
-    target: ResolvedSurface;
-    /** SHA-256 of the current file content the patch was drafted against. */
-    baseSha256: string;
-    /** Unified-diff patch the LLM drafted (relative to `target.absolutePath`). */
-    patch: string;
-    /** One-line summary the operator sees in the report / PR title. */
-    summary: string;
-    /** Multi-line rationale for the PR body — finding context + LLM reasoning. */
-    rationale: string;
-    /** Carry-forward from the finding so the apply gate can check the threshold. */
-    confidence: number;
-    /** Carry-forward severity for prioritization. */
-    severity: AnalystFinding['severity'];
-}
-interface CreateSurfaceImprovementProposerOptions {
-    surfaces: AgentSurfaces;
-    repoRoot: string;
-    /**
-     * LLM-draft callback. Given a finding + current file content + the
-     * resolved target, returns a unified-diff patch + summary + rationale.
-     *
-     * Required — the substrate doesn't ship a hardcoded prompt; the agent
-     * author picks the model (Haiku for cheap routine drafts, Sonnet for
-     * substantive prompt rewrites, etc.) via this callback.
-     */
-    draftPatch: (input: DraftPatchInput) => Promise<DraftPatchOutput>;
-    /**
-     * When the resolved target doesn't exist, allow the substrate to
-     * CREATE the file (for `knowledge.wiki`, `new-tool` subjects). Default
-     * true for those kinds, false for `system-prompt` / `rubric` / etc.
-     * (named sections that don't exist are a contract violation, not a
-     * scaffolding opportunity).
-     */
-    allowCreateForKinds?: ReadonlyArray<FindingSubject['kind']>;
-}
-interface DraftPatchInput {
-    finding: AnalystFinding;
-    subject: FindingSubject;
-    target: ResolvedSurface;
-    /** Current file content (empty string when `intent === 'create-new'`). */
-    currentContent: string;
-}
-interface DraftPatchOutput {
-    /** Unified diff against the current file content. Empty string skips this finding. */
-    patch: string;
-    /** One-line summary for the operator. */
-    summary: string;
-    /** Multi-line rationale for the PR body. */
-    rationale: string;
-}
-/** Resolve each finding to a real surface and draft a detached patch candidate. */
-declare function createSurfaceImprovementProposer(opts: CreateSurfaceImprovementProposerOptions): ImprovementProposalSource<SurfaceImprovementEdit>;
-
-export { type AgentSurfaces as A, type CreateSurfaceImprovementProposerOptions as C, type DraftPatchInput as D, type ResolvedSurface as R, type SurfaceImprovementEdit as S, type DraftPatchOutput as a, type SurfaceValidationIssue as b, createSurfaceImprovementProposer as c, resolveSubjectPath as d, renderSurfaceIssues as r, validateSurfaces as v };

package/dist/knowledge.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}