@tangle-network/agent-runtime 0.271.0 → 0.273.3

package/dist/{types-Bo7z5aG5.d.ts → types-DMRc3jru.d.ts}

@@ -1998,6 +1998,322 @@ declare class RetainedRunDispatchBindingError extends AgentEvalError {
   });
 }
 //#endregion
+//#region src/runtime/supervise/continuation.d.ts
+/**
+ * One reading of a completion check.
+ *
+ * A check program prints an agent-eval `JudgeScore`; {@link verdictFromJudgeScore} reads it into
+ * this shape. A plain boolean check is a verdict with no items.
+ */
+interface CheckVerdict {
+  /** Whether the check accepts the result. */
+  readonly pass: boolean;
+  /** Every item the check read, by name: 1 when it passes, lower when it does not. The
+   *  `JudgeScore.dimensions` of the check program. */
+  readonly items?: Readonly<Record<string, number>>;
+  /** The check's score. */
+  readonly composite?: number;
+  /** The pass threshold on `composite`, when the check has one. */
+  readonly threshold?: number;
+  /** One `FAIL <item> <where>: <reason>` line per failed item, in the check's order. */
+  readonly failures?: ReadonlyArray<string>;
+  /** The check's prose review of the result, when it writes one. */
+  readonly review?: string;
+}
+/**
+ * The check could not run: its box did not start, its judge's provider refused, its program
+ * crashed. It is not a verdict on the result. Inside a run the loop pauses, as it does for an
+ * unavailable upstream, and the refusal tells the director its result was not judged.
+ */
+declare class CheckUnavailableError extends Error {
+  constructor(message: string, options?: {
+    readonly cause?: unknown;
+  });
+}
+/** Read a check function's return value into a verdict. Anything but `true` or a passing verdict
+ *  is a failure: a check fails closed. */
+declare function checkVerdictOf(outcome: unknown): CheckVerdict;
+/**
+ * Read an agent-eval `JudgeScore` from a check program into a verdict.
+ *
+ * Each dimension is a checked item. `notes` lines that start with `FAIL ` are the failures; the
+ * remaining lines are the check's review. The verdict passes when `composite >= threshold` and the
+ * score is not marked `failed`; a `failed` score means the judge itself did not run, which is
+ * {@link CheckUnavailableError}, not a verdict.
+ */
+declare function verdictFromJudgeScore(score: {
+  readonly dimensions: Readonly<Record<string, number>>;
+  readonly composite: number;
+  readonly notes: string;
+  readonly failed?: true;
+}, threshold: number): CheckVerdict;
+/** Items that fail in `verdict`: every item below 1, or the named items of its FAIL lines. */
+declare function failedItems(verdict: CheckVerdict): ReadonlyArray<string>;
+/** Items that pass in `verdict`. */
+declare function passedItems(verdict: CheckVerdict): ReadonlyArray<string>;
+/** One time the check ran inside the run, whatever started it. */
+interface CheckRead {
+  /** 1-based count of check reads in this manager, the unavailable ones included. */
+  readonly read: number;
+  /** The driver attempt the read belongs to. */
+  readonly attempt: number;
+  /** Epoch ms. */
+  readonly at: number;
+  /** `submit`: a `submit_result` call. `turn-end`: the turn ended with no accepted result. */
+  readonly source: 'submit' | 'turn-end';
+  /** Absent when the check could not run. */
+  readonly verdict?: CheckVerdict;
+  /** Why the check could not run. */
+  readonly unavailable?: string;
+}
+/**
+ * How a manager with a completion check is sent back when its turn ends unmet.
+ *
+ * Required for an external manager with a check: Runtime supplies no default, because a retry
+ * default in source is a research decision the record must make. There is no re-prompt count.
+ * The loop re-enters until the check passes, `report_blocked` ends the run, or a bound ends it:
+ * this deadline, the budget, `maxBarren` turns in a row without progress, or cancellation.
+ * Progress means the check's best composite rose, an accepted result, or a worker that delivered.
+ */
+interface ContinuationPolicy {
+  /** No re-entry starts at or after this instant: epoch ms, or an ISO 8601 time. */
+  readonly deadline: number | string;
+  /** Re-entered turns in a row that may end without progress before the run ends. Minimum 1.
+   *  The evidence for 2: repair loses most of its effect within two or three attempts, and a
+   *  fresh start at the same budget scored higher (Debugging Decay Index). */
+  readonly maxBarren: number;
+  /** Every instruction word of the note. */
+  readonly profile: ContinuationProfile;
+  /** `verbatim` sends the check's FAIL lines, the protected items, and what changed. A check with
+   *  `feedback: 'pass-only'` overrides this to `off`. */
+  readonly failures: 'verbatim' | 'off';
+  /** `on` runs the question panel at each continuation and puts its admitted findings in the note.
+   *  Requires `runPanel`. */
+  readonly panel: 'on' | 'off';
+  /** `on` states the bar: every check item with its state, the best version's verdict and the
+   *  gap, the reference result, and the check's review. */
+  readonly bar: 'on' | 'off';
+  /** The play's registered reference result, for the bar. */
+  readonly reference?: string;
+  /** The best version's verdict on the same check, for the bar. The version loop sets it. */
+  readonly best?: {
+    readonly label: string;
+    readonly verdict: CheckVerdict;
+  };
+  /** The panel's dollar caps. Required with `panel: 'on'`. */
+  readonly panelUsd?: {
+    readonly perContinuation: number;
+    readonly perRun: number;
+  };
+  /** The question panel. Required with `panel: 'on'`. */
+  readonly runPanel?: ContinuationPanel;
+  /** A play's own section, appended after Runtime's sections. It cannot remove or rewrite one. */
+  readonly append?: ContinuationAppend;
+}
+/** Resolve and check a policy before any compute. Returns the deadline in epoch ms. */
+declare function admitContinuationPolicy(policy: ContinuationPolicy, context: string): number;
+/**
+ * Every instruction word of the note. Runtime supplies the facts and their order; this data
+ * supplies the words, so the note can be improved (by a person, reflection, or GEPA) without a code
+ * change. Templates may name the facts in {@link CONTINUATION_FACTS} as `{name}`.
+ */
+interface ContinuationProfile {
+  /** Recorded with every note, so each continuation names the words it carried. */
+  readonly id: string;
+  /** Section 1, the verdict. The first line should state the failure as a fact. */
+  readonly opening: string;
+  /** Section 7: what to do before the next submit. */
+  readonly plan: string;
+  /** Section 8: what the harness enforces, and the honest exit. */
+  readonly rules: string;
+  /** Section headings; an empty heading prints the section without one. */
+  readonly headings: {
+    readonly failures: string;
+    readonly protected: string;
+    readonly changed: string;
+    readonly findings: string;
+    readonly bar: string;
+    readonly plan: string;
+    readonly rules: string;
+  };
+  /** The bar's standing instruction, printed under its heading. */
+  readonly barRule?: string;
+  /** The panel's question templates. `{item}` expands over failed items and `{worker}` over
+   *  settled workers; a template with neither is asked once. */
+  readonly questions?: ReadonlyArray<string>;
+  /** The panel's model, when the profile chooses one. */
+  readonly panelModel?: string;
+  /** What a new version's director reads about the best version's review, for the version
+   *  chain's `'review-of-best'`. It may name `{version}`, `{path}` and `{score}`. */
+  readonly review?: string;
+}
+/** The facts a profile template may name. */
+declare const CONTINUATION_FACTS: readonly ["composite", "threshold", "failed", "total", "reads", "owed", "settled", "delivered", "continuation"];
+/** What the question panel reads for one continuation. */
+interface ContinuationPanelInput {
+  /** 1-based continuation number. */
+  readonly continuation: number;
+  readonly task: unknown;
+  /** The check's verdict this note reports; absent when no result reached the check. */
+  readonly verdict?: CheckVerdict;
+  /** Every check read so far, oldest first. */
+  readonly reads: ReadonlyArray<CheckRead>;
+  /** The expanded questions, one per atomic question. */
+  readonly questions: ReadonlyArray<string>;
+  /** `<runDir>/root-stream.jsonl`, the director's own trace, when the run has a directory. */
+  readonly rootStreamPath?: string;
+  /** Settled workers, with the evidence reference their trace is read from. */
+  readonly workers: ReadonlyArray<{
+    readonly id: string;
+    readonly label: string;
+  }>;
+  readonly bar?: ContinuationPolicy['best'];
+  readonly reference?: string;
+  /** The dollars this panel call may spend. */
+  readonly usdCap: number;
+  readonly signal: AbortSignal;
+}
+/** One answer the panel proposes for the note. */
+interface PanelFinding {
+  readonly question: string;
+  /** The finding, stated as a claim about the run. */
+  readonly claim: string;
+  /** Every `trace://` citation in the answer, and whether the trace store holds it. */
+  readonly citations: ReadonlyArray<{
+    readonly uri: string;
+    readonly resolved: boolean;
+  }>;
+  /** Whether an independent verifier, shown only the cited spans, agreed with the claim. */
+  readonly verified: boolean;
+  /** The failed check items the finding explains, when it names any. */
+  readonly items?: ReadonlyArray<string>;
+}
+interface ContinuationPanelResult {
+  readonly findings: ReadonlyArray<PanelFinding>;
+  /** Dollars spent; `null` when the provider reported no cost. Unknown is never zero. */
+  readonly usd: number | null;
+  /** Provider receipts, recorded verbatim in `panel.jsonl`. */
+  readonly receipts?: unknown;
+}
+/** Ask the panel's questions over the run's own traces. */
+type ContinuationPanel = (input: ContinuationPanelInput) => Promise<ContinuationPanelResult>;
+/** A play's own section for one note. Return `undefined` to add nothing this time. */
+type ContinuationAppend = (context: {
+  readonly continuation: number;
+  readonly verdict?: CheckVerdict;
+  readonly reads: ReadonlyArray<CheckRead>;
+  readonly signal: AbortSignal;
+}) => Promise<{
+  readonly heading: string;
+  readonly text: string;
+} | undefined>;
+/** A finding that reached the note, with the continuation that admitted it. */
+interface AdmittedFinding extends PanelFinding {
+  readonly admittedAt: number;
+  /** Set once every item the finding named passes. */
+  readonly resolvedAt?: number;
+}
+/** Findings reach the note only when every citation resolves, at least two distinct spans are
+ *  cited, and the independent verifier agreed. The best method in Who&When found the failing step
+ *  14.2% of the time, so an unverified finding is noise with a citation. */
+declare function admitFinding(finding: PanelFinding): boolean;
+/**
+ * Rank the admitted findings by how many failed items they explain, drop repeats, and keep them
+ * within the note's cap. Earlier findings stay as they were written (ACE: itemized additions keep
+ * detail that repeated rewrites lose); a finding whose items all pass now is marked resolved.
+ */
+declare function distillFindings(prior: ReadonlyArray<AdmittedFinding>, proposed: ReadonlyArray<PanelFinding>, failing: ReadonlySet<string>, continuation: number): ReadonlyArray<AdmittedFinding>;
+/** Expand the profile's question templates over the failed items and the settled workers. */
+declare function expandQuestions(templates: ReadonlyArray<string>, failing: ReadonlyArray<string>, workers: ReadonlyArray<{
+  readonly id: string;
+  readonly label: string;
+}>): ReadonlyArray<string>;
+/** The facts one note is written from. */
+interface ContinuationNoteInput {
+  readonly profile: ContinuationProfile;
+  /** 1-based. */
+  readonly continuation: number;
+  /** The verdict this turn ended on; absent when no result has reached the check. */
+  readonly verdict?: CheckVerdict;
+  /** The verdict the previous note reported, for what changed. */
+  readonly previous?: CheckVerdict;
+  /** Check reads so far, the unavailable ones included. */
+  readonly reads: number;
+  /** `verbatim` only when the policy and the check both allow the FAIL lines. */
+  readonly failures: 'verbatim' | 'off';
+  readonly findings?: ReadonlyArray<AdmittedFinding>;
+  readonly bar?: {
+    readonly best?: ContinuationPolicy['best'];
+    readonly reference?: string;
+  };
+  readonly appended?: ReadonlyArray<{
+    readonly heading: string;
+    readonly text: string;
+  }>;
+  /** What the run owes, from the check's description. */
+  readonly owed?: string;
+  readonly progress: DriverProgressMark;
+  /** Whether `read_continuation` is served to this manager. */
+  readonly canReadMore: boolean;
+  /** Whether the check's score comes from cases the director cannot see. */
+  readonly sealed?: boolean;
+}
+/**
+ * Write one continuation note, sections 1 to 8 of docs/38. Section 9, the run's state, is
+ * `composeReentryTask`, which wraps this text. Pure: the same input writes the same note.
+ */
+declare function composeContinuationNote(input: ContinuationNoteInput): string;
+/** One continuation as the settle record carries it (`DriverContinuationRecord.continuations`). */
+interface ContinuationEntry {
+  /** 1-based. */
+  readonly continuation: number;
+  /** The driver attempt whose end this note answered. */
+  readonly attempt: number;
+  /** sha256 of the note's text. */
+  readonly noteDigest: string;
+  readonly profile: string;
+  readonly switches: {
+    readonly failures: 'verbatim' | 'off';
+    readonly panel: 'on' | 'off';
+    readonly bar: 'on' | 'off';
+  };
+  /** The verdict the note reported: `null` when no result had reached the check. */
+  readonly before: VerdictSummary | null;
+  /** The verdict at the director's next turn end: `null` when the run ended first. */
+  readonly after: VerdictSummary | null;
+  /** The panel's part: questions asked, findings admitted, dollars (`null` = unknown). */
+  readonly panel?: {
+    readonly asked: number;
+    readonly proposed: number;
+    readonly admitted: number;
+    readonly usd: number | null;
+  };
+  /** Sections a play appended. */
+  readonly appended: number;
+}
+interface VerdictSummary {
+  readonly pass: boolean;
+  readonly composite?: number;
+  readonly failed?: number;
+  readonly total?: number;
+}
+/** A run directory's continuation files: the root's at `<runDir>/continuations/<n>/`, a nested
+ *  manager's at `<runDir>/continuations/managers/<owner>/<n>/`. */
+declare const CONTINUATIONS_DIR = "continuations";
+/** The readout a continuation is composed from. */
+interface ContinuationContext {
+  /** The attempt that just completed, 1-based. */
+  readonly attempt: number;
+  /** Continuations this run has already sent. */
+  readonly continuations: number;
+  /** The mark read after the completed drive. */
+  readonly progress: DriverProgressMark;
+  readonly budget: DriverBudgetReadout;
+  /** Re-entered drives in a row, this one included, that ended without progress. */
+  readonly barrenReentries: number;
+  readonly signal: AbortSignal;
+}
+//#endregion
 //#region src/runtime/supervise/upstream-unavailable.d.ts
 /** How long an agent waits after its upstream refused a turn for capacity: the codes and
  *  statuses `upstreamUnavailableSignal` reads. A pause is not a failure: a driver spends neither
@@ -2059,15 +2375,16 @@ interface DriverAttemptRecord {
   readonly unavailableSignal?: string;
   /** The completion check's verdict after this attempt. Absent when the caller declares none. */
   readonly contract?: DriverContractState;
