@basein/runner 0.3.20 → 0.3.22

package/dist/replay/safety.d.ts

@@ -36,8 +36,7 @@
  * NUL. A file is not a shell, and a quote or a backslash — every Windows path —
  * is text there.
  */
-import type { FlatEntry } from "./flatten.js";
-import type { ParamsSchema } from "./types.js";
+import type { ParamsSchema, SerializedScenarioStep } from "./types.js";
 /**
  * How a step consumes its input, strictest first: `command` is run by a shell
  * or a database, `write` is only written into a file.
@@ -61,11 +60,11 @@ export declare function sinkOf(toolName: string | null | undefined, host?: HostS
 /** Whether this tool's input is run or written: a shell, a file edit, a query. */
 export declare function isCommandSink(toolName: string | null | undefined): boolean;
 /** The strictest sink among the planned steps, or undefined when there is none. */
-export declare function sinkOfPlan(entries: readonly FlatEntry[], host?: HostSinks): SinkKind | undefined;
+export declare function sinkOfPlan(steps: readonly SerializedScenarioStep[], host?: HostSinks): SinkKind | undefined;
 /** Whether any planned step runs its input through a shell. */
-export declare function hasShellStep(entries: readonly FlatEntry[], host?: HostSinks): boolean;
+export declare function hasShellStep(steps: readonly SerializedScenarioStep[], host?: HostSinks): boolean;
 /** Whether any planned step's input is run or written. */
-export declare function hasCommandSink(entries: readonly FlatEntry[]): boolean;
+export declare function hasCommandSink(steps: readonly SerializedScenarioStep[]): boolean;
 /**
  * The first value derived for this turn that is not safe to template into a
  * command, or undefined when every one is.

package/dist/replay/safety.js

@@ -118,10 +118,10 @@ export function isCommandSink(toolName) {
     return sinkOf(toolName) !== undefined;
 }
 /** The strictest sink among the planned steps, or undefined when there is none. */
