@tangle-network/agent-runtime 0.266.0 → 0.273.3

package/dist/durable.d.ts

@@ -1,7 +1,5 @@
-import { I as ProviderModelExecutionEvidence, J as RootStreamReceipt, P as ProfileMaterializationReceipt, Pn as RetainedPendingCause, U as RetainedExecutionState, at as SpendGap, i as Budget, j as NodeId, l as ExecutionBindingReceipt, lt as SupervisedResult, n as AgentExecutionRef, o as BudgetViolation, rt as Spend, xt as WorkerTraceEvidence, y as ExecutorProgressEvent } from "./types-CrnwLVYQ.js";
-import { Xa as SuperviseOptions, eo as supervise, wo as SupervisorProfile } from "./index-CU2mlMfc.js";
-import { l as RuntimeHooks, o as RuntimeHookEvent, r as RuntimeDecisionPoint } from "./runtime-hooks-Bj6wJHlH.js";
-import { AgentCandidateLineage, AgentProfile, AgentProfileDiff, Sha256Digest } from "@tangle-network/agent-interface";
+import { J as RootStreamReceipt, j as NodeId, lt as SupervisedResult, y as ExecutorProgressEvent } from "./types-DMRc3jru.js";
+import { $s as VersionJudge, Bs as JudgedPursuitVersion, Cc as createFileObserverHooks, Dc as PursuitFork, Ec as FORK_PARENT_UNCERTAIN_NODES_KEY, Gs as PursuitVersionParent, Hs as NextPursuitVersionInput, Js as PursuitVersions, Ks as PursuitVersionStop, Oc as RUN_FORK_CORRELATION_KEYS, Qs as SettledPursuitVersion, Sc as ObserverRecordKind, Tc as verifyObserverRecords, Us as PURSUIT_VERSIONS_FILE, Vs as NextPursuitVersion, Ws as PreparedPursuitVersion, Xs as REVIEW_DIR, Ys as PursuitVersionsRecord, Zs as RunPursuitVersion, _c as PursuitStatus, ac as SupervisedPursuitResult, bc as ObserverJournal, cc as PursuitNodeCost, dc as PursuitNodeProjection, ec as VersionVerdict, fc as PursuitNodeTiming, gc as PursuitRunTotals, hc as PursuitRunProjection, ic as SupervisePursuitOptions, lc as PursuitNodePlacement, mc as PursuitProjection, nc as pursuitVersionRun, oc as supervisePursuit, pc as PursuitNodeUsage, qs as PursuitVersionStopReason, rc as SupervisePursuitError, sc as PursuitCostProvenance, tc as assertPursuitVersions, uc as PursuitNodePlatform, vc as projectPursuit, wc as observerRecordDigest, xc as ObserverRecord, yc as FileObserverJournal } from "./index-D2ipSqkP.js";
 //#region src/runtime/supervise/root-stream.d.ts
 /** The root stream: one JSONL line per progress event the root's executor observed. */
 declare const ROOT_STREAM_FILE = "root-stream.jsonl";
@@ -167,572 +165,6 @@ declare function deriveExecutionId(input: {
   turnIndex: number;
 }): string;
 //#endregion