-  /** True when this COMPLETED attempt's unmet contract sent the loop back into the live session. */
+  /** True when this COMPLETED attempt's unmet contract sent the loop back with a continuation. */
   readonly reprompted?: boolean;
   /** Why an unmet contract did NOT re-enter the session. Absent when the contract was met, when
-   *  the caller configured no re-prompt, or when the re-prompt was issued. */
+   *  the manager has no continuation policy, or when the continuation was sent. */
   readonly repromptRefusedBy?: DriverRepromptRefusal;
 }
 /** Why a completed drive with an unmet contract was not re-entered. `no-progress` means
- *  `reprompt.maxBarren` consecutive re-entered drives completed without a delivery. */
-type DriverRepromptRefusal = 'reprompts-exhausted' | 'caller-stop' | Extract<DriverAttemptStop, 'aborted' | 'budget-exhausted' | 'deadline' | 'max-attempts' | 'no-progress'>;
+ *  `continuation.maxBarren` consecutive re-entered drives completed without progress. `closed`
+ *  means the run was already closed: a failed `report_blocked` probe or a progress stop rule. */
+type DriverRepromptRefusal = 'closed' | Extract<DriverAttemptStop, 'aborted' | 'budget-exhausted' | 'deadline' | 'max-attempts' | 'no-progress'>;
 /** The comparable mark used to decide whether an attempt moved the run TOWARD ITS DELIVERABLE.
  *  While a declared check is unmet, spend and settlements are not progress on their own; see this
  *  file's header for the measurement that made that the rule. */
