e2e 0.15.2 → 0.17.0

package/dist/agent/operation-queue.d.ts

@@ -18,4 +18,3 @@ export declare class OperationQueue {
     /** Runs `body` after every operation queued before it, in call order. */
     run<T>(body: () => Promise<T>): Promise<T>;
 }
-//# sourceMappingURL=operation-queue.d.ts.map

package/dist/agent/operation-queue.js

@@ -24,4 +24,3 @@ export class OperationQueue {
         return run;
     }
 }
-//# sourceMappingURL=operation-queue.js.map

package/dist/agent/phases.d.ts

@@ -75,4 +75,3 @@ export declare function retryingObserve(options: {
     readonly signal: AbortSignal;
     readonly api: string;
 }): Promise<Observation>;
-//# sourceMappingURL=phases.d.ts.map

package/dist/agent/phases.js

@@ -140,4 +140,3 @@ function phaseErrorCode(cause) {
         return engineError.code;
     return cause instanceof Error ? cause.name : 'ERROR';
 }
-//# sourceMappingURL=phases.js.map

package/dist/agent/pixels.d.ts

@@ -18,4 +18,3 @@ export declare function sizeForModel<P extends ObservationPixels>(pixels: P): P;
  * the caller's pixels carry (a masked-region count) rides along unchanged.
  */
 export declare function downscalePixels<P extends ObservationPixels>(pixels: P, maxLongSide: number): P;
-//# sourceMappingURL=pixels.d.ts.map

package/dist/agent/pixels.js

@@ -82,4 +82,3 @@ function boxResample(source, sourceWidth, sourceHeight, target, targetWidth, tar
         }
     }
 }
-//# sourceMappingURL=pixels.js.map

package/dist/agent/point-tap.d.ts

@@ -7,9 +7,9 @@
  * screenshot are scaled into the observation's CSS pixels first.
  */
 import type { PointActionName } from '../cache/trace.ts';
-import type { SemanticNode, ViewportPoint, ViewportSize } from '../engine/surface.ts';
+import type { ViewportPoint, ViewportSize } from '../engine/surface.ts';
 import type { ExecutorPixels } from './executor.ts';
-import { type AgentObservation } from './observation.ts';
+import { type AgentObservation, type RedactedNode } from './observation.ts';
 /**
  * Scales a point read off a screenshot into the observation's CSS pixels and
  * clamps it to the viewport. `pixels.scale` is image pixels per CSS pixel
@@ -23,9 +23,9 @@ export declare function imagePointToViewport(point: {
 }, pixels: Pick<ExecutorPixels, 'width' | 'height' | 'scale'>, viewport: ViewportSize): ViewportPoint;
 export interface HitTest {
     /** The innermost enabled control whose box contains the point, if any. */
-    readonly control: SemanticNode | undefined;
+    readonly control: RedactedNode | undefined;
     /** The innermost listed node of any role whose box contains the point, if any. */
-    readonly under: SemanticNode | undefined;
+    readonly under: RedactedNode | undefined;
 }
 /**
  * Finds what the newest observation lists at a viewport point. Only an
@@ -54,13 +54,12 @@ export declare const POINT_VERBS: Readonly<Record<PointActionName, {
 export declare function describePointAction(input: PointProse & {
     readonly verb: PointActionName;
     readonly point: ViewportPoint;
-    readonly control: SemanticNode | undefined;
-    readonly under: SemanticNode | undefined;
+    readonly control: RedactedNode | undefined;
+    readonly under: RedactedNode | undefined;
 }): string;
 /** What one hit test found, for the model that named the point. */
 export declare function describePointHit(input: PointProse & {
     readonly point: ViewportPoint;
-    readonly control: SemanticNode | undefined;
-    readonly under: SemanticNode | undefined;
+    readonly control: RedactedNode | undefined;
+    readonly under: RedactedNode | undefined;
 }): string;
-//# sourceMappingURL=point-tap.d.ts.map

package/dist/agent/point-tap.js

