@basein/runner 0.3.14 → 0.3.16

package/dist/replay/controller.d.ts

@@ -435,6 +435,24 @@ export interface ReplayState {
     sharedWith: string[];
     /** Set when the plan handed the task to the model part-way (fallbk.md). */
     handover?: Handover;
+    /**
+     * Every planned step ran and the model was handed the results to answer
+     * from: a steered plan whose last step threaded, a direct run that ran to
+     * its end, or a divergence whose bundle carried the rest of the chain. A
+     * call the model makes of its own after this is the task done again — it
+     * did not take the plan's result as the answer (the service's newestRun.md
+     * N7). Never set on a plan that handed over: the hand-over says the rest
+     * is the model's.
+     */
+    ranToEnd?: boolean;
+    /**
+     * A divergence is running the plan's remaining steps for real (§8). The
+     * plan is already retired by then, so this is what tells a call made beside
+     * that work from one made after it: a repeat never opens while steps are
+     * still landing, and whether the plan ran to its end or handed over is not
+     * known yet (the service's newestRun.md N7).
+     */
+    diverging?: boolean;
     /**
      * Which gate declined, as a fixed code (segmented.md R-HIT-14). The prose
      * `why` that `decline()` logs stays free text; this is what code reads — the
@@ -496,6 +514,60 @@ export interface ReplayState {
      * sample of what the task costs unaided.
      */
     hostStop?: HostStop;
+    /**
+     * The served chain's revision, for the mark on the plan's own calls when
+     * they are recorded into the turn's newest run (autocorrect.md AC2).
+     */
+    chainRevision?: number;
+    /**
+     * Keep every call this plan makes, whole, for the turn's newest run: set by
+     * the control server on a prompt plan whose match offered to record the
+     * turn as a repeat. A plan that runs to its end and is then redone by the
+     * agent has its calls recorded first into that repeat (AC2) — the report's
+     * copies are cut to 3,800 bytes, and the agent's work is built on them.
+     */
+    keepCalls?: boolean;
+    /**
+     * Those calls, in the order the plan made them, keyed by frame and step —
+     * a sub-task called twice keeps both calls of each step.
+     */
+    turnCalls?: Map<string, TurnCall>;
+    /** What they hold, in characters: bounded by {@link TURN_CALLS_MAX_CHARS}. */
+    turnCallChars?: number;
+    /**
+     * Steer mode: the steps a test just left out (AC5), and the note that tells
+     * the model so — riding on the `PostToolUse` that moved the cursor past
+     * them, or given in place of a call the model makes to one of them.
+     */
+    skipNote?: {
+        text: string;
+        tools: Set<string>;
+        delivered: boolean;
+        refused?: number;
+        /**
+         * It says the sequence is complete — the steps left out were the plan's
+         * last. The only note that outlives the plan: every other one names a step
+         * to call next, which a retired plan no longer has (AC5 review).
+         */
+        complete?: boolean;
+    };
+}
+/**
+ * One of a plan's own calls, kept whole for the turn's newest run (the
+ * service's autocorrect.md AC2): redacted and capped like a recorded call,
+ * never cut to what a report carries.
+ */
+export interface TurnCall {
+    scenarioId: string;
+    stepIndex: number;
+    chainRevision: number | null;
+    toolName: string;
+    /** Serialized and redacted, at most 64 KiB, as a recorded call's input is. */
+    input: string;
+    /** The tool's answer, when it gave one; on the same terms. */
+    output?: string;
+    /** What it reported instead, when it failed. */
+    error?: string;
 }
 /**
  * Why a match did not arm. One code per gate of the ladder, so the caller can
@@ -504,10 +576,21 @@ export interface ReplayState {
 export type DeclineCode = "replay_disabled" | "not_ready" | "flatten_failed" | "known_bad_first_step" | "nondeterministic_first_step" | "unusable_first_step" | "coverage" | "missing_target" | "no_derive_key"
 /** The service handed over no plan: this runner is too old for it. */
  | "runner_update_required"
+/**
+ * The service handed over no plan: it holds it, because the agent did the
+ * task again after the plan's last run (the service's autocorrect.md AC4).
+ */
+ | "held"
 /** The session's host only records: its adapter asked for no plan with the prompt. */
  | "host_records_only"
 /** The plan names a tool the host's agent does not hold. */
  | "host_tool_missing"