@@ -2088,19 +2405,22 @@ interface DriverProgressMark {
   /** Monotone count of settled children that PASSED the completion check. A child that ran and
    *  settled without delivering does not count here, which is the whole point. */
   readonly deliveredCount?: number;
+  /** The best composite any check read has scored so far. A rise is progress: the director moved
+   *  the outside check even though it has not passed. */
+  readonly composite?: number;
 }
 /** Why the loop is entering the driver again. Absent on the first attempt only.
  *
- *  An `unmet-contract` re-entry carries the unmet items. A `driver-failure` re-entry carries no
- *  instruction of its own: the drive that failed may never have read the last one, so the caller
- *  re-enters with the ORIGINAL task and the run's state, never with the unmet-items text alone. */
+ *  An `unmet-contract` re-entry carries Runtime's continuation note. A `driver-failure` re-entry
+ *  carries no instruction of its own: the drive that failed may never have read the last one, so
+ *  the caller re-enters with the ORIGINAL task and the run's state, never with the note alone. */
 type DriverReentry = {
   readonly reason: 'unmet-contract';
-  /** The unmet items. Whether they are the whole turn depends on where the drive runs: only a
-   *  backend that proves the same harness session may be re-entered with this text alone. */
+  /** The continuation note. Whether it is the whole turn depends on where the drive runs: only
+   *  a backend that proves the same harness session may be re-entered with this text alone. */
   readonly steer: string;
-  /** 1-based: which re-prompt this is. */
-  readonly reprompt: number;
+  /** 1-based: which continuation this is. */
+  readonly continuation: number;
 } | {
   readonly reason: 'driver-failure';
   /** The failure that ended the previous drive, as recorded. */
@@ -2108,61 +2428,15 @@ type DriverReentry = {
   /** 1-based: which failure retry this is. */
   readonly retry: number;
 } | {
-  /** The upstream refused the previous drive for capacity, and the loop paused before this
-   *  one. Re-entered like a failure, with the original task and the run's state. */
+  /** The upstream refused the previous drive for capacity, or the check could not run, and the
+   *  loop paused before this one. Re-entered like a failure, with the original task and the
+   *  run's state. */
   readonly reason: 'upstream-unavailable';
   /** The code or status that classified the refusal, such as `provider_quota_exhausted`. */
   readonly signal: string;
   /** 1-based: which pause this is. */
   readonly pause: number;
 };
-/** What the caller sees when a drive returns with its completion check unmet. */
-interface DriverUnmetContractContext {
-  /** The attempt that just completed, 1-based. */
-  readonly attempt: number;
-  /** How many re-prompts this run has already issued. */
-  readonly reprompts: number;
-  readonly maxReprompts: DriverRepromptPolicy['maxReprompts'];
-  /** The mark read AFTER the completed drive. */
-  readonly progress: DriverProgressMark;
-  readonly budget: DriverBudgetReadout;
-  /** What the run was supposed to produce, from the caller's completion check. */
-  readonly describe?: string;
-  /** Consecutive re-entered drives, this one included, that completed without a delivery. */
-  readonly barrenReentries: number;
-}
-/** The caller's answer: re-enter the session with `steer`, or end the run here. */
-type DriverUnmetContractDecision = {
-  readonly steer: string;
-} | 'stop';
-/** Compose the re-entry instruction for a completed drive that delivered nothing, or refuse. */
-type OnUnmetContract = (context: DriverUnmetContractContext) => DriverUnmetContractDecision | Promise<DriverUnmetContractDecision>;
-/** How a completed-but-undelivered drive is re-entered. Absent = the historical behavior, where
- *  such a drive ends the run and only the completion gate's label records what happened. */
-interface DriverRepromptPolicy {
-  /** How many times one run may re-enter its driver with the unmet items. `0` = never.
-   *  `'until-complete'` removes the count cap and requires a finite positive scope deadline.
-   *  Budget, cancellation, explicit stop, the barren bound, and failure retry limits still apply. */
-  readonly maxReprompts: number | 'until-complete';
-  /** Consecutive re-entered drives that may complete without a delivery before re-prompting stops
-   *  (`repromptRefusedBy: 'no-progress'`). Default {@link DEFAULT_MAX_BARREN_REPROMPTS}; minimum 1.
-   *  A delivery — an accepted submission, a child that passed its check, the contract turning
-   *  met — resets the count. */
-  readonly maxBarren?: number;
-  /** Compose the instruction, or return `'stop'`. Omit = {@link defaultUnmetContractSteer}. */
-  readonly onUnmetContract?: OnUnmetContract;
-  /** What the run owes, surfaced in the default instruction. */
-  readonly describe?: string;
-}
-/**
- * The instruction a completed-but-undelivered drive is re-entered with when the caller supplies no
- * `onUnmetContract`. It states the verdict, names what is owed, reports the ledger, and gives the
- * three steps — the same shape `depthStrategy` re-prompts a resumed session with, said in the
- * driver's own terms.
- */
-declare function defaultUnmetContractSteer(context: DriverUnmetContractContext): string;
-/** Two re-prompted drives in a row that deliver nothing end the re-prompts. */
-declare const DEFAULT_MAX_BARREN_REPROMPTS = 2;
 /**
  * How one driver failure is answered.
  *
@@ -2232,11 +2506,15 @@ interface DriverContinuationRecord extends DriverLoopRecord {
   /** Re-entries that ran in a new environment because the provider no longer held the old one. */
   readonly environmentReplacements: number;
   /** How the run was closed, when something closed it: an accepted `submit_result`, the
-   *  manager's own `stop`, a `report_blocked` whose probe failed, or the caller's progress
-   *  `stopRule`. Absent when the loop ended on a bound or a failure. */
+   *  manager's own `stop` (served only to a manager with no check), a `report_blocked` whose
+   *  probe failed, or the caller's progress `stopRule`. Absent when the loop ended on a bound or a
+   *  failure. */
   readonly closedBy?: 'result-accepted' | 'stop' | 'blocked' | 'stop-rule';
   /** The reason the manager gave, or the failed probe, verbatim. */
   readonly stopReason?: string;
+  /** Every continuation note this manager was sent, with the check's verdict before and after it.
+   *  Empty for a manager with no check. */
+  readonly continuations: ReadonlyArray<ContinuationEntry>;
 }
 /** Count a loop's attempt records into its {@link DriverLoopRecord}. */
 declare function summarizeDriverAttempts(records: ReadonlyArray<DriverAttemptRecord>): DriverLoopRecord;