-export function sinkOfPlan(entries, host) {
+export function sinkOfPlan(steps, host) {
     let found;
-    for (const e of entries) {
-        const sink = sinkOf(e.step.toolName, host);
+    for (const s of steps) {
+        const sink = sinkOf(s.toolName, host);
         if (sink === "command")
             return sink;
         found ??= sink;
@@ -129,12 +129,12 @@ export function sinkOfPlan(entries, host) {
     return found;
 }
 /** Whether any planned step runs its input through a shell. */
-export function hasShellStep(entries, host) {
-    return entries.some((e) => isShellTool(e.step.toolName, host));
+export function hasShellStep(steps, host) {
+    return steps.some((s) => isShellTool(s.toolName, host));
 }
 /** Whether any planned step's input is run or written. */
-export function hasCommandSink(entries) {
-    return entries.some((e) => isCommandSink(e.step.toolName));
+export function hasCommandSink(steps) {
+    return steps.some((s) => isCommandSink(s.toolName));
 }
 /**
  * The first value derived for this turn that is not safe to template into a

package/dist/replay/source-run.d.ts

@@ -24,12 +24,6 @@
  * Fetched **lazily** — only when a step actually needs it — and cached for the
  * turn, so a fully-executable replay never makes this call at all.
  *
- * A chain with calls draws on **several** recordings: a called segment's steps
- * take their outputs from that segment's own recording, within its own range
- * (segmented.md R-CALL-31). So the rows are cached per run id, and the cursors
- * are kept per frame — a segment called twice in one chain replays from the
- * start of its range both times, as two separate replays of it would.
- *
  * OFF BY DEFAULT NOW. A recorded output shown to the model as a step's result
  * is last week's answer standing in for a call that did not happen here — and
  * for a write ("INSERT 0 1", "file updated") that is a lie the model repeats to
@@ -40,10 +34,10 @@
  * keeps it on, because its operator reads a per-step trace. Nothing else asks
  * for these rows.
  */
-import type { FlatEntry } from "./flatten.js";
+import type { SerializedScenarioStep } from "./types.js";
 export interface SourceRunOptions {
     baseUrl: string;
-    /** The run the plan's own scenario came from; others are fetched on demand. */
+    /** The run the plan's scenario came from. */
     runId: string;
     /** Bearer token; refreshed by the caller, read fresh on each fetch. */
     token: () => string;
@@ -55,33 +49,30 @@ export declare class SourceRunCache {
     /** run id → every recorded output of that run, in order. */
     private readonly runs;
     private readonly loading;
-    /** `frameId#toolName` → how many of that tool the frame has drawn. */
+    /** tool name → how many of that tool's outputs have been drawn. */
     private readonly cursor;
     constructor(opts: SourceRunOptions);
     /**
-     * The next recorded output for this entry's tool, from this entry's own
-     * recording and range, or undefined when there is none left (or the run could
-     * not be fetched). Never throws — a missing recorded output means the step is
-     * skipped, which the caller already handles.
+     * The next recorded output for this step's tool, or undefined when there is
+     * none left (or the run could not be fetched). Never throws — a missing
+     * recorded output means the step is skipped, which the caller already
+     * handles.
      */
-    outputFor(entry: FlatEntry): Promise<string | undefined>;
+    outputFor(step: SerializedScenarioStep): Promise<string | undefined>;
     /**
      * A step its test left out (the service's autocorrect.md AC5). Every step
      * of a plan was in the recording, and made its call there — unless a
      * correction added it from the agent's redo (`correctionKind: "added"`)
-     * or wrote it from the agent's answer (`"written"`, AC12), which made none. So one that was in it passes over its recorded output,
-     * and the next step of its tool takes its own; an added one passes over
-     * nothing. Nothing is fetched: the cursor is a count of this frame's calls
-     * of the tool, whichever of them are read later (docs/calculatedReplay.md
-     * §9.2).
+     * or wrote it from the agent's answer (`"written"`, AC12), which made none.
+     * So one that was in it passes over its recorded output, and the next step
+     * of its tool takes its own; an added one passes over nothing. Nothing is
+     * fetched: the cursor is a count of the plan's calls of the tool, whichever
+     * of them are read later (docs/calculatedReplay.md §9.2).
      */
-    leftOut(entry: FlatEntry): void;
+    leftOut(step: SerializedScenarioStep): void;
     private load;
     private fetchRun;
 }
-/**
- * The name this class had before one chain could draw on more than one
- * recording. Kept so nothing outside has to change its import.
- */
+/** The class's other name, which the controller and older callers import. */
 export { SourceRunCache as SourceRunOutputs };
 //# sourceMappingURL=source-run.d.ts.map

package/dist/replay/source-run.js

@@ -24,12 +24,6 @@
  * Fetched **lazily** — only when a step actually needs it — and cached for the
  * turn, so a fully-executable replay never makes this call at all.
  *
- * A chain with calls draws on **several** recordings: a called segment's steps
- * take their outputs from that segment's own recording, within its own range
- * (segmented.md R-CALL-31). So the rows are cached per run id, and the cursors
- * are kept per frame — a segment called twice in one chain replays from the
- * start of its range both times, as two separate replays of it would.
- *
  * OFF BY DEFAULT NOW. A recorded output shown to the model as a step's result
  * is last week's answer standing in for a call that did not happen here — and
  * for a write ("INSERT 0 1", "file updated") that is a lie the model repeats to
@@ -48,20 +42,20 @@ export class SourceRunCache {
     /** run id → every recorded output of that run, in order. */
     runs = new Map();
     loading = new Map();
-    /** `frameId#toolName` → how many of that tool the frame has drawn. */
+    /** tool name → how many of that tool's outputs have been drawn. */
     cursor = new Map();
     constructor(opts) {
         this.opts = opts;
     }
     /**
-     * The next recorded output for this entry's tool, from this entry's own
-     * recording and range, or undefined when there is none left (or the run could
-     * not be fetched). Never throws — a missing recorded output means the step is
-     * skipped, which the caller already handles.
+     * The next recorded output for this step's tool, or undefined when there is
+     * none left (or the run could not be fetched). Never throws — a missing
+     * recorded output means the step is skipped, which the caller already
+     * handles.
      */
-    async outputFor(entry) {
-        const runId = entry.runId || this.opts.runId;
-        const toolName = entry.step.toolName;
+    async outputFor(step) {
+        const runId = this.opts.runId;
+        const toolName = step.toolName;
         if (!toolName)
             return undefined;
         try {
@@ -75,34 +69,28 @@ export class SourceRunCache {
             });
             return undefined;
         }
-        const all = this.runs.get(runId) ?? [];
-        const inRange = all.filter((o) => o.toolName === toolName &&
-            (entry.stepFrom === null ||
-                entry.stepTo === null ||
-                (o.position >= entry.stepFrom && o.position <= entry.stepTo)));
-        if (inRange.length === 0)
+        const all = (this.runs.get(runId) ?? []).filter((o) => o.toolName === toolName);
+        if (all.length === 0)
             return undefined;
-        const key = cursorKey(entry, toolName);
-        const at = this.cursor.get(key) ?? 0;
-        this.cursor.set(key, at + 1);
-        return inRange[at]?.output;
+        const at = this.cursor.get(toolName) ?? 0;
+        this.cursor.set(toolName, at + 1);
+        return all[at]?.output;
     }
     /**
      * A step its test left out (the service's autocorrect.md AC5). Every step
      * of a plan was in the recording, and made its call there — unless a
      * correction added it from the agent's redo (`correctionKind: "added"`)
-     * or wrote it from the agent's answer (`"written"`, AC12), which made none. So one that was in it passes over its recorded output,
-     * and the next step of its tool takes its own; an added one passes over
-     * nothing. Nothing is fetched: the cursor is a count of this frame's calls
-     * of the tool, whichever of them are read later (docs/calculatedReplay.md
-     * §9.2).
+     * or wrote it from the agent's answer (`"written"`, AC12), which made none.
+     * So one that was in it passes over its recorded output, and the next step
+     * of its tool takes its own; an added one passes over nothing. Nothing is
+     * fetched: the cursor is a count of the plan's calls of the tool, whichever
+     * of them are read later (docs/calculatedReplay.md §9.2).
      */
-    leftOut(entry) {
-        const toolName = entry.step.toolName;
-        if (!toolName || entry.step.correctionKind === "added" || entry.step.correctionKind === "written")
+    leftOut(step) {
+        const toolName = step.toolName;
+        if (!toolName || step.correctionKind === "added" || step.correctionKind === "written")
             return;
-        const key = cursorKey(entry, toolName);
-        this.cursor.set(key, (this.cursor.get(key) ?? 0) + 1);
+        this.cursor.set(toolName, (this.cursor.get(toolName) ?? 0) + 1);
     }
     load(runId) {
         let pending = this.loading.get(runId);
@@ -154,24 +142,10 @@ export class SourceRunCache {
         }
         serviceOk(startedAt);
         const outputs = [];
-        // A `tool_response` belongs to the `tool_selected` before it, and it is
-        // *that* row's position the range is cut on: a response row may sit just
-        // outside a range whose call sits inside it.
-        const lastCall = new Map();
         for (const row of body.steps ?? []) {
-            if (!row.tool_name)
-                continue;
-            if (row.type === "tool_selected") {
-                lastCall.set(row.tool_name, row.step_index ?? -1);
+            if (!row.tool_name || row.type !== "tool_response")
                 continue;
-            }
-            if (row.type !== "tool_response")
-                continue;
-            outputs.push({
-                toolName: row.tool_name,
-                output: row.tool_output ?? "{}",
-                position: lastCall.get(row.tool_name) ?? row.step_index ?? -1,
-            });
+            outputs.push({ toolName: row.tool_name, output: row.tool_output ?? "{}" });
         }
         this.runs.set(runId, outputs);
         logDetail("replay.source_run_loaded", {
@@ -180,15 +154,8 @@ export class SourceRunCache {
         });
     }
 }
-/**
- * The name this class had before one chain could draw on more than one
- * recording. Kept so nothing outside has to change its import.
- */
+/** The class's other name, which the controller and older callers import. */
 export { SourceRunCache as SourceRunOutputs };
-/** One frame's queue of one tool's recorded outputs: a sub-task called twice replays from its start twice. */
-function cursorKey(entry, toolName) {
-    return `${entry.frame.id}#${toolName}`;
-}
 /**
  * Report a service answer to the breaker with the time its request started:
  * an answer to a request sent before a hot path gave up on the service does

package/dist/replay/targets.d.ts

@@ -35,10 +35,6 @@
  * runs on this turn's value, and one that cannot calls a tool with `null` and
  * falls back to the model. What never happens, either way, is last week's fleet.
  *
- * Only frame 0 is judged here. A called segment runs on the parameters its
- * call's `paramMapLogic` builds, not on these, so that body is scanned as a
- * consumer and the segment's own steps are not (R-CALL-29).
- *
  * A THIRD WAY NOT TO BLOCK: A VALUE ONLY ONE HALF NEEDS (the service's review
  * of calcscenarioautocorrect.md, item 11). A plan that holds both halves of an
  * "if … otherwise" reads values only one half needs — the task's name, its
@@ -62,8 +58,7 @@
  * more strictly still, because it runs before any step and can rename a target
  * the steps then read under another name.
  */
-import type { FlatEntry } from "./flatten.js";
-import { type ParamsSchema } from "./types.js";
+import { type ParamsSchema, type SerializedScenarioStep } from "./types.js";
 /**
  * The subset of `missing` this plan must decline on.
  *
@@ -74,17 +69,17 @@ import { type ParamsSchema } from "./types.js";
  * `paramsLogic` is the scenario's own, when it has one: it runs on these
  * parameters before step 0, and what it returns is what every step reads.
  */
-export declare function blockingTargets(missing: readonly string[], schema: ParamsSchema | null | undefined, planned: readonly FlatEntry[], paramsLogic?: string | null): string[];
+export declare function blockingTargets(missing: readonly string[], schema: ParamsSchema | null | undefined, planned: readonly SerializedScenarioStep[], paramsLogic?: string | null): string[];
 /**
  * Of `missing`, the targets that only the steps of one half read (see A THIRD
  * WAY NOT TO BLOCK above): the plan holds them as a mark, and they do not stop
  * it. A key is one only when
  *
- *  - some step of frame 0 that runs under a test of its own (`when`, either
- *    `otherwise`) reads it in its input logic; and
- *  - nothing else names it: no step without a test, no output logic, no test,
- *    no sub-task's parameter mapping or test — the mark is never something a
- *    test decides on, or that an output passes on to another value; and
+ *  - some step that runs under a test of its own (`when`, either `otherwise`)
+ *    reads it in its input logic; and
+ *  - nothing else names it: no step without a test, no output logic, no test
+ *    — the mark is never something a test decides on, or that an output
+ *    passes on to another value; and
  *  - `paramsLogic`, when there is one, does not name the key at all, not even
  *    as a bare word (`{ ...parameters, task_name: 'x' }` is a typed default:
  *    a guessed target), and uses `parameters` only as a spread that hands
@@ -92,14 +87,9 @@ export declare function blockingTargets(missing: readonly string[], schema: Para
  *  - no body carries the recorded sample as a literal.
  *
  * Anything this cannot follow — `parameters` destructured, passed or aliased —
- * and it answers none: every missing target blocks, as before. Nor in a plan
- * that calls a sub-task: the sub-task's mappings — the one that builds its
- * parameters, the one that hands its results back — run on the caller's
- * values out of every watch, and a mark is a truthy text a mapping could
- * branch on, change past recognising, or pass into what a later test decides
- * on. The plan also puts the mark back after `paramsLogic` has run, so a body
- * that dropped the key or wrote one of its own in its place still stops in
- * front of the step.
+ * and it answers none: every missing target blocks, as before. The plan also
+ * puts the mark back after `paramsLogic` has run, so a body that dropped the
+ * key or wrote one of its own in its place still stops in front of the step.
  */
-export declare function testedOnlyTargets(missing: readonly string[], schema: ParamsSchema | null | undefined, planned: readonly FlatEntry[], paramsLogic?: string | null): string[];
+export declare function testedOnlyTargets(missing: readonly string[], schema: ParamsSchema | null | undefined, planned: readonly SerializedScenarioStep[], paramsLogic?: string | null): string[];
 //# sourceMappingURL=targets.d.ts.map

package/dist/replay/targets.js

@@ -35,10 +35,6 @@
  * runs on this turn's value, and one that cannot calls a tool with `null` and
  * falls back to the model. What never happens, either way, is last week's fleet.
  *
- * Only frame 0 is judged here. A called segment runs on the parameters its
- * call's `paramMapLogic` builds, not on these, so that body is scanned as a
- * consumer and the segment's own steps are not (R-CALL-29).
- *
  * A THIRD WAY NOT TO BLOCK: A VALUE ONLY ONE HALF NEEDS (the service's review
  * of calcscenarioautocorrect.md, item 11). A plan that holds both halves of an
  * "if … otherwise" reads values only one half needs — the task's name, its
@@ -107,11 +103,11 @@ export function blockingTargets(missing, schema, planned, paramsLogic) {
  * WAY NOT TO BLOCK above): the plan holds them as a mark, and they do not stop
  * it. A key is one only when
  *
- *  - some step of frame 0 that runs under a test of its own (`when`, either
- *    `otherwise`) reads it in its input logic; and
- *  - nothing else names it: no step without a test, no output logic, no test,
- *    no sub-task's parameter mapping or test — the mark is never something a
- *    test decides on, or that an output passes on to another value; and
+ *  - some step that runs under a test of its own (`when`, either `otherwise`)
+ *    reads it in its input logic; and
+ *  - nothing else names it: no step without a test, no output logic, no test
+ *    — the mark is never something a test decides on, or that an output
+ *    passes on to another value; and
  *  - `paramsLogic`, when there is one, does not name the key at all, not even
  *    as a bare word (`{ ...parameters, task_name: 'x' }` is a typed default:
  *    a guessed target), and uses `parameters` only as a spread that hands
@@ -119,20 +115,13 @@ export function blockingTargets(missing, schema, planned, paramsLogic) {
  *  - no body carries the recorded sample as a literal.
  *
  * Anything this cannot follow — `parameters` destructured, passed or aliased —
- * and it answers none: every missing target blocks, as before. Nor in a plan
- * that calls a sub-task: the sub-task's mappings — the one that builds its
- * parameters, the one that hands its results back — run on the caller's
- * values out of every watch, and a mark is a truthy text a mapping could
- * branch on, change past recognising, or pass into what a later test decides
- * on. The plan also puts the mark back after `paramsLogic` has run, so a body
- * that dropped the key or wrote one of its own in its place still stops in
- * front of the step.
+ * and it answers none: every missing target blocks, as before. The plan also
+ * puts the mark back after `paramsLogic` has run, so a body that dropped the
+ * key or wrote one of its own in its place still stops in front of the step.
  */
 export function testedOnlyTargets(missing, schema, planned, paramsLogic) {
     if (missing.length === 0 || !schema || planned.length === 0)
         return [];
-    if (planned.some((entry) => entry.depth > 0))
-        return [];
     const { tested, others } = consumerBodies(planned);
     const all = [...tested, ...others];
     if (all.length === 0 || all.some(readsWhole))
@@ -152,33 +141,21 @@ export function testedOnlyTargets(missing, schema, planned, paramsLogic) {
     });
 }
 /**
- * The bodies that run with the caller's own `parameters`, as
- * {@link callerBodies} lists them, told apart: the input logic of each step of
- * frame 0 that runs under a test of its own, and every other body.
+ * The bodies that run with the plan's `parameters`, as {@link callerBodies}
+ * lists them, told apart: the input logic of each step that runs under a test
+ * of its own, and every other body.
  */
 function consumerBodies(planned) {
     const tested = [];
     const others = [];
-    const seenFrames = new Set();
-    for (const entry of planned) {
-        if (entry.depth === 0) {
-            const input = entry.step.toolInputLogic;
-            if (input)
-                (isStepTest(entry.step.when) ? tested : others).push(input);
-            if (entry.step.toolOutputLogic)
-                others.push(entry.step.toolOutputLogic);
-            if (entry.step.when?.logic)
-                others.push(entry.step.when.logic);
-            continue;
-        }
-        const frame = entry.frame;
-        if (frame.depth !== 1 || seenFrames.has(frame.id))
-            continue;
-        seenFrames.add(frame.id);
-        if (frame.paramMapLogic)
-            others.push(frame.paramMapLogic);
-        if (frame.when?.logic)
-            others.push(frame.when.logic);
+    for (const step of planned) {
+        const input = step.toolInputLogic;
+        if (input)
+            (isStepTest(step.when) ? tested : others).push(input);
+        if (step.toolOutputLogic)
+            others.push(step.toolOutputLogic);
+        if (step.when?.logic)
+            others.push(step.when.logic);
     }
     return { tested, others };
 }
@@ -216,38 +193,22 @@ function mentions(body, key) {
     return pattern.test(body);
 }
 /**
- * Every logic body that runs with the caller's own `parameters`.
+ * Every logic body that runs with the plan's `parameters`.
  *
  * Both of a step's bodies, because `toolOutputLogic` is handed `parameters`
- * too and a value baked in there travels just as far. Plus the `paramMapLogic`
- * of each segment called directly from frame 0: it reads the caller's
- * parameters to build the segment's.
+ * too and a value baked in there travels just as far.
  */
 function callerBodies(planned) {
     const bodies = [];
-    const seenFrames = new Set();
-    for (const entry of planned) {
-        if (entry.depth === 0) {
-            if (entry.step.toolInputLogic)
-                bodies.push(entry.step.toolInputLogic);
-            if (entry.step.toolOutputLogic)
-                bodies.push(entry.step.toolOutputLogic);
-            // A step's test reads the parameters too (autocorrect.md AC5): a test
-            // that decides on a target nobody named decides on nothing.
-            if (entry.step.when?.logic)
-                bodies.push(entry.step.when.logic);
-            continue;
-        }
-        // The frame's own mapping, once, and only when its caller is frame 0 —
-        // and the call row's test, which is decided in the caller's scope.
-        const frame = entry.frame;
-        if (frame.depth !== 1 || seenFrames.has(frame.id))
-            continue;
-        seenFrames.add(frame.id);
-        if (frame.paramMapLogic)
-            bodies.push(frame.paramMapLogic);
-        if (frame.when?.logic)
-            bodies.push(frame.when.logic);
+    for (const step of planned) {
+        if (step.toolInputLogic)
+            bodies.push(step.toolInputLogic);
+        if (step.toolOutputLogic)
+            bodies.push(step.toolOutputLogic);
+        // A step's test reads the parameters too (autocorrect.md AC5): a test
+        // that decides on a target nobody named decides on nothing.
+        if (step.when?.logic)
+            bodies.push(step.when.logic);
     }
     return bodies;
 }

package/dist/replay/types.d.ts

@@ -10,33 +10,6 @@
  * everywhere and nothing is assumed present. A scenario whose `state` is not
  * `"ready"` carries an **empty** `steps` array, by the service's own rule.
  */
-/** One step: the tool, and the JS logic that recomputes its arguments. */
-/**
- * A segment inlined into the chain that calls it (segmented.md R-CALL-28).
- *
- * The caller's chain holds one *call* row where a stretch of steps used to be,
- * and the service serves that segment's own chain inside it. Nothing is copied
- * into the caller's scenario: this is one payload, built at serving time from
- * the segment as it stands right now.
- */
-export interface InlinedSegment {
-    id: string;
-    intent: string;
-    paramsObject: ParamsSchema | null;
-    runId: string;
-    stepFrom: number;
-    stepTo: number;
-    /**
-     * The segment's `chain_revision` as served. Sent back on every verdict about
-     * one of its steps, so a failure counted against a chain that has since been
-     * rebuilt is dropped (R-CALL-13, R-REUSE-5).
-     */
-    chainRevision: number;
-    /** May itself contain call rows, to the depth limit. */
-    steps: SerializedScenarioStep[];
-}
-/** Why a call cannot run right now (segmented.md 9.9). */
-export type CallUnusable = "switched_off" | "not_ready" | "missing" | "stale" | "unresolved" | "depth" | "unsupported";
 /**
  * A reason the plan stops in front of a step, as the service decided it
  * (plan-services.md D8). The service knows the grace period, the retry clock
@@ -47,18 +20,9 @@ export interface StepStop {
      * `parked`: the step has failed too often and its retry is not due, or its
      * grace has ended. `nondeterministic`: the calculation could not write code
      * that computes this step's input — a judgement — so the agent makes it.
-     * `decision`: the task has an "if … otherwise" here (the service's
-     * segmentsbreakdown.md SB-6). The plan runs only the steps before it and
-     * hands the task back, and the agent decides which way applies. Not a
-     * failure: it counts nothing against the step. Runners up to 0.3.18 read it
-     * as an unknown kind and stop here too, as `known_bad_step`.
-     */
-    kind: "parked" | "nondeterministic" | "decision";
-    /**
-     * For `nondeterministic`: which check the step failed at calculation. For
-     * `decision`: the condition in words. It holds the recorded run's values,
-     * so it is never shown to the agent (it would hint at the recorded half).
      */
+    kind: "parked" | "nondeterministic";
+    /** For `nondeterministic`: which check the step failed at calculation. */
     why?: string;
     /** For `parked` inside its grace: when the step may be tried again. */
     retryAt?: string;
@@ -82,12 +46,12 @@ export interface StepTest {
 }
 /** Whether a served test is one this runner can run; anything else is no plan to arm. */
 export declare function isStepTest(value: unknown): value is StepTest;
+/** One step: the tool, and the JS logic that recomputes its arguments. */
 export interface SerializedScenarioStep {
     stepIndex: number;
     /**
      * Run this step only when its test says so (autocorrect.md AC5). Absent or
-     * null on a step with no test — every step of an older service. On a call
-     * row the test decides the whole sub-task.
+     * null on a step with no test — every step of an older service.
      */
     when?: StepTest | null;
     /**
@@ -100,16 +64,10 @@ export interface SerializedScenarioStep {
      */
     correctionId?: string | null;
     correctionKind?: "added" | "tested" | "changed" | "written" | null;
-    /**
-     * `"segment"` is a call: a sub-task this chain runs by calling a recorded
-     * scenario instead of carrying a copy of its steps (R-CALL-1). Absent means
-     * `"tool"`, which is what every older service sends.
-     */
-    kind?: "tool" | "segment";
-    /** As the recorder wrote it — `mcp__<server>__<tool>` for an MCP call. Null on a call row. */
-    toolName: string | null;
-    /** JS body: `(parameters, intent, respParams) => object`. Null on a call row. */
-    toolInputLogic: string | null;
+    /** As the recorder wrote it — `mcp__<server>__<tool>` for an MCP call. */
+    toolName: string;
+    /** JS body: `(parameters, intent, respParams) => object`. */
+    toolInputLogic: string;
     /** JS body: `(toolOutput, parameters, intent, respParams) => object`. */
     toolOutputLogic: string | null;
     /** The model's reasoning for this step, used in the steering directive. */
@@ -139,30 +97,6 @@ export interface SerializedScenarioStep {
      * {@link ../replay/source-run.ts} is what actually supplies recorded outputs.
      */
     recordedOutput?: string | null;
-    /** Which segment answers this call right now, if one does. */
-    segmentId?: string | null;
-    /** What the sub-task is, in one line. The ask, frozen with the chain. */
-    callIntent?: string | null;
-    /** How many of the caller's recorded steps the call covers. */
-    callStepCount?: number | null;
-    /** JS body: `(parameters, intent, respParams) => <the segment's parameters>`. */
-    paramMapLogic?: string | null;
-    /** JS body: `(out, parameters, intent, respParams) => <keys the caller reads>`. */
-    resultMapLogic?: string | null;
-    /** The segment, inlined. Absent when the call is `unusable`. */
-    segment?: InlinedSegment | null;
-    /**
-     * Set when the call cannot run: the plan stops in front of it and the agent
-     * does that stretch itself (R-CALL-29, R-FALL-5).
-     */
-    unusable?: CallUnusable;
-    /** How the answer was reached. Read only for the `plan.armed` line (R-CALL-32). */
-    resolution?: {
-        state: string;
-        score?: number;
-        verdict?: string;
-        resolvedAt?: string;
-    } | null;
 }
 /**
  * What a parameter *is* (segmented.md R-PARAM-1). A `target` is what the task
@@ -244,12 +178,6 @@ export type FallbackKind =
 "step_failed"
 /** The plan stopped in front of a step that has failed too often, without trying it. */
  | "known_bad_step"
-/**
- * The plan stopped in front of a *call* that cannot run — its segment is
- * gone, switched off, out of date, or nested too deep (segmented.md
- * R-CALL-29). Like a known-bad step it counts nothing against any step.
- */
- | "unusable_call"
 /**
  * The plan stopped in front of a step the calculation marked
  * non-deterministic: its input needs a judgement no code computes
@@ -261,14 +189,7 @@ export type FallbackKind =
  * (autocorrect.md AC5): this request is the other half of an "if …
  * otherwise", and the agent does it. No fault of the plan; counts nothing.
  */
- | "other_branch"
-/**
- * The plan ran the steps before its decision and stopped in front of it
- * (the service's segmentsbreakdown.md SB-17): the agent decides which way
- * applies and does the rest. No fault of the plan; it counts nothing, and
- * the plan is billed only up to the stop (SB-26).
- */
- | "decision";
+ | "other_branch";
 /**
  * Upgrade order. `not_steered` is the floor — the control group, and the safe
  * answer if a turn dies mid-flight — and each later decision point can only move
@@ -344,14 +265,6 @@ export interface ExecutionStepResult {
      * waiting out the grace period.
      */
     toolMissing?: boolean;
-    /**
-     * The scenario this step belongs to, when it ran inside a called segment: a
-     * failure is counted where a repair would happen (segmented.md R-CALL-13).
-     * Absent on a step of the reported scenario's own chain.
-     */
-    scenarioId?: string;
-    /** That segment's `chain_revision` as served. Absent at depth 0. */
-    chainRevision?: number;
 }
 /** Narrowing guard for a payload that is worth arming a plan from. */
 export declare function isReadyScenario(value: unknown): value is SerializedScenario;