-//#region src/durable/observer-journal.d.ts
-type ObserverRecordKind = 'event' | 'decision';
-/**
- * One immutable record in the observer plane. `sequence` is journal order, not
- * execution order; causal/runtime order remains available on the underlying event.
- * `previousDigest` + `digest` make deletion, reordering, or mutation detectable.
- */
-interface ObserverRecord {
-  readonly schemaVersion: 1;
-  readonly pursuitId: string;
-  readonly sequence: number;
-  readonly kind: ObserverRecordKind;
-  readonly observedAt: number;
-  readonly previousDigest?: string;
-  readonly event?: RuntimeHookEvent;
-  readonly decision?: RuntimeDecisionPoint;
-  readonly digest: string;
-}
-interface ObserverJournal {
-  appendEvent(event: RuntimeHookEvent): Promise<ObserverRecord>;
-  appendDecision(point: RuntimeDecisionPoint): Promise<ObserverRecord>;
-  read(): Promise<readonly ObserverRecord[]>;
-  hooks(): RuntimeHooks;
-}
-/**
- * Durable, append-only third-person history for one concrete Runtime execution.
- * It consumes Runtime's existing hook stream and does not participate in execution
- * decisions. A broken observer therefore cannot change what an agent is allowed to do.
- *
- * The write discipline deliberately matches `FileSpawnJournal`: serialized appends,
- * torn-tail recovery, short-write handling, and fsync before acknowledgement. One
- * execution owns one journal file; higher-level pursuit aggregation joins isolated
- * journals by `pursuitId` instead of making independent processes share a write head.
- */
-declare class FileObserverJournal implements ObserverJournal {
-  readonly path: string;
-  readonly pursuitId: string;
-  private tail;
-  private initialized;
-  private sequence;
-  private previousDigest;
-  private appendFailure;
-  constructor(path: string, pursuitId: string);
-  hooks(): RuntimeHooks;
-  appendEvent(event: RuntimeHookEvent): Promise<ObserverRecord>;
-  appendDecision(point: RuntimeDecisionPoint): Promise<ObserverRecord>;
-  read(): Promise<readonly ObserverRecord[]>;
-  private enqueue;
-  private initialize;
-  private readExistingUnsafe;
-  private writeRecord;
-  private assertComplete;
-}
-/** Verify identity, monotonic sequence, payload shape, and the complete digest chain. */
-declare function verifyObserverRecords(records: readonly ObserverRecord[], pursuitId?: string): readonly ObserverRecord[];
-/** Compute the canonical SHA-256 digest for an unsigned observer record. */
-declare function observerRecordDigest(record: Omit<ObserverRecord, 'digest'>): string;
-/** Build the canonical durable observer hook in one call. */
-declare function createFileObserverHooks(path: string, pursuitId: string): {
-  readonly journal: FileObserverJournal;
-  readonly hooks: RuntimeHooks;
-};
-//#endregion
-//#region src/durable/observer-projection.d.ts
-/**
- * One settled projection status, shared by runs and nodes. `down` is the journal's own word for a
- * failure (a settlement is journaled as `kind: 'down'`, cancellation included), so a consumer can
- * join run rows to node rows on `status` and read one failure population instead of two.
- */
-type PursuitStatus = 'running' | 'done' | 'down';
-/**
- * Where a node's dollar figure came from. `reported` = a provider billed all of it; `estimated` =
- * a model catalog priced all of it; `partial` = a provider billed part and a catalog priced the
- * rest; `unknown` = nothing priced it, so `usd` is a floor and never the cost.
- */
-type PursuitCostProvenance = 'reported' | 'estimated' | 'partial' | 'unknown';
-/**
- * One node's token usage by class. Cache and reasoning classes are absent when the provider did
- * not report them — absence is not zero. `tokensKnown` is `false` when work happened whose token
- * count no provider reported, which makes `input`/`output` a floor.
- */
-interface PursuitNodeUsage {
-  readonly input: number;
-  readonly output: number;
-  readonly cacheRead?: number;
-  readonly cacheWrite?: number;
-  readonly reasoning?: number;
-  readonly tokensKnown: boolean;
-}
-/**
- * One node's PLATFORM consumption — box wall time, the resource a subscription seat really pays.
- *
- * Kept apart from `PursuitNodeCost` because the two answer different questions and fail
- * independently: a seat run reports a truthful `$0` and real minutes, a caller-account run
- * reports real dollars and may report no minutes at all. Collapsing them into one "spend known"
- * figure hides which one is missing.
- *
- * Absent on a node that ran no box. `boxMinutes` absent WITH the block present says a box ran and
- * nothing measured it — a missing measurement is never a zero.
- */
-interface PursuitNodePlatform {
-  readonly boxMinutes?: number;
-  /** `false` when a box ran whose time could not be closed, so `boxMinutes` is a floor. */
-  readonly boxMinutesKnown: boolean;
-  /** `observed` = the platform billed the minutes; `estimated` = Runtime derived them from the box
-   *  lifetime it watched; `uncaptured` = a box ran and nothing measured it. */
-  readonly provenance: 'observed' | 'estimated' | 'uncaptured';
-}
-/** One node's dollar cost with the provenance that decides whether it may be compared or summed. */
-interface PursuitNodeCost {
-  readonly usd: number;
-  readonly usdKnown: boolean;
-  /** The part of `usd` a model catalog priced because no provider receipt covered it. */
-  readonly usdEstimated?: number;
-  readonly provenance: PursuitCostProvenance;
-}
-/**
- * One node's clock. `wallMs` is `settledAt - startedAt` and is deliberately distinct from the
- * executor-reported `spent.ms` sums, which under-report and overlap across parallel children.
- * `firstTokenAt` stays absent unless a provider reports that instant; it is never inferred from
- * `firstOutputAt`, which is when the node first reported usage for a turn.
- */
-interface PursuitNodeTiming {
-  readonly startedAt: number;
-  readonly firstOutputAt?: number;
-  readonly firstTokenAt?: number;
-  readonly settledAt?: number;
-  readonly wallMs?: number;
-}
-/** Where and how a node's execution was placed, read off its execution-binding receipt. */
-type PursuitNodePlacement = Readonly<Record<string, string | number | boolean | null>>;
-/**
- * One run's spend counted once, and each node's own share of it. `inclusive` and the entries of
- * `exclusiveByNode` are the two views a client needs to show a tree without double counting.
- */
-interface PursuitRunTotals {
-  /**
-   * The whole run counted once. A node's settled `spent` already contains the child work its own
-   * nested tree reported, so summing only the run's top-level nodes plus every node's own
-   * inference counts each model call exactly once.
-   */
-  readonly inclusive: Spend;
-  /**
-   * Each node's own share: its reported spend and own inference minus what its direct children
-   * reported. Keyed by node id, plus the run root when the root itself metered inference. The
-   * entries sum to `inclusive` by construction.
-   */
-  readonly exclusiveByNode: Readonly<Record<string, Spend>>;
-}
-/**
- * One attempt at one concrete Runtime run: the stretch of `agent.run` lifecycle from a `before`
- * to the `after` or `error` that settles it. A run whose first attempt threw and whose corrected
- * attempt settled is two rows, so `error` names only the attempt that failed.
- *
- * A `before` observed while an attempt is still open does not open another: it is a process
- * that resumed the run after the previous process died without a terminal record, and the row
- * counts it in `resumeCount`. The alternative, a row per process start, would leave the killed
- * process's row `running` for the rest of history.
- */
-interface PursuitRunProjection {
-  readonly runId: string;
-  /** Zero-based position of this attempt among the run's attempts, in journal order. */
-  readonly attemptIndex: number;
-  /** How many times a process resumed this attempt after a predecessor died mid-run. */
-  readonly resumeCount: number;
-  readonly status: PursuitStatus;
-  readonly settledAt?: number;
-  readonly error?: string;
-  readonly firstSequence: number;
-  readonly lastSequence: number;
-  readonly firstObservedAt: number;
-  readonly lastObservedAt: number;
-  readonly eventCount: number;
-  readonly decisionCount: number;
-  readonly targets: Readonly<Record<string, number>>;
-  readonly decisions: Readonly<Record<string, number>>;
-  readonly totals: PursuitRunTotals;
-  /** The nodes whose accounting is incomplete. Present exactly when non-empty. */
-  readonly spendGaps?: ReadonlyArray<SpendGap>;
-}
-interface PursuitNodeProjection {
-  readonly id: string;
-  readonly parentId?: string;
-  /** Node ids are scoped to this concrete Runtime tree; `(runId,id)` is identity. */
-  readonly runId: string;
-  readonly label?: string;
-  /** The runner that executed this node — the executor's own name, not a harness guess. */
-  readonly runtime?: string;
-  readonly depth?: number;
-  readonly assignmentId?: string;
-  /** The settled sibling this node replaced, as its manager's spawn named it. Absent on a node
-   *  that replaced nothing. */
-  readonly successorOf?: string;
-  readonly identity?: unknown;
-  readonly budget?: unknown;
-  readonly status: PursuitStatus;
-  readonly settledAt?: number;
-  /** The child work this node reported at settlement. Absent until a terminal record lands. */
-  readonly spent?: Spend;
-  /** This node's OWN inference, re-homed from its nested tree. Absent when it drove no turns. */
-  readonly ownInference?: Spend;
-  /** Absent until a spend record lands; the run's `spendGaps` then names the node. */
-  readonly usage?: PursuitNodeUsage;
-  /** Absent until a spend record lands; the run's `spendGaps` then names the node. */
-  readonly cost?: PursuitNodeCost;
-  /** What the node consumed on the PLATFORM. Absent on a node that ran no box. */
-  readonly platform?: PursuitNodePlatform;
-  readonly timing?: PursuitNodeTiming;
-  /** The kernel-minted attempt this node's execution binding is keyed on. */
-  readonly attemptId?: string;
-  /** The runner-native execution the node bound to: a request, session, run, process, or tree. */
-  readonly execution?: {
-    readonly kind: string;
-    readonly id: string;
-  };
-  /** The model the materialization receipt names, when the runner reported one. */
-  readonly model?: string;
-  /** The concrete backend the profile materialized onto. */
-  readonly backend?: string;
-  readonly placement?: PursuitNodePlacement;
-  /** Model-call identifiers this node's own turns reported, in order, deduplicated. */
-  readonly modelCalls?: ReadonlyArray<string>;
-  readonly materialization?: ProfileMaterializationReceipt;
-  readonly executionBindings?: ReadonlyArray<ExecutionBindingReceipt>;
-  /** What the provider itself reported serving, and why it is unknown when it is. */
-  readonly providerModel?: ProviderModelExecutionEvidence;
-  /** Content-addressed pointer to this node's persisted tool trace, or why there is none. */
-  readonly trace?: WorkerTraceEvidence;
-  readonly outRef?: string;
-  readonly score?: number;
-  readonly valid?: boolean;
-  readonly reason?: string;
-  readonly infra?: boolean;
-  /** Recorded by Runtime on the `agent.child` payload: `'pending'` at a retained child's
-   *  settlement, `'released'` when root settlement destroyed its environment without recovery.
-   *  The status stays `down` — the split is a sibling fact, not a fourth status. A second
-   *  `agent.child` for one node is already how a live-recovered child flips down→done, so the
-   *  fold overwrites in observed order; that event's `settledAt` is the original settlement, so
-   *  `settledAt` and `timing` do not move. */
-  readonly retainedExecution?: RetainedExecutionState;
-  /** Why a retained child has no accepted result; see `RetainedPendingCause`. */
-  readonly retainedPendingCause?: RetainedPendingCause;
-  /** When the release sweep closed a retained node's slot; absent unless `'released'`. */
-  readonly releasedAt?: number;
-  /** Each channel on which the settled spend exceeded the node's reservation. The status is the
-   *  node's own outcome: a `done` node that overspent still delivered its output. */
-  readonly budgetViolation?: BudgetViolation;
-  readonly wait?: unknown;
-  readonly firstSequence: number;
-  readonly lastSequence: number;
-  readonly firstObservedAt: number;
-  readonly lastObservedAt: number;
-  readonly eventCount: number;
-  readonly turnCount: number;
-}
-interface PursuitProjection {
-  readonly pursuitId: string;
-  /** Number of records in this concrete execution journal. */
-  readonly sequence: number;
-  /** Digest-chain tip for this concrete execution journal. */
-  readonly chainTip: string;
-  readonly firstObservedAt: number;
-  readonly lastObservedAt: number;
-  readonly runs: readonly PursuitRunProjection[];
-  readonly nodes: readonly PursuitNodeProjection[];
-  readonly eventCount: number;
-  readonly decisionCount: number;
-}
-/**
- * Fold one append-only execution journal into a deterministic operator projection.
- *
- * This is intentionally a READ model, not another state machine: it does not own
- * execution, cannot steer agents, and can be rebuilt from the journal at any time.
- * Projection verifies the complete hash chain first, so an operator view can never
- * silently render a mutated or reordered observer history as trustworthy state.
- *
- * Topology comes only from Runtime's canonical `agent.spawn` facts. Terminal node
- * state comes only from `agent.child`; concrete run state comes only from the root
- * `agent.run` lifecycle emitted by `supervisePursuit`, one row per attempt. Node identity is
- * scoped to the concrete Runtime run so independent trees may both contain `root:s0` without
- * aliasing, and a node belongs to the attempt that spawned it.
- *
- * Usage, cost and timing are reported at the class the runtime measured them at. A missing
- * class stays ABSENT and the run names the node in `spendGaps`; nothing here converts an
- * unmeasured channel into a zero, because a fabricated zero is indistinguishable from free work.
- */
-declare function projectPursuit(records: readonly ObserverRecord[]): PursuitProjection;
-//#endregion
-//#region src/durable/run-fork.d.ts
-/**
- * Start a run as a version of a settled run: the parent's recorded root inputs plus one change.
- *
- * The call's `profile`, `task` and `budget` must be the parent's, byte for byte, as its sealed
- * journal records them. Runtime applies `change` to that profile and runs the result in a new
- * run directory. The parent directory is read and never written.
- */
-interface PursuitFork {
-  /** The settled parent's run directory. */
-  readonly runDir: string;
-  /** The sha256 of the parent's `result.json` bytes: the sealed point the fork starts from. */
-  readonly settleDigest: Sha256Digest;
-  /** The one change, applied to the parent's root profile. Its `id` is recorded. */
-  readonly change: AgentProfileDiff;
-  /**
-   * Fork a parent whose journal holds a node without a terminal record, an unbegun owned tree, an
-   * unconfirmed teardown, or work in flight. Such a node may still act, and a fork never replays
-   * the parent's children, so it can only duplicate work outside the fork's tree. The root then
-   * records those node ids as `forkParentUncertainNodes`. Omit it to refuse such a parent.
-   */
-  readonly acceptUncertain?: boolean;
-}
-/**
- * The `execution.correlation` keys a fork records on its root. Runtime writes them; a caller that
- * supplies one is refused. `lineageRootRunId` is the first run of the chain of parents, so the
- * spend of every version of one lineage groups under one id.
- */
-declare const RUN_FORK_CORRELATION_KEYS: readonly ["forkParentRunId", "forkParentSettleDigest", "forkProfileDiffId", "lineageRootRunId"];
-/** The correlation key an accepted uncertain parent adds: its uncertain node ids, comma-joined. */
-declare const FORK_PARENT_UNCERTAIN_NODES_KEY = "forkParentUncertainNodes";
-//#endregion
-//#region src/durable/supervise-pursuit.d.ts
-interface SupervisePursuitOptions extends SuperviseOptions {
-  /** Stable objective identity spanning concrete Runtime runs. */
-  readonly pursuitId: string;
-  /**
-   * One concrete Runtime execution owns one durable directory and observer journal.
-   * A pursuit spanning several runs reuses `pursuitId` across distinct `runDir`s;
-   * Intelligence joins those isolated projections without a shared write head.
-   */
-  readonly runDir: string;
-  /**
-   * Always `'release'`. The settle record refuses re-entry, so no later call resumes a settled
-   * pursuit and nothing else would release the provider environments its retained children hold.
-   * `'keep'` is refused rather than ignored.
-   */
-  readonly retainedAtSettlement?: 'release';
-  /**
-   * Run this pursuit as a version of a settled run: `profile`, `task` and `budget` must equal the
-   * parent's recorded root, and Runtime executes the parent's profile with `fork.change` applied.
-   * The root's `execution.correlation` records the parent, its sealed digest, the change and the
-   * lineage (`RUN_FORK_CORRELATION_KEYS`). The fork's `runDir` must lie outside the parent's, and
-   * the parent's outside it. The parent's directory is never written, and a refused fork, such as
-   * one whose parent has an uncertain node, writes nothing.
-   */
-  readonly fork?: PursuitFork;
-  /**
-   * Continue this pursuit across versions. The first version runs at `runDir` as usual, or is
-   * read back when that directory already settled. After each version settles, `versions.judge`
-   * scores it from outside its tree; unless `versions.stop` ends the chain, the next version forks
-   * from the best version so far with the change `versions.next` returns, at `<runDir>.v<n>` with
-   * run id `<runId>.v<n>`. `<runDir>.versions/versions.jsonl` records every version, its parent,
-   * its change, its verdict and its dollars, and the stop. A call on a chain that stopped reads
-   * that record back; a call on a chain that did not resumes it without re-running or re-judging a
-   * settled version. The call returns the best version's result with the chain's record.
-   */
-  readonly versions?: PursuitVersions;
-  /** Supervise's name tables, plus the version judges and changes `versions` may name. */
-  readonly registry?: SuperviseOptions['registry'] & PursuitVersionRegistry;
-}
-interface SupervisedPursuitResult<Result> {
-  readonly result: Result;
-  readonly pursuit: PursuitProjection;
-  readonly observerPath: string;
-  /** `runDir/result.json`: `result` as canonical JSON, written once at settle. */
-  readonly settlePath: string;
-  /** The version chain's record, when the call set `versions`. */
-  readonly versions?: PursuitVersionsRecord;
-}
-/** A failed Runtime execution whose complete third-person projection was retained. */
-declare class SupervisePursuitError extends Error {
-  readonly pursuit: PursuitProjection;
-  readonly observerPath: string;
-  /** `runDir/failure.json`: the record of this throw. */
-  readonly failurePath: string;
-  constructor(cause: unknown, pursuit: PursuitProjection, observerPath: string, failurePath: string);
-}
-/**
- * One-call durable pursuit execution over the canonical `supervise()` kernel.
- *
- * This is an adapter, not a second executor: it composes a durable third-person
- * observer into Runtime's existing recursive hook stream and then rebuilds the
- * operator projection after the same `supervise()` call settles. Agents never
- * receive the observer path or projection and their behavior does not depend on it.
- *
- * Every concrete execution writes only inside its own `runDir`. Cross-run pursuit
- * aggregation is therefore lock-free at the observer layer: reuse `pursuitId` across
- * run directories and let Intelligence join the independently verified projections.
- *
- * The directory's terminal state is recorded beside `observer.jsonl`: `result.json` holds the
- * returned result once the run settles and `failure.json` the most recent throw. A directory
- * whose `result.json` exists refuses re-entry before any compute; a failure record alone does
- * not, because a caller can correct its input and drive the same run again. For the life of the
- * call the directory is held by `supervise.lock`, so a second process on the same directory
- * refuses and names the holder instead of sharing one journal.
- * An abandoned `supervise.lock.guard` requires removal after confirming no lock mutation is active.
- */
-declare function supervisePursuit(profile: SupervisorProfile, task: unknown, opts: SupervisePursuitOptions): Promise<SupervisedPursuitResult<Awaited<ReturnType<typeof supervise>>>>;
-//#endregion
-//#region src/durable/pursuit-versions.d.ts
-/**
- * Continue a pursuit across versions: after each version settles, an outside judge scores it, and
- * the next version forks from the best version so far with one change, until the stop rule ends
- * the chain. Each version is one `supervisePursuit` run in its own directory; the fork records its
- * parent, the parent's seal, the change and the lineage root on the version's root.
- */
-interface PursuitVersions {
-  /** Scores each settled version from outside its tree. A string names `registry.versionJudges`. */
-  readonly judge: VersionJudge | string;
-  /** The change the next version applies to the best version's profile. A string names
-   *  `registry.nextVersions`. */
-  readonly next: NextPursuitVersion | string;
-  /** When the chain stops. Every cap is required: a chain without one is refused. */
-  readonly stop: PursuitVersionStop;
-  /**
-   * Where a later version executes. Omit it to run each version in this process through
-   * `supervisePursuit({ fork })`, the same placement as the first. A caller that places versions
-   * elsewhere executes exactly `version.profile` on `version.task` under `version.budget`, with
-   * `version.execution` as the root's attribution, and returns once `version.runDir` holds the
-   * version's settle record and observer journal. It is called again for the same version after
-   * a restart, so it must attach to a version it already started rather than start a second one.
-   */
-  readonly run?: RunPursuitVersion;
-  /**
-   * A version's dollars as the caller measured them, such as the provider's charge to the keys the
-   * version used. Omit it to use the version's settled `spentTotal.usd`, which is an estimate
-   * when `usdKnown` is false. `null` means unknown, and stops the chain.
-   */
-  readonly usd?: (version: SettledPursuitVersion, signal: AbortSignal) => Promise<number | null>;
-}
-/** The chain's stop rule. The chain never starts a version once any cap is reached. */
-interface PursuitVersionStop {
-  /** Stop after this many consecutive versions that did not improve on the best score. */
-  readonly patience: number;
-  /** At most this many versions, the first included. */
-  readonly maxVersions: number;
-  /**
-   * The chain's total dollars, the first version included, summed from each version's settled
-   * `spentTotal.usd`. The chain checks it between versions; a version's own budget, or the
-   * caller's spend watcher, bounds that version in flight. A version whose dollars are not a
-   * number stops the chain, since the chain can no longer prove it is under the cap.
-   */
-  readonly maxUsd: number;
-  /** The chain's wall clock, from its first version's start. A running version is aborted at it. */
-  readonly deadlineMs: number;
-  /** A version improves when its score exceeds the best by more than this. Default 0. */
-  readonly minImprovement?: number;
-}
-/** An outside judge. Runtime calls it after a version's settle record exists, never inside the
- *  version's tree, and gives it no handle into that tree. Place it where you like, such as its own
- *  sandbox through `runIsolatedCheck({ box })`. */
-interface VersionJudge {
-  /** The sha256 of the judge's code and configuration. Every verdict must carry it, and a chain
-   *  whose ledger was judged under another digest is refused. */
-  readonly digest: Sha256Digest;
-  judge(version: SettledPursuitVersion, signal: AbortSignal): Promise<VersionVerdict>;
-}
-interface VersionVerdict {
-  /** Higher is better. `null` when the judge could not score the version, which never counts as
-   *  an improvement. */
-  readonly score: number | null;
-  /** Must equal `VersionJudge.digest`. */
-  readonly judgeDigest: Sha256Digest;
-  /** What the judge measured, retained verbatim in the ledger. JSON values only. */
-  readonly detail?: unknown;
-}
-/** A settled version, as the judge and `next` read it. */
-interface SettledPursuitVersion {
-  /** 1 for the first version. */
-  readonly version: number;
-  readonly runId: string;
-  readonly runDir: string;
-  /** The sha256 of the version's `result.json` bytes. */
-  readonly settleDigest: Sha256Digest;
-  readonly result: SupervisedResult<unknown>;
-  /** The profile the version executed: the first version's, or its parent's plus its change. */
-  readonly profile: AgentProfile;
-  readonly parent?: PursuitVersionParent;
-  readonly change?: AgentProfileDiff;
-}
-interface PursuitVersionParent {
-  readonly version: number;
-  readonly runId: string;
-  readonly settleDigest: Sha256Digest;
-}
-interface JudgedPursuitVersion extends SettledPursuitVersion {
-  readonly verdict: VersionVerdict;
-  /** Whether its score beat every earlier version's by more than `minImprovement`. */
-  readonly improved: boolean;
-  /** The version's dollars: `versions.usd`'s measurement, or its settled `spentTotal.usd`;
-   *  `null` when that is not a number. */
-  readonly usd: number | null;
-  /** False when the figure is Runtime's estimate or unknown. */
-  readonly usdKnown: boolean;
-  /** Who measured `usd`: the caller's `versions.usd`, or Runtime's settled `spentTotal`. */
-  readonly usdSource: 'caller' | 'runtime';
-  /** Where the version came from: its parent run and its change. Absent for a first version that
-   *  is not a fork. */
-  readonly lineage?: AgentCandidateLineage;
-}
-interface NextPursuitVersionInput {
-  /** The version the next one forks from: the highest score, the earliest on a tie. */
-  readonly best: JudgedPursuitVersion;
-  readonly last: JudgedPursuitVersion;
-  readonly versions: readonly JudgedPursuitVersion[];
-}
-/** Build the one change the next version applies to `best.profile`. Its `id` must be non-empty. */
-type NextPursuitVersion = (input: NextPursuitVersionInput, signal: AbortSignal) => AgentProfileDiff | Promise<AgentProfileDiff>;
-/** One version, ready to execute. */
-interface PreparedPursuitVersion {
-  readonly version: number;
-  readonly runId: string;
-  readonly runDir: string;
-  readonly pursuitId: string;
-  /** The profile to execute, the change already applied. */
-  readonly profile: AgentProfile;
-  readonly task: unknown;
-  readonly budget: Budget;
-  /** The root's attribution, with the fork's parent, seal, change and lineage root. */
-  readonly execution: AgentExecutionRef;
-  /** The fork Runtime verified, for a placement that runs `supervisePursuit({ fork })` itself
-   *  with the parent's profile, `parentProfile`. */
-  readonly fork: PursuitFork;
-  readonly parentProfile: AgentProfile;
-}
-type RunPursuitVersion = (version: PreparedPursuitVersion, signal: AbortSignal) => Promise<void>;
-type PursuitVersionStopReason = 'no-improvement' | 'max-versions' | 'max-usd' | 'spend-unknown' | 'deadline' | 'aborted';
-/** The chain's record, returned beside the best version's result and kept in `versions.jsonl`. */
-interface PursuitVersionsRecord {
-  /** `<runDir>.versions`, beside the first version's directory. */
-  readonly lineageDir: string;
-  readonly judgeDigest: Sha256Digest;
-  readonly stop: PursuitVersionStop;
-  /** ISO instant the first version started. */
-  readonly startedAt: string;
-  readonly versions: readonly JudgedPursuitVersion[];
-  /** The best version's number. */
-  readonly best: number;
-  /** Sum of the versions' `usd`; a floor when any version's dollars are unknown. */
-  readonly spentUsd: number;
-  readonly stopped: {
-    readonly reason: PursuitVersionStopReason;
-    readonly at: string;
-  };
-}
-/** The registry tables `versions.judge` and `versions.next` resolve a name against. */
-interface PursuitVersionRegistry {
-  readonly versionJudges?: {
-    resolve(name: string): VersionJudge | undefined;
-  };
-  readonly nextVersions?: {
-    resolve(name: string): NextPursuitVersion | undefined;
-  };
-}
-/** The ledger file inside the lineage directory. */
-declare const PURSUIT_VERSIONS_FILE = "versions.jsonl";
-/** The `<runDir>.v<n>` directory and `<runId>.v<n>` id of version `n`, beside the first. */
-declare function pursuitVersionRun(runDir: string, runId: string, version: number): {
-  runDir: string;
-  runId: string;
-};
-/**
- * Validate a `versions` option before any compute. The same check runs inside `supervisePursuit`;
- * a caller that records the option as data can run it at preflight.
- */
-declare function assertPursuitVersions(versions: unknown): asserts versions is PursuitVersions;
-//#endregion
 //#region src/durable/run-lock.d.ts
 /** The lock file `supervisePursuit` holds inside a run directory for the life of one call. */
 declare const RUN_DIRECTORY_LOCK_FILE = "supervise.lock";