@@ -4976,6 +5254,8 @@ interface SpawnJournal {
   loadTree(root: NodeId): Promise<SpawnEvent[] | undefined>;
   beginTree(root: NodeId, at: string): Promise<void>;
   appendEvent(root: NodeId, ev: SpawnEvent): Promise<void>;
+  /** Publish all events together or none; SQL contexts use this for initialization records. */
+  appendEvents?(root: NodeId, events: ReadonlyArray<SpawnEvent>): Promise<void>;
 }
 /** Content-addressed result blobs (the `outRef` → artifact map) backing the replay
  *  invariant. Split from the journal so the journal stays small (decisions) and the
@@ -5310,6 +5590,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** The root manager's native harness session, persisted like a child's receipt. A child's
+   *  receipt rides its settle record and the root has none, so the result carries it. Absent
+   *  for a router-brained root, which runs no driver. */
+  readonly rootHarnessTranscript?: HarnessTranscriptEvidence;
   /** What the root's external driver loop did: genuine continuations, failure retries,
    *  environment replacements, why the loop ended, and how the root closed the run. Absent for
    *  a router-brained root, which runs no driver loop. */
@@ -5357,6 +5641,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** The root manager's native harness session, persisted like a child's receipt. A child's
+   *  receipt rides its settle record and the root has none, so the result carries it. Absent
+   *  for a router-brained root, which runs no driver. */
+  readonly rootHarnessTranscript?: HarnessTranscriptEvidence;
   /** What the root's external driver loop did: genuine continuations, failure retries,
    *  environment replacements, why the loop ended, and how the root closed the run. Absent for
    *  a router-brained root, which runs no driver loop. */