@@ -41,7 +41,7 @@ export function hitTest(observation, point) {
  * The innermost listed node whose box contains the point, among those
  * `accept` admits: deepest in the tree, then the smallest box. Hidden nodes
  * and nodes without a box are skipped. Every box is in the top-level
- * viewport's CSS pixels, nested documents included (`SemanticNode.rect`), so
+ * viewport's CSS pixels, nested documents included (`RedactedNode.rect`), so
  * a node inside an iframe is found like any other.
  */
 function innermostAt(observation, point, accept = () => true) {
@@ -112,4 +112,3 @@ export function describePointHit(input) {
 function describeNode(prose, node) {
     return nodeLine(prose.observation, node.ref.id);
 }
-//# sourceMappingURL=point-tap.js.map

package/dist/agent/primitives.d.ts

@@ -46,6 +46,12 @@ export interface GrammarToolOptions {
      * otherwise.
      */
     readonly screen?: ScreenPresenter;
+    /**
+     * Told the cause of every action that failed into a result rather than a
+     * throw, before it becomes the result's text: the one place its runner
+     * code is still structured.
+     */
+    readonly onActionFailed?: ((cause: unknown) => void) | undefined;
 }
 /**
  * AI SDK tools over the harness action grammar, limited to the verbs the
@@ -78,4 +84,3 @@ export declare function trackModelCalls(context: StepExecutorContext, model?: {
     readonly provider?: string;
     readonly modelId?: string;
 }): ModelCallTracker;
-//# sourceMappingURL=primitives.d.ts.map

package/dist/agent/primitives.js

@@ -666,7 +666,10 @@ function verbKit(context, options) {
         catch (cause) {
             if (isRuntimeHardStop(cause))
                 throw cause;
-            return present(failureLead(label, cause));
+            const failed = await present(failureLead(label, cause));
+            // After the look, so a look that throws fails the call once, as itself.
+            options.onActionFailed?.(cause);
+            return failed;
         }
         return present(outcome.lead, { expectChange: outcome.expectChange, ...update });
     });
@@ -717,4 +720,3 @@ export function trackModelCalls(context, model) {
         },
     };
 }
-//# sourceMappingURL=primitives.js.map

package/dist/agent/prompts.d.ts

@@ -49,4 +49,3 @@ export declare const JUDGMENT_REQUEST: string;
 export declare const EXTRACT_REQUEST: string;
 /** The extraction's answer to a rejection the screen cannot satisfy: say so rather than change the data. */
 export declare const EXTRACT_REPAIR_OUTLET = "Correct a misread or a wrong shape. When the data the observation shows cannot satisfy the errors, respond with \"found\": false and say why in \"missing\" rather than change a value to fit.";
-//# sourceMappingURL=prompts.d.ts.map

package/dist/agent/prompts.js

@@ -118,4 +118,3 @@ export const EXTRACT_REQUEST = [
 ].join('\n');
 /** The extraction's answer to a rejection the screen cannot satisfy: say so rather than change the data. */
 export const EXTRACT_REPAIR_OUTLET = 'Correct a misread or a wrong shape. When the data the observation shows cannot satisfy the errors, respond with "found": false and say why in "missing" rather than change a value to fit.';
-//# sourceMappingURL=prompts.js.map

package/dist/agent/protocol.d.ts

@@ -65,4 +65,3 @@ export declare function extractSchema(shape: JSONSchema7): JSONSchema7;
  */
 export declare function validateExtractResponse(value: unknown): ProtocolValidation<ExtractResponse>;
 export {};
-//# sourceMappingURL=protocol.d.ts.map

package/dist/agent/protocol.js

@@ -163,4 +163,3 @@ function asBoundedString(value, min, max) {
 function codePointLength(value) {
     return [...value].length;
 }
-//# sourceMappingURL=protocol.js.map

package/dist/agent/public.d.ts

@@ -11,4 +11,3 @@
 export { createToolLoopExecutor, type ToolLoopExecutorOptions, type PreparedTurn, type PreparedMessages, type ToolLoopHelpers, } from './tool-loop.ts';
 export { defineTool, getToolContext, type DefinedTool, type ToolAnnotations } from './tool.ts';
 export { AgentError, isAgentError } from './error.ts';
-//# sourceMappingURL=public.d.ts.map

package/dist/agent/public.js

@@ -11,4 +11,3 @@
 export { createToolLoopExecutor, } from './tool-loop.js';
 export { defineTool, getToolContext } from './tool.js';
 export { AgentError, isAgentError } from './error.js';
-//# sourceMappingURL=public.js.map

package/dist/agent/reading.d.ts

@@ -24,4 +24,3 @@ export declare function nodeReading(observation: Pick<SemanticAgentObservation,
  * list moving.
  */
 export declare function readingShape(observation: Pick<SemanticAgentObservation, 'nodes'>): string;
-//# sourceMappingURL=reading.d.ts.map

package/dist/agent/reading.js

@@ -80,4 +80,3 @@ export function readingShape(observation) {
     }
     return lines.join('\n');
 }
-//# sourceMappingURL=reading.js.map

package/dist/agent/replay.d.ts

@@ -11,15 +11,20 @@
  * timeout, cancellation) rethrow untouched; they are the step's truth, not a
  * divergence.
  */
-import { type ActionTrace, type DerivedReason, type TraceTargetDescriptor, type TraceViewport } from '../cache/trace.ts';
-import type { SemanticNode } from '../engine/surface.ts';
+import { type ActionTrace, type DerivedReason, type TraceViewport } from '../cache/trace.ts';
+import type { RedactedNode } from './observation.ts';
 import { type ExecutorActions, type ReplayHandOffReason } from './executor.ts';
 import { type SettleMode } from './settle-policy.ts';
 /** The nodes of one observation, keyed by their per-observation ids. */
-export type ObservedNodes = ReadonlyMap<string, SemanticNode>;
+export type ObservedNodes = ReadonlyMap<string, RedactedNode>;
 /** One capture's location and viewport, with nodes only when semantic evidence is available. */
 export type ObservedScreen = {
     readonly viewport: TraceViewport;
+    /**
+     * Where the capture was, as the cache compares it (`appLocation`): on the
+     * app's own origin its path, query, and fragment; elsewhere the whole
+     * location; a device's screen title as it is.
+     */
     readonly path?: string;
 } & ({
     readonly kind: 'semantic';
@@ -45,7 +50,6 @@ export interface ReplayHost {
     readonly actions: ExecutorActions;
     readonly signal: AbortSignal;
     remainingMs(): number;
-    readonly redact: (text: string) => string;
 }
 export interface ReplayOutcome {
     /** True when every recorded action executed; the step self-finalizes. */
@@ -67,21 +71,27 @@ export interface ReplayOptions {
      * instead of capturing again: nothing has happened since it was taken.
      */
     readonly initial?: SemanticScreen;
+    /**
+     * Asked before a free action (a navigate, typed text, a key) that follows
+     * another action; true takes the look a targeted action would have taken.
+     * A free action reads no screen, so without it the screen the previous
+     * action left goes unseen.
+     */
+    readonly looksBeforeFree?: () => boolean;
 }
 /** Replays one trace until it completes or diverges. */
 export declare function replayTrace(host: ReplayHost, trace: ActionTrace, options?: ReplayOptions): Promise<ReplayOutcome>;
 /**
- * Verifies a trace's recorded end anchors against the live screen: every
- * anchor must be present again (`anchors.ts`, every recorded field equal) or
- * the replay must not pass on its own. Waits on the same settling backoff
+ * Waits for a trace's recorded end state on the live screen: `holds` (the
+ * recorded delta, `cache/anchors.ts`) must be true of one look, or the
+ * replay must not pass on its own. Waits on the same settling backoff
  * relocation uses, because the recording run's final look came seconds of
  * model latency after its last action and a replay's comes right away: a
  * save still in flight is a wait, not a divergence. A surface that cannot be
  * observed at all is a mismatch too — the executor gets the step and judges
  * the live state; only runtime hard stops propagate.
  */
-export declare function verifyAnchors(host: ReplayHost, anchors: readonly TraceTargetDescriptor[], options?: {
+export declare function verifyEndState(host: ReplayHost, holds: (screen: SemanticScreen) => boolean, options?: {
     readonly waitMs?: number;
     readonly initial?: SemanticScreen;
 }): Promise<boolean>;
-//# sourceMappingURL=replay.d.ts.map

package/dist/agent/replay.js

@@ -11,7 +11,6 @@
  * timeout, cancellation) rethrow untouched; they are the step's truth, not a
  * divergence.
  */
-import { anchorsPresent } from '../cache/anchors.js';
 import { isRelocatableDescriptor, MAIN_LIST_SHARE, relocateDescriptor } from '../cache/relocate.js';
 import { isNodeAction } from '../cache/trace.js';
 import { hasCause } from '../internal/errors.js';
@@ -146,6 +145,8 @@ export async function replayTrace(host, trace, options = {}) {
                     break;
                 }
                 case 'free':
+                    if (previous !== undefined && options.looksBeforeFree?.() === true)
+                        await firstLook(host, look);
                     await planned.invoke();
                     break;
                 case 'scroll': {
@@ -228,21 +229,19 @@ export async function replayTrace(host, trace, options = {}) {
     return { completed: true, executed: summaries.length, total, summaries };
 }
 /**
- * Verifies a trace's recorded end anchors against the live screen: every
- * anchor must be present again (`anchors.ts`, every recorded field equal) or
- * the replay must not pass on its own. Waits on the same settling backoff
+ * Waits for a trace's recorded end state on the live screen: `holds` (the
+ * recorded delta, `cache/anchors.ts`) must be true of one look, or the
+ * replay must not pass on its own. Waits on the same settling backoff
  * relocation uses, because the recording run's final look came seconds of
  * model latency after its last action and a replay's comes right away: a
  * save still in flight is a wait, not a divergence. A surface that cannot be
  * observed at all is a mismatch too — the executor gets the step and judges
  * the live state; only runtime hard stops propagate.
  */
-export async function verifyAnchors(host, anchors, options = {}) {
-    if (anchors.length === 0)
-        return true;
+export async function verifyEndState(host, holds, options = {}) {
     const startedMs = Date.now();
     try {
-        const present = await pollSettled(host, ({ nodes }) => anchorsPresent(anchors, nodes, host) ? true : undefined, options.initial === undefined ? HELD_STILL : { kind: 'in-hand', screen: options.initial });
+        const present = await pollSettled(host, (screen) => holds(screen) ? true : undefined, options.initial === undefined ? HELD_STILL : { kind: 'in-hand', screen: options.initial });
         if (present === true)
             return true;
         // The settling backoff covers a slow re-render; the recorded run may have
@@ -255,7 +254,7 @@ export async function verifyAnchors(host, anchors, options = {}) {
             const screen = await host.observe('raw');
             if (screen.kind === 'pixels' || !host.traceEligible)
                 return false;
-            if (anchorsPresent(anchors, screen.nodes, host))
+            if (holds(screen))
                 return true;
         }
         return false;
@@ -272,10 +271,9 @@ const END_WAIT_POLL_MS = 1_000;
 const END_WAIT_RESERVE_MS = 20_000;
 /** Relocates one descriptor against the settling screen, looking again while `retryable` says the failure may pass. */
 async function relocate(host, descriptor, look) {
-    const options = { redact: host.redact };
     let last = { kind: 'failed', failure: 'target-not-found' };
     const settled = await pollSettled(host, (screen) => {
-        const result = relocateDescriptor(descriptor, screen.nodes, options);
+        const result = relocateDescriptor(descriptor, screen.nodes);
         if (result.kind === 'failed') {
             last = result.failure === 'target-not-found' ? result : { ...result, screen };
             return retryable(result.failure, descriptor) ? undefined : last;
@@ -294,17 +292,16 @@ async function relocate(host, descriptor, look) {
  * unpositioned ambiguity is not.
  */
 async function relocatePair(host, source, destination, look) {
-    const options = { redact: host.redact };
     let last = 'target-not-found';
     const failed = (descriptor, failure) => {
         last = failure;
         return retryable(failure, descriptor) ? undefined : { kind: 'failed', failure };
     };
     const settled = await pollSettled(host, (screen) => {
-        const from = relocateDescriptor(source, screen.nodes, options);
+        const from = relocateDescriptor(source, screen.nodes);
         if (from.kind === 'failed')
             return failed(source, from.failure);
-        const to = relocateDescriptor(destination, screen.nodes, options);
+        const to = relocateDescriptor(destination, screen.nodes);
         if (to.kind === 'failed')
             return failed(destination, to.failure);
         return { kind: 'found', source: from.id, destination: to.id };
@@ -438,4 +435,3 @@ function isUncertainCommit(cause) {
 function isReplayFatal(cause, signal) {
     return signal.aborted || isRuntimeHardStop(cause);
 }
-//# sourceMappingURL=replay.js.map

package/dist/agent/screen-update.d.ts

@@ -121,4 +121,3 @@ export declare class ScreenPresenter {
      */
     private withScreenshot;
 }
-//# sourceMappingURL=screen-update.d.ts.map

package/dist/agent/screen-update.js

@@ -312,4 +312,3 @@ function diffScreens(previous, next) {
     }
     return lines;
 }
-//# sourceMappingURL=screen-update.js.map

package/dist/agent/scroll-target.d.ts

@@ -10,11 +10,10 @@
  * all scrolls as the viewport does, which is what scrolling the main list
  * does; a smaller region that vanished is gone, as for any other action.
  */
-import type { SemanticNode } from '../engine/surface.ts';
 import { type Box } from '../internal/geometry.ts';
 import type { ExecutorTarget } from './executor.ts';
 import { type ObservationFeed, type Resolved } from './observation-feed.ts';
-import type { SemanticAgentObservation } from './observation.ts';
+import type { RedactedNode, SemanticAgentObservation } from './observation.ts';
 /**
  * The node a scroll target names now: the node itself, its descriptor's
  * match, or the same-role node in its old place. Undefined for a lost list
@@ -22,5 +21,4 @@ import type { SemanticAgentObservation } from './observation.ts';
  */
 export declare function resolveScrollTarget(feed: ObservationFeed, target: ExecutorTarget): Resolved | undefined;
 /** The listed node of the role whose box overlaps `box` most, when it overlaps enough. */
-export declare function samePlace(observation: SemanticAgentObservation, role: string | undefined, box: Box): SemanticNode | undefined;
-//# sourceMappingURL=scroll-target.d.ts.map
+export declare function samePlace(observation: SemanticAgentObservation, role: string | undefined, box: Box): RedactedNode | undefined;

package/dist/agent/scroll-target.js

@@ -51,4 +51,3 @@ export function samePlace(observation, role, box) {
     }
     return best?.node;
 }
-//# sourceMappingURL=scroll-target.js.map

package/dist/agent/secrets.d.ts

@@ -17,4 +17,3 @@ interface SecretFillHost {
  */
 export declare function authorizeSecretFill(host: SecretFillHost, runtime: AgentContext, secret: Secret, node: SemanticNode): Promise<string>;
 export {};
-//# sourceMappingURL=secrets.d.ts.map

package/dist/agent/secrets.js

@@ -38,4 +38,3 @@ export async function authorizeSecretFill(host, runtime, secret, node) {
         throw toAgentError(cause);
     }
 }
-//# sourceMappingURL=secrets.js.map

package/dist/agent/settle-policy.d.ts

@@ -53,4 +53,3 @@ interface SettleAfter {
  */
 export declare const SETTLE_AFTER: Record<RecordedAction['name'], SettleAfter>;
 export {};
-//# sourceMappingURL=settle-policy.d.ts.map

package/dist/agent/settle-policy.js

@@ -66,4 +66,3 @@ export const SETTLE_AFTER = {
     dismissKeyboard: { changeWaitMs: FULL_CHANGE_WAIT_MS, look: 'held-still' },
     tool: { changeWaitMs: BRIEF_CHANGE_WAIT_MS, look: 'held-still' },
 };
-//# sourceMappingURL=settle-policy.js.map

package/dist/agent/step-accounting.d.ts

@@ -108,4 +108,3 @@ export declare class StepAccounting {
      */
     modelInfo(executor: Pick<StepExecutor, 'name' | 'version'>): StepModelInfo | undefined;
 }
-//# sourceMappingURL=step-accounting.d.ts.map

package/dist/agent/step-accounting.js

@@ -220,4 +220,3 @@ export class StepAccounting {
         }, calls);
     }
 }
-//# sourceMappingURL=step-accounting.js.map

package/dist/agent/step-cache.d.ts

@@ -12,6 +12,7 @@
  * when replay performed no action.
  */
 import type { AgentCacheContext } from '../cache/context.ts';
+import type { CacheAgentIdentity } from '../cache/identity.ts';
 import { type ParamTemplate } from '../cache/template.ts';
 import { type DerivedReason } from '../cache/trace.ts';
 import type { StepCacheInfo } from '../run/steps.ts';
@@ -42,7 +43,11 @@ export interface StepCacheOptions {
         readonly name: string;
         readonly version?: string;
     };
+    /** The agent the step runs with, part of the key (`cache/identity.ts`). */
+    readonly agent: CacheAgentIdentity;
     readonly redact: (text: string) => string;
+    /** `redact` for a field cut at its observed limit (`SecretLedger.redactCut`). */
+    readonly redactCut: (text: string) => string;
     readonly maxActions: number;
     /** Timeline index of the step being dispatched. */
     readonly stepIndex: number;
@@ -60,8 +65,11 @@ export declare class StepTraceSession {
     private readonly host;
     private readonly cache;
     private readonly keyHash;
+    /** The claimed key and the step it names, which an entry records as its provenance. */
+    private readonly claim;
     private readonly recorder;
     private readonly options;
+    private readonly redaction;
     private info;
     private prefix;
     private startPath;
@@ -85,6 +93,8 @@ export declare class StepTraceSession {
     private replayedWhole;
     /** True once a cached entry's actions were run this step, fully or partly. */
     private consumedReplay;
+    /** True once the store returned an entry for this step, whether or not it replayed. */
+    private readEntryHit;
     /** True once `cache.strict` failed the step on its recording, which is then kept for review rather than evicted. */
     private failedStale;
     /** Grammar actions recorded so far when an end-mismatch hand-off happened. */
@@ -117,6 +127,14 @@ export declare class StepTraceSession {
      * model call to absorb on every run. The report keeps the cache detail.
      */
     private failIfStale;
+    /**
+     * Under `cache.strict`, ends a step whose key found no entry while the
+     * store holds a recording made for the same step under another key: the
+     * runner, the engine, the app, or the agent's context changed since, and
+     * the recording no longer replays as surely as one that diverged. A step
+     * whose instruction or params changed is a new step and still runs live.
+     */
+    private failIfRekeyed;
     /**
      * Closes the session once the step has settled. The whole write-side
      * decision lives here, in read-write mode only:
@@ -136,6 +154,10 @@ export declare class StepTraceSession {
      *   anchor, or end wait, so drift is repaired only once a relocation fails
      *   and the hand-off that follows re-records.
      * - passed otherwise: stage the recorded trace for attempt-end settlement.
+     *   When this pass leaves nothing to stage (it changed nothing a replay
+     *   could check) and an entry was read for the step, evict that entry: it
+     *   did not serve this pass, and nothing recorded will replace it, so
+     *   keeping it would hand every later run off the same way.
      * - failed after consuming a replay: evict. Without this, a diverged replay
      *   whose step then fails stages nothing — and the poisoned entry would
      *   replay its bad prefix on every future first attempt.
@@ -172,18 +194,22 @@ export declare class StepTraceSession {
     private replayEntry;
     /**
      * The trace's postcondition against the live screen: the recorded end
-     * route (when the live location is known) and every recorded end anchor
-     * present again. A route the path leaves undecided is the recorded screen
-     * only if the anchors are already on it, which then needs no second look.
+     * route when the live location is known, the recorded delta on the
+     * screen (`deltaHolds`), and evidence that the replay produced it rather
+     * than finding it there (`deltaEvidenced`). The evidence is measured from
+     * the first screen the replay saw on the route it ended on (`screens`, in
+     * order): the start for a step that stays on one screen, the page a
+     * recorded navigate opened before the switch on it was tapped. An outcome
+     * already showing there proves nothing, and neither does a recording with
+     * no delta at all.
      */
     private endStateMatches;
     /**
      * Captures the semantic end state once its route matches the recording,
-     * polling while a navigation the last action started commits. Reports
-     * whether the anchors were what settled the route, so the caller does not
-     * verify them again. A route still undecided when the poll runs out is
-     * handed on with the anchors unseen: the caller's anchor wait, sized by
-     * the recording, is the one that decides it, as for a route that matched.
+     * polling while a navigation the last action started commits. A route
+     * that never matches is another screen, whatever it shows: a link that
+     * now lands on a page sharing the recorded one's layout is exactly the
+     * flow that went wrong.
      */
     private endScreen;
     private selfFinalize;
@@ -199,12 +225,13 @@ export declare class StepTraceSession {
      *
      * The end path and a fresh settled observation are the trace's
      * postcondition — the state the step passed in. The delta between the
-     * baseline and the passing observation becomes the end anchors. When the
-     * step moved to another pathname the whole new screen is the delta, and its
-     * first stable anchors back the path check, which matches a created
-     * record's page up to the id the app minted for it. A postcondition that
-     * cannot be captured stages nothing: a trace without its check would
-     * replay on mechanics alone.
+     * baseline and the passing observation becomes the anchors: what appeared
+     * and what vanished. When the step moved to another pathname the whole new
+     * screen is the delta, and its first stable anchors back the path check,
+     * which matches a created record's page up to the id the app minted for
+     * it. A postcondition that cannot be captured stages nothing, and neither
+     * does a step that changed nothing a replay could check, no node and no
+     * route: a trace without its check would replay on mechanics alone.
      */
     private stage;
     /**
@@ -224,4 +251,3 @@ export declare class StepTraceSession {
  * drift apart; a summary not written by it is returned as is.
  */
 export declare function recordedVerdictOf(summary: string): string;
-//# sourceMappingURL=step-cache.d.ts.map