+/**
+ * The plan has steps that run only when a test says so (the service's
+ * autocorrect.md AC5), and the session's host is another app, whose adapter
+ * steps through a plan call by call and knows no tests yet.
+ */
+ | "host_tests_unsupported"
 /**
  * No gate said no: the plan was good, and late. Not ready when the prompt
  * had to be answered (`arm_timeout`), or ready just after it had been
@@ -768,6 +851,50 @@ export declare class ReplayController {
      * ({@link pinFailure}). `how` lets the caller say so outright.
      */
     postTool(state: ReplayState, toolUseId: string, output: string, failed?: string, how?: PostToolOptions): boolean;
+    /**
+     * A steer plan whose cursor reached its end: in front of a parked step (or a
+     * call the service could not answer), which hands over; otherwise it ran to
+     * its end — and from here every call is the model's own.
+     */
+    private finishSteer;
+    /**
+     * Move a plan's own cursor past the steps this request does not need, and
+     * act on what its tests decide (the service's autocorrect.md AC5). Every
+     * verdict is recorded as it is made. `stopped` means the plan handed over —
+     * the other half, a test that could not answer, or no step needed at all —
+     * and its note waits in {@link takeNote}. Otherwise the steps left out are
+     * named in a note for the model ({@link takeSkipNote}), and the caller goes
+     * on: a step is due, or the plan is done.
+     *
+     * Nothing at all for a plan without tests, which behaves exactly as before.
+     */
+    private settleCursor;
+    /** What the model is told about steps a test left out (AC5). */
+    private skipNoteText;
+    /**
+     * The note naming the steps a test just left out, claimed for delivery on a
+     * `PostToolUse` (AC5). Returned once; undefined when there is none.
+     */
+    takeSkipNote(state: ReplayState | undefined): string | undefined;
+    /**
+     * The same note, for a call the model is about to make to one of the steps
+     * it names — when the note has not reached the model yet. The control server
+     * gives it in place of that call, whether the plan is still steering or has
+     * just finished: a step left out must never run because the note was late.
+     */
+    skipNoteFor(state: ReplayState | undefined, toolName: string): string | undefined;
+    /**
+     * The pin guard took a call to the next step as that step: a note still
+     * waiting to say that a step before it was left out has nothing left to
+     * stop, and goes — as it went at the call before the guard existed.
+     */
+    pinTaken(state: ReplayState | undefined): void;
+    /**
+     * The plan's own calls of the turn, whole, in the order it made them — for
+     * the turn's newest run when the agent redoes the task (AC2). Empty unless
+     * the control server asked for them to be kept ({@link ReplayState.keepCalls}).
+     */
+    turnCallsOf(state: ReplayState | undefined): TurnCall[];
     /**
      * The result of a call pinned under a plan that has since handed over
      * because another call ran beside it (`concurrentCall`). Nothing threads —
@@ -836,6 +963,16 @@ export declare class ReplayController {
          * usual cost.
          */
         cutShort?: boolean;
+        /**
+         * The plan ran to its end and the agent redid the task in a repeat the
+         * service took (autocorrect.md AC1): that repeat's id and the agent's
+         * own calls in it. Only the control server knows, and only for the
+         * prompt's plan.
+         */
+        redoneBy?: {
+            runId: string;
+            ownCalls: number;
+        };
     }): ExecutionReport | undefined;
     /**
      * The step a failed replay is fairly blamed on: the first whose own logic
@@ -933,6 +1070,13 @@ export declare class ReplayController {
      * step.
      */
     private stopKindOf;
+    /**
+     * The steps before flat position `bound` that ran, 1-based, and the ones
+     * their tests left out (AC5) — the plan cursor's own, and a divergence
+     * bundle's (`extra`). `left` is empty when no step was left out; `ran` is
+     * then not filled, since every step before `bound` ran.
+     */
+    private ranBefore;
     private noteFor;
     /**
      * The executor handed to a plan: dispatch a step to the proxy that owns its
@@ -1020,6 +1164,13 @@ export declare class ReplayController {
      * the recording's input and output beside this run's verdict.
      */
     private recordStep;
+    /**
+     * Keep one call of the plan whole (AC2): its arguments and its answer,
+     * redacted and capped as a recorded call's are. Later news about the same
+     * step replaces earlier, in place, so the order is the order the calls went
+     * out. Past {@link TURN_CALLS_MAX_CHARS} a call keeps only a report's cut.
+     */
+    private keepCall;
     /** The step verdicts, in chain order, for the execution report. */
     private stepResultsOf;
     private logStep;