@@ -5427,6 +5715,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** The root manager's native harness session, persisted like a child's receipt. A child's
+   *  receipt rides its settle record and the root has none, so the result carries it. Absent
+   *  for a router-brained root, which runs no driver. */
+  readonly rootHarnessTranscript?: HarnessTranscriptEvidence;
   /** What the root's external driver loop did: genuine continuations, failure retries,
    *  environment replacements, why the loop ended, and how the root closed the run. Absent for
    *  a router-brained root, which runs no driver loop. */
@@ -5499,5 +5791,5 @@ interface WidenGate<Out> {
   readonly judgeExempt?: boolean;
 }
 //#endregion
-export { SpawnJournal as $, LoopTraceEvent as $i, HarnessTranscriptCapture as $n, RetainedInteractiveAdmission as $r, loopEventToOtelSpan as $t, NodeExecutionIdentity as A, OpenAIChatResponseFormat as Aa, ReservationWaitRefused as Ai, TraceSource as An, AgentEvalError$1 as Ar, createPropagatingTraceEmitter as At, ResultBlobStore as B, LoopEndedPayload as Bi, ScopeProgressInput as Bn, RetainedRunDispatchBindingError as Br, OtelAttribute as Bt, ExecutorToolCall as C, AgentRuntimeEventSink as Ca, LeakedReservation as Ci, pollFor as Cn, DriverUnmetContractDecision as Cr, WorkerTraceResolver as Ct, MaterializedExecutionIdentity as D, AgentTaskStatus as Da, ReservationShortfall as Di, SessionMessageLike as Dn, summarizeDriverAttempts as Dr, workerTraceHeaders as Dt, HeldEnvironment as E, AgentTaskSpec as Ea, ReservationRejection as Ei, waitUntil as En, defaultUnmetContractSteer as Er, workerTraceEnv as Et, ProviderModelAttemptEvidence as F, RuntimeCanonicalStreamEvent as Fa, DefaultVerdict$1 as Fi, RetainedPendingCause as Fn, NotFoundError as Fr, EvalRunGeneration as Ft, RootMaterialization as G, LoopPlanDescription as Gi, ReconnectRetainedInteractiveRunOptions as Gn, createWorkerSlots as Gr, RuntimeEventOtelOptions as Gt, ResumedWork as H, LoopIterationEndedPayload as Hi, WorkerProgress as Hn, ValidationError as Hr, OtelExportStats as Ht, ProviderModelExecutionEvidence as I, RuntimeSession as Ia, Driver as Ii, ActivityLog as In, PlannerError as Ir, EvalRunsExportConfig as It, RootStreamReceipt as J, LoopSandboxPlacement as Ji, RetainedInteractiveEnvironmentInput as Jn, NativeContextContinuationInput as Jr, buildRuntimeEventOtelSpans as Jt, RootProviderModelEvidence as K, LoopPlanPayload as Ki, RecoverRetainedInteractiveRunOptions as Kn, NativeContextContinuationExecution as Kr, buildLoopOtelSpans as Kt, RecursiveReservationPolicy as L, RuntimeSessionStore as La, ExecCtx as Li, ActivityNote as Ln, RetainedInteractiveAdmissionError as Lr, EvalRunsExportResult as Lt, NodeSnapshot as M, OpenAIChatToolChoice as Ma, createBudgetPool as Mi, decodeToolPart as Mn, BackendTransportError as Mr, readTraceContextFromEnv as Mt, NodeStatus as N, RunAgentTaskOptions as Na, spendFromUsageEvents as Ni, sandboxSessionTraceSource as Nn, ConfigError as Nr, traceContextToEnv as Nt, MaterializedModelIdentity as O, BackendErrorDetail as Oa, ReservationStage as Oi, SessionTraceBox as On, upstreamUnavailableSignal as Or, workerTraceSeamKey as Ot, ProfileMaterializationReceipt as P, RunAgentTaskStreamOptions as Pa, AgentRunSpec as Pi, RetainedChildRecovery as Pn, JudgeError as Pr, EvalRunEvent as Pt, SpawnEvent as Q, LoopTraceEmitter as Qi, HarnessTranscriptArtifact as Qn, RecoverRetainedRunResult as Qr, generateSpanId as Qt, ResourceLimit as R, RuntimeStreamEvent as Ra, Iteration as Ri, DEFAULT_STALL_AFTER_MS as Rn, RetainedInteractiveBindingError as Rr, INTELLIGENCE_WIRE_VERSION as Rt, ExecutorTeardownWarning as S, AgentRuntimeEvent as Sa, BudgetReconcileFault as Si, isWaitOutcome as Sn, DriverUnmetContractContext as Sr, WorkerTraceUnavailableReason as St, Handle as T, AgentTaskRunResult as Ta, ReservationHolder as Ti, validateWaitSpec as Tn, classifyDriverFailure as Tr, readWorkerTraceContext as Tt, RetainedExecutionState as U, LoopIterationStartedPayload as Ui, createActivityLog as Un, SlotPermit as Ur, OtelExporter as Ut, ResumedKeyState as V, LoopIterationDispatchPayload as Vi, TeamProgress as Vn, RuntimeRunStateError as Vr, OtelExportConfig as Vt, RootHandle as W, LoopLineageOptions as Wi, readWorkerProgress as Wn, WorkerSlots as Wr, OtelSpan as Wt, Scope as X, LoopTeardownFailedPayload as Xi, RetainedInteractiveStartMaterial as Xn, RecoverRetainedRunIntentOptions as Xr, createOtelExporter as Xt, Runtime as Y, LoopStartedPayload as Yi, RetainedInteractiveRunHandle as Yn, ReconnectRetainedRunOptions as Yr, createOpenInferenceFileExporter as Yt, Settled as Z, LoopTokenUsage as Zi, StartRetainedInteractiveRunOptions as Zn, RecoverRetainedRunOptions as Zr, exportEvalRuns as Zt, ExecutorMaterialization as _, AgentAdapter as _a, StartRetainedRunInEnvironmentOptions as _i, WaitProbe as _n, DriverProgressMark as _r, WaitOpts as _t, BudgetOverspend as a, SandboxClient as aa, RetainedRunCancelOptions as ai, RuntimeStreamEventSink as an, captureHarnessTranscript as ar, SpendGap as at, ExecutorRegistry as b, AgentExecutionBackend as ba, BudgetPoolRestore as bi, WaitSpec as bn, DriverRepromptRefusal as br, WorkerInteractiveUnavailableReason as bt, EnvironmentTeardownReceipt as c, Validator as ca, RetainedRunEffect as ci, SanitizedKnowledgeReadinessReport as cn, DEFAULT_MAX_BARREN_REPROMPTS as cr, SubtreeSummary as ct, ExecutorAccounting as d, RuntimeRunHandle as da, RetainedRunHandle as di, createRuntimeStreamEventCollector as dn, DriverAttemptsExhaustedError as dr, SupervisorOpts as dt, LoopWinner as ea, RetainedInteractiveEnvironmentAdmission as ei, padSpanId as en, HarnessTranscriptEvidence as er, SpawnOpts as et, ExecutorCancellation as f, RuntimeRunOptions as fa, RetainedRunIntentAdmission as fi, sanitizeAgentRuntimeEvent as fn, DriverBudgetReadout as fr, TokenUsageProvenance as ft, ExecutorFactory as g, startRuntimeRun as ga, RetainedRunTurnInput as gi, WaitOutcome as gn, DriverLoopRecord as gr, UsageEvent as gt, ExecutorExecutionBinding as h, RuntimeRunStatus as ha, RetainedRunStartMaterial as hi, PendingWait as hn, DriverFailureClass as hr, UnknownMaterializationReason as ht, Budget as i, RunProvenance as ia, RetainedRunAdmissionHook as ii, RuntimeStreamEventCollector as in, ReadableEnvironment as ir, SpendChannel as it, NodeId as j, OpenAIChatTool as ja, ReserveOptions as ji, createPushTraceSource as jn, AgentEvalErrorCode as jr, mergeTraceEnv as jt, NoWinnerError as k, KnowledgeReadinessDecision as ka, ReservationTicket as ki, ToolStepInput as kn, UnavailablePausePolicy as kr, TraceContext as kt, ExecutionBindingReceipt as l, RuntimeRunCompleteInput as la, RetainedRunEnvironmentAdmission as li, SanitizedKnowledgeRequirement as ln, DriverAttemptRecord as lr, SupervisedResult as lt, ExecutorContext as m, RuntimeRunRow as ma, RetainedRunSnapshot as mi, sanitizeRuntimeStreamEvent as mn, DriverContractState as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, MountRecorder as na, RetainedInteractiveStartedAdmission as ni, toOtelAttributes as nn, HarnessTranscriptUnavailable as nr, SpawnRejection as nt, BudgetViolation as o, SelectionReceipt as oa, RetainedRunCancellation as oi, RuntimeStreamEventSummary as on, harnessTranscriptArtifact as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, RuntimeRunPersistenceAdapter as pa, RetainedRunReplayPoint as pi, sanitizeKnowledgeReadinessReport as pn, DriverContinuationRecord as pr, TreeView as pt, RootSignal as q, LoopResult as qi, RetainedInteractiveAdmissionHook as qn, NativeContextContinuationHandle as qr, buildLoopSpanNodes as qt, AgentSpec as r, OutputAdapter as ra, RetainedRunAdmission as ri, RuntimeEventCollector as rn, HarnessTranscriptUnavailableReason as rr, Spend as rt, DefaultVerdict as s, ValidationCtx as sa, RetainedRunDispatchedAdmission as si, RuntimeTelemetryOptions as sn, persistHarnessTranscript as sr, SubtreeResult as st, Agent as t, MountManifestEntry as ta, RetainedInteractiveIntentAdmission as ti, padTraceId as tn, HarnessTranscriptFile as tr, SpawnPrior as tt, Executor as u, RuntimeRunCost as ua, RetainedRunEventOptions as ui, createRuntimeEventCollector as un, DriverAttemptStop as ur, Supervisor as ut, ExecutorNodeContext as v, AgentBackendContext as va, StartRetainedRunOptions as vi, WaitProbeRegistry as vn, DriverReentry as vr, WidenGate as vt, FleetYield as w, AgentTaskContext as wa, ReservationFloor as wi, timerAt as wn, OnUnmetContract as wr, WorkerTraceSeamCarrier as wt, ExecutorResult as x, AgentKnowledgeProvider as xa, BudgetReadout as xi, createWaitProbes as xn, DriverRetryPolicy as xr, WorkerTraceEvidence as xt, ExecutorProgressEvent as y, AgentBackendInput as ya, BudgetPool as yi, WaitRejection as yn, DriverRepromptPolicy as yr, WorkerInteractiveSession as yt, ResourceSpend as z, LoopDecisionPayload as zi, ExecutorProgress as zn, RetainedRunAdmissionError as zr, LoopSpanNode as zt };
-//# sourceMappingURL=types-Bo7z5aG5.d.ts.map
+export { SpawnJournal as $, RunAgentTaskOptions as $a, spendFromUsageEvents as $i, HarnessTranscriptCapture as $n, ConfigError as $r, loopEventToOtelSpan as $t, NodeExecutionIdentity as A, RuntimeRunCost as Aa, RetainedRunEventOptions as Ai, TraceSource as An, ContinuationAppend as Ar, createPropagatingTraceEmitter as At, ResultBlobStore as B, AgentExecutionBackend as Ba, BudgetPoolRestore as Bi, ScopeProgressInput as Bn, VerdictSummary as Br, OtelAttribute as Bt, ExecutorToolCall as C, OutputAdapter as Ca, RetainedRunAdmission as Ci, pollFor as Cn, UnavailablePausePolicy as Cr, WorkerTraceResolver as Ct, MaterializedExecutionIdentity as D, ValidationCtx as Da, RetainedRunDispatchedAdmission as Di, SessionMessageLike as Dn, CheckRead as Dr, workerTraceHeaders as Dt, HeldEnvironment as E, SelectionReceipt as Ea, RetainedRunCancellation as Ei, waitUntil as En, CONTINUATION_FACTS as Er, workerTraceEnv as Et, ProviderModelAttemptEvidence as F, RuntimeRunStatus as Fa, RetainedRunStartMaterial as Fi, RetainedPendingCause as Fn, ContinuationPanelInput as Fr, EvalRunGeneration as Ft, RootMaterialization as G, AgentTaskRunResult as Ga, ReservationHolder as Gi, ReconnectRetainedInteractiveRunOptions as Gn, distillFindings as Gr, RuntimeEventOtelOptions as Gt, ResumedWork as H, AgentRuntimeEvent as Ha, BudgetReconcileFault as Hi, WorkerProgress as Hn, admitFinding as Hr, OtelExportStats as Ht, ProviderModelExecutionEvidence as I, startRuntimeRun as Ia, RetainedRunTurnInput as Ii, ActivityLog as In, ContinuationPanelResult as Ir, EvalRunsExportConfig as It, RootStreamReceipt as J, BackendErrorDetail as Ja, ReservationStage as Ji, RetainedInteractiveEnvironmentInput as Jn, passedItems as Jr, buildRuntimeEventOtelSpans as Jt, RootProviderModelEvidence as K, AgentTaskSpec as Ka, ReservationRejection as Ki, RecoverRetainedInteractiveRunOptions as Kn, expandQuestions as Kr, buildLoopOtelSpans as Kt, RecursiveReservationPolicy as L, AgentAdapter as La, StartRetainedRunInEnvironmentOptions as Li, ActivityNote as Ln, ContinuationPolicy as Lr, EvalRunsExportResult as Lt, NodeSnapshot as M, RuntimeRunOptions as Ma, RetainedRunIntentAdmission as Mi, decodeToolPart as Mn, ContinuationEntry as Mr, readTraceContextFromEnv as Mt, NodeStatus as N, RuntimeRunPersistenceAdapter as Na, RetainedRunReplayPoint as Ni, sandboxSessionTraceSource as Nn, ContinuationNoteInput as Nr, traceContextToEnv as Nt, MaterializedModelIdentity as O, Validator as Oa, RetainedRunEffect as Oi, SessionTraceBox as On, CheckUnavailableError as Or, workerTraceSeamKey as Ot, ProfileMaterializationReceipt as P, RuntimeRunRow as Pa, RetainedRunSnapshot as Pi, RetainedChildRecovery as Pn, ContinuationPanel as Pr, EvalRunEvent as Pt, SpawnEvent as Q, OpenAIChatToolChoice as Qa, createBudgetPool as Qi, HarnessTranscriptArtifact as Qn, BackendTransportError as Qr, generateSpanId as Qt, ResourceLimit as R, AgentBackendContext as Ra, StartRetainedRunOptions as Ri, DEFAULT_STALL_AFTER_MS as Rn, ContinuationProfile as Rr, INTELLIGENCE_WIRE_VERSION as Rt, ExecutorTeardownWarning as S, MountRecorder as Sa, RetainedInteractiveStartedAdmission as Si, isWaitOutcome as Sn, upstreamUnavailableSignal as Sr, WorkerTraceUnavailableReason as St, Handle as T, SandboxClient as Ta, RetainedRunCancelOptions as Ti, validateWaitSpec as Tn, CONTINUATIONS_DIR as Tr, readWorkerTraceContext as Tt, RetainedExecutionState as U, AgentRuntimeEventSink as Ua, LeakedReservation as Ui, createActivityLog as Un, checkVerdictOf as Ur, OtelExporter as Ut, ResumedKeyState as V, AgentKnowledgeProvider as Va, BudgetReadout as Vi, TeamProgress as Vn, admitContinuationPolicy as Vr, OtelExportConfig as Vt, RootHandle as W, AgentTaskContext as Wa, ReservationFloor as Wi, readWorkerProgress as Wn, composeContinuationNote as Wr, OtelSpan as Wt, Scope as X, OpenAIChatResponseFormat as Xa, ReservationWaitRefused as Xi, RetainedInteractiveStartMaterial as Xn, AgentEvalError$1 as Xr, createOtelExporter as Xt, Runtime as Y, KnowledgeReadinessDecision as Ya, ReservationTicket as Yi, RetainedInteractiveRunHandle as Yn, verdictFromJudgeScore as Yr, createOpenInferenceFileExporter as Yt, Settled as Z, OpenAIChatTool as Za, ReserveOptions as Zi, StartRetainedInteractiveRunOptions as Zn, AgentEvalErrorCode as Zr, exportEvalRuns as Zt, ExecutorMaterialization as _, LoopTokenUsage as _a, RecoverRetainedRunOptions as _i, WaitProbe as _n, DriverReentry as _r, WaitOpts as _t, BudgetOverspend as a, LoopDecisionPayload as aa, RetainedRunAdmissionError as ai, RuntimeStreamEventSink as an, captureHarnessTranscript as ar, SpendGap as at, ExecutorRegistry as b, LoopWinner as ba, RetainedInteractiveEnvironmentAdmission as bi, WaitSpec as bn, classifyDriverFailure as br, WorkerInteractiveUnavailableReason as bt, EnvironmentTeardownReceipt as c, LoopIterationEndedPayload as ca, ValidationError as ci, SanitizedKnowledgeReadinessReport as cn, DriverAttemptRecord as cr, SubtreeSummary as ct, ExecutorAccounting as d, LoopPlanDescription as da, createWorkerSlots as di, createRuntimeStreamEventCollector as dn, DriverBudgetReadout as dr, SupervisorOpts as dt, AgentRunSpec as ea, JudgeError as ei, padSpanId as en, RunAgentTaskStreamOptions as eo, HarnessTranscriptEvidence as er, SpawnOpts as et, ExecutorCancellation as f, LoopPlanPayload as fa, NativeContextContinuationExecution as fi, sanitizeAgentRuntimeEvent as fn, DriverContinuationRecord as fr, TokenUsageProvenance as ft, ExecutorFactory as g, LoopTeardownFailedPayload as ga, RecoverRetainedRunIntentOptions as gi, WaitOutcome as gn, DriverProgressMark as gr, UsageEvent as gt, ExecutorExecutionBinding as h, LoopStartedPayload as ha, ReconnectRetainedRunOptions as hi, PendingWait as hn, DriverLoopRecord as hr, UnknownMaterializationReason as ht, Budget as i, Iteration as ia, RetainedInteractiveBindingError as ii, RuntimeStreamEventCollector as in, RuntimeStreamEvent as io, ReadableEnvironment as ir, SpendChannel as it, NodeId as j, RuntimeRunHandle as ja, RetainedRunHandle as ji, createPushTraceSource as jn, ContinuationContext as jr, mergeTraceEnv as jt, NoWinnerError as k, RuntimeRunCompleteInput as ka, RetainedRunEnvironmentAdmission as ki, ToolStepInput as kn, CheckVerdict as kr, TraceContext as kt, ExecutionBindingReceipt as l, LoopIterationStartedPayload as la, SlotPermit as li, SanitizedKnowledgeRequirement as ln, DriverAttemptStop as lr, SupervisedResult as lt, ExecutorContext as m, LoopSandboxPlacement as ma, NativeContextContinuationInput as mi, sanitizeRuntimeStreamEvent as mn, DriverFailureClass as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, Driver as na, PlannerError as ni, toOtelAttributes as nn, RuntimeSession as no, HarnessTranscriptUnavailable as nr, SpawnRejection as nt, BudgetViolation as o, LoopEndedPayload as oa, RetainedRunDispatchBindingError as oi, RuntimeStreamEventSummary as on, harnessTranscriptArtifact as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, LoopResult as pa, NativeContextContinuationHandle as pi, sanitizeKnowledgeReadinessReport as pn, DriverContractState as pr, TreeView as pt, RootSignal as q, AgentTaskStatus as qa, ReservationShortfall as qi, RetainedInteractiveAdmissionHook as qn, failedItems as qr, buildLoopSpanNodes as qt, AgentSpec as r, ExecCtx as ra, RetainedInteractiveAdmissionError as ri, RuntimeEventCollector as rn, RuntimeSessionStore as ro, HarnessTranscriptUnavailableReason as rr, Spend as rt, DefaultVerdict as s, LoopIterationDispatchPayload as sa, RuntimeRunStateError as si, RuntimeTelemetryOptions as sn, persistHarnessTranscript as sr, SubtreeResult as st, Agent as t, DefaultVerdict$1 as ta, NotFoundError as ti, padTraceId as tn, RuntimeCanonicalStreamEvent as to, HarnessTranscriptFile as tr, SpawnPrior as tt, Executor as u, LoopLineageOptions as ua, WorkerSlots as ui, createRuntimeEventCollector as un, DriverAttemptsExhaustedError as ur, Supervisor as ut, ExecutorNodeContext as v, LoopTraceEmitter as va, RecoverRetainedRunResult as vi, WaitProbeRegistry as vn, DriverRepromptRefusal as vr, WidenGate as vt, FleetYield as w, RunProvenance as wa, RetainedRunAdmissionHook as wi, timerAt as wn, AdmittedFinding as wr, WorkerTraceSeamCarrier as wt, ExecutorResult as x, MountManifestEntry as xa, RetainedInteractiveIntentAdmission as xi, createWaitProbes as xn, summarizeDriverAttempts as xr, WorkerTraceEvidence as xt, ExecutorProgressEvent as y, LoopTraceEvent as ya, RetainedInteractiveAdmission as yi, WaitRejection as yn, DriverRetryPolicy as yr, WorkerInteractiveSession as yt, ResourceSpend as z, AgentBackendInput as za, BudgetPool as zi, ExecutorProgress as zn, PanelFinding as zr, LoopSpanNode as zt };
+//# sourceMappingURL=types-DMRc3jru.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.271.0",
+  "version": "0.273.3",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {
@@ -98,7 +98,7 @@
     "@arethetypeswrong/cli": "0.18.5",
     "@biomejs/biome": "^2.5.11",
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@tangle-network/agent-eval": "0.187.0",
+    "@tangle-network/agent-eval": "0.190.1",
     "@tangle-network/agent-interface": "^2.11.0",
     "@tangle-network/sandbox": ">=0.36.4 <0.48.0",
     "@types/node": "26.4.0",
@@ -121,15 +121,15 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@tangle-network/agent-eval": ">=0.185.0 <0.188.0",
+    "@tangle-network/agent-eval": ">=0.188.0 <0.191.0",
     "@tangle-network/agent-interface": "^2.11.0",
     "@tangle-network/sandbox": ">=0.36.4 <0.48.0 || ^0.49.0-0 || ^0.50.0 || ^0.51.0 || ^0.52.0"
   },
   "dependencies": {
     "@tangle-network/agent-core": ">=0.9.6 <0.10.0",
-    "@tangle-network/agent-knowledge": "^17.1.3",
+    "@tangle-network/agent-knowledge": "^17.1.5",
     "@tangle-network/agent-profile-materialize": ">=0.20.1 <0.21.0",
-    "@tangle-network/agent-trace-contract": "^1.0.2",
+    "@tangle-network/agent-trace-contract": "^1.2.0",
     "tar-stream": "3.2.1"
   },
   "scripts": {