@@ -870,5 +302,5 @@ interface DurableSupervisionDiscovery {
  */
 declare function discoverDurableSupervisionRun(runDir: string): Promise<DurableSupervisionDiscovery>;
 //#endregion
-export { type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type DurableCoordinationStreamIdentity, type DurableFailureRecord, type DurableSupervisionDiscovery, FAILURE_RECORD_FILE, FORK_PARENT_UNCERTAIN_NODES_KEY, FileObserverJournal, type JudgedPursuitVersion, type NextPursuitVersion, type NextPursuitVersionInput, type ObserverJournal, type ObserverRecord, type ObserverRecordKind, PURSUIT_VERSIONS_FILE, type PreparedPursuitVersion, type PursuitCostProvenance, type PursuitFork, type PursuitNodeCost, type PursuitNodePlacement, type PursuitNodePlatform, type PursuitNodeProjection, type PursuitNodeTiming, type PursuitNodeUsage, type PursuitProjection, type PursuitRunProjection, type PursuitRunTotals, type PursuitStatus, type PursuitVersionParent, type PursuitVersionRegistry, type PursuitVersionStop, type PursuitVersionStopReason, type PursuitVersions, type PursuitVersionsRecord, ROOT_STREAM_FILE, RUN_DIRECTORY_LOCK_FILE, RUN_FORK_CORRELATION_KEYS, type RootStreamReceipt, type RootStreamRecord, type RunChatTurnInput, type RunDirectoryHolderLiveness, type RunDirectoryLock, type RunDirectoryLockHolder, RunDirectoryLockedError, type RunPursuitVersion, SETTLE_RECORD_FILE, type SettledPursuitVersion, SettledRunDirectoryError, SupervisePursuitError, type SupervisePursuitOptions, type SupervisedPursuitResult, type VersionJudge, type VersionVerdict, acquireRunDirectoryLock, assertPursuitVersions, createFileObserverHooks, deriveExecutionId, discoverDurableSupervisionRun, handleChatTurn, observerRecordDigest, projectPursuit, pursuitVersionRun, readFailureRecord, readRootStream, readRootStreamReceipt, readRunDirectoryLock, readSettleRecord, runDirectoryHolderIsLive, settleRecordJson, supervisePursuit, verifyObserverRecords };
+export { type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type DurableCoordinationStreamIdentity, type DurableFailureRecord, type DurableSupervisionDiscovery, FAILURE_RECORD_FILE, FORK_PARENT_UNCERTAIN_NODES_KEY, FileObserverJournal, type JudgedPursuitVersion, type NextPursuitVersion, type NextPursuitVersionInput, type ObserverJournal, type ObserverRecord, type ObserverRecordKind, PURSUIT_VERSIONS_FILE, type PreparedPursuitVersion, type PursuitCostProvenance, type PursuitFork, type PursuitNodeCost, type PursuitNodePlacement, type PursuitNodePlatform, type PursuitNodeProjection, type PursuitNodeTiming, type PursuitNodeUsage, type PursuitProjection, type PursuitRunProjection, type PursuitRunTotals, type PursuitStatus, type PursuitVersionParent, type PursuitVersionStop, type PursuitVersionStopReason, type PursuitVersions, type PursuitVersionsRecord, REVIEW_DIR, ROOT_STREAM_FILE, RUN_DIRECTORY_LOCK_FILE, RUN_FORK_CORRELATION_KEYS, type RootStreamReceipt, type RootStreamRecord, type RunChatTurnInput, type RunDirectoryHolderLiveness, type RunDirectoryLock, type RunDirectoryLockHolder, RunDirectoryLockedError, type RunPursuitVersion, SETTLE_RECORD_FILE, type SettledPursuitVersion, SettledRunDirectoryError, SupervisePursuitError, type SupervisePursuitOptions, type SupervisedPursuitResult, type VersionJudge, type VersionVerdict, acquireRunDirectoryLock, assertPursuitVersions, createFileObserverHooks, deriveExecutionId, discoverDurableSupervisionRun, handleChatTurn, observerRecordDigest, projectPursuit, pursuitVersionRun, readFailureRecord, readRootStream, readRootStreamReceipt, readRunDirectoryLock, readSettleRecord, runDirectoryHolderIsLive, settleRecordJson, supervisePursuit, verifyObserverRecords };
 //# sourceMappingURL=durable.d.ts.map