@reticlehq/server 3.6.0 → 3.7.0

package/dist/surface/tools/act/screen-request.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The opt-in screen/request check, wired: after an act_and_wait, compare what the window's write
+ * requests carried with the values the page's form controls show (engine: screen-request.ts).
+ *
+ * OPT-IN (`RETICLE_SCREEN_REQUEST_CHECK=1`) and ADVISORY. It ships behind the flag until its
+ * false-alarm rate is measured at zero on the e2e battery, the benchmark and the persona fixtures;
+ * until then it must cost nothing for anyone who did not ask. It runs AFTER the verdict is decided
+ * and is appended to `contradictions` as an advisory kind, so it can never move a verdict.
+ */
+import { type Contradiction, type ReticleEvent } from '@reticlehq/core';
+import type { Session } from '../../../portal/session/session.js';
+export declare const SCREEN_REQUEST_CHECK_ENV = "RETICLE_SCREEN_REQUEST_CHECK";
+export interface SentBody {
+    method: string;
+    url: string;
+    /** The request body as sent (JSON text). */
+    body: string;
+}
+export interface ShownControl {
+    /** `name` or `id` attribute — the only link from a control to a field. */
+    field: string;
+    /** The control's current value (a select's selected option value, an input's text). */
+    value: string;
+    /** What the user sees, when it differs from the value (a select's option label). */
+    label?: string | undefined;
+    ref?: string | undefined;
+}
+export declare function screenRequestMismatches(sent: readonly SentBody[], controls: readonly ShownControl[]): Contradiction[];
+/** Advisory findings for this window, or none when the check is off or nothing was written. */
+export declare function screenRequestFindings(session: Session, windowEvents: readonly ReticleEvent[]): Promise<Contradiction[]>;
+/** The `contradictions` field: the verdict's own, then any advisory ones; omitted when both are empty. */
+export declare function withAdvisories(decided: readonly Contradiction[], advisory: readonly Contradiction[]): {
+    contradictions?: Contradiction[];
+};

package/dist/surface/tools/act/screen-request.js

@@ -0,0 +1,113 @@
+/**
+ * The opt-in screen/request check, wired: after an act_and_wait, compare what the window's write
+ * requests carried with the values the page's form controls show (engine: screen-request.ts).
+ *
+ * OPT-IN (`RETICLE_SCREEN_REQUEST_CHECK=1`) and ADVISORY. It ships behind the flag until its
+ * false-alarm rate is measured at zero on the e2e battery, the benchmark and the persona fixtures;
+ * until then it must cost nothing for anyone who did not ask. It runs AFTER the verdict is decided
+ * and is appended to `contradictions` as an advisory kind, so it can never move a verdict.
+ */
+import { ContradictionKind, EventType, REDACTED_VALUE, ReticleCommand, } from '@reticlehq/core';
+export const SCREEN_REQUEST_CHECK_ENV = 'RETICLE_SCREEN_REQUEST_CHECK';
+const READ_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+/** The form controls whose value a request can carry. */
+const CONTROL_ROLES = ['combobox', 'listbox', 'textbox', 'spinbutton'];
+function primitiveFields(body) {
+    const out = new Map();
+    try {
+        const parsed = JSON.parse(body);
+        if ('object' !== typeof parsed || null === parsed || Array.isArray(parsed))
+            return out;
+        for (const [key, value] of Object.entries(parsed)) {
+            if ('string' === typeof value || 'number' === typeof value || 'boolean' === typeof value) {
+                out.set(key.toLowerCase(), String(value));
+            }
+        }
+    }
+    catch {
+        // Not JSON: nothing comparable, so nothing reported.
+    }
+    return out;
+}
+function pathOf(url) {
+    try {
+        return new URL(url, 'http://local.invalid').pathname;
+    }
+    catch {
+        return url;
+    }
+}
+export function screenRequestMismatches(sent, controls) {
+    const out = [];
+    for (const request of sent) {
+        const fields = primitiveFields(request.body);
+        if (0 === fields.size)
+            continue;
+        for (const control of controls) {
+            const key = control.field.toLowerCase();
+            const carried = fields.get(key);
+            if (carried === undefined || carried === control.value)
+                continue;
+            const shown = control.label !== undefined && control.label !== control.value
+                ? `"${control.label}" (value "${control.value}")`
+                : `"${control.value}"`;
+            out.push({
+                kind: ContradictionKind.SCREEN_REQUEST_MISMATCH,
+                claim: `the screen's "${control.field}" control shows ${shown}`,
+                counter: `${request.method.toUpperCase()} ${pathOf(request.url)} sent ${control.field}=${JSON.stringify(carried)}`,
+                detail: `${control.ref === undefined ? '' : `${control.ref} `}${control.field}: shown ${shown}, sent ${JSON.stringify(carried)}`,
+            });
+        }
+    }
+    return out;
+}
+function sentBodies(events) {
+    return events.flatMap((event) => {
+        if (EventType.NET_REQUEST !== event.type)
+            return [];
+        const raw = event.data['method'];
+        const method = ('string' === typeof raw ? raw : 'GET').toUpperCase();
+        const body = event.data['requestBody'];
+        const url = event.data['url'];
+        if (READ_METHODS.has(method) || 'string' !== typeof body || 'string' !== typeof url)
+            return [];
+        return [{ method, url, body }];
+    });
+}
+async function shownControls(session) {
+    const out = [];
+    for (const role of CONTROL_ROLES) {
+        const res = await session.command(ReticleCommand.MATCH, {
+            query: { role, attrs: ['name', 'id'] },
+        });
+        if (!res.ok)
+            continue;
+        for (const el of res.result?.elements ?? []) {
+            const field = el.attrs?.['name'] ?? el.attrs?.['id'];
+            // No value read, or a redacted one: nothing to compare, so nothing is guessed.
+            if (field === undefined || el.value === undefined || REDACTED_VALUE === el.value)
+                continue;
+            out.push({ field, value: el.value, ref: el.ref });
+        }
+    }
+    return out;
+}
+/** Advisory findings for this window, or none when the check is off or nothing was written. */
+export async function screenRequestFindings(session, windowEvents) {
+    if ('1' !== process.env[SCREEN_REQUEST_CHECK_ENV])
+        return [];
+    const sent = sentBodies(windowEvents);
+    if (0 === sent.length)
+        return [];
+    try {
+        return screenRequestMismatches(sent, await shownControls(session));
+    }
+    catch {
+        return [];
+    }
+}
+/** The `contradictions` field: the verdict's own, then any advisory ones; omitted when both are empty. */
+export function withAdvisories(decided, advisory) {
+    const all = [...decided, ...advisory];
+    return 0 === all.length ? {} : { contradictions: all };
+}

package/dist/surface/tools/act/sequence-grade.d.ts

@@ -40,6 +40,12 @@ export interface StepExpectation {
      * filter act_and_wait applies. A held step with one is a UI that advanced over a failed write.
      */
     contradicted?: readonly string[];
+    /**
+     * Why this step could not be judged at all: its target was missing (nothing was acted on), the
+     * page left the app and the observation went with it, or the predicate could not be read. Such a
+     * step is undecided, never a miss — `unknown`, as act_and_wait says.
+     */
+    undecided?: string;
 }
 export interface SequenceGrade {
     verified: Verified;
@@ -80,5 +86,7 @@ export declare function gradeSequence(steps: readonly StepExpectation[], plan?:
  * two-of-twelve plan as a regression flow is a reasonable thing to do and a bad thing to do without
  * knowing it.
  */
+/** The stopped recording a proved journey is held under, so the `keep` offer can be taken. */
+export declare const JOURNEY_RECORDING = "last-journey";
 export declare function offerToKeep(grade: SequenceGrade): string | undefined;
 export {};

package/dist/surface/tools/act/sequence-grade.js

@@ -29,7 +29,7 @@ export function gradeSequence(steps, plan = { planned: steps.length, dispatched:
     const declared = declaring.length;
     // `held: false` on an undeclared step means it could not be performed at all — the journey broke
     // there whether or not anything was declared about it.
-    const missed = steps.find((step) => (step.declared ? true !== step.held : false === step.held));
+    const missed = steps.find((step) => step.undecided === undefined && (step.declared ? true !== step.held : false === step.held));
     // A miss decides the grade before coverage does. How much of the plan declared nothing is
     // context on a red, never a softening of it.
     if (missed !== undefined) {
@@ -52,6 +52,15 @@ export function gradeSequence(steps, plan = { planned: steps.length, dispatched:
             because: `step ${String(contradictedAt + 1)}: channels disagree about this action (${kinds}) even though it went on`,
         };
     }
+    // Nothing failed that was seen: a step nobody could judge leaves the plan undecided, saying why.
+    const unjudged = steps.find((step) => step.undecided !== undefined);
+    if (unjudged !== undefined)
+        return {
+            verified: Verified.UNKNOWN,
+            declared,
+            total,
+            because: `a step could not be judged — ${unjudged.undecided ?? ''}`,
+        };
     /*
      * `unknown` rather than `no-fault`, and the distinction is load-bearing.
      *
@@ -125,11 +134,13 @@ export function gradeSequence(steps, plan = { planned: steps.length, dispatched:
  * two-of-twelve plan as a regression flow is a reasonable thing to do and a bad thing to do without
  * knowing it.
  */
+/** The stopped recording a proved journey is held under, so the `keep` offer can be taken. */
+export const JOURNEY_RECORDING = 'last-journey';
 export function offerToKeep(grade) {
     if (grade.verified !== Verified.YES || 0 === grade.declared)
         return undefined;
     return (`this plan proved something (${String(grade.declared)} of ${String(grade.total)} steps declared a ` +
         'consequence and every one held) — keep it as a regression flow with ' +
-        'reticle_flow_save { saveAs: "<name>" }, and the steps that declared nothing will replay ' +
+        `reticle_flow_save { flowName: "${JOURNEY_RECORDING}", saveAs: "<name>" }, and the steps that declared nothing will replay ` +
         'without proving anything, exactly as they did here');
 }

package/dist/surface/tools/act-sequence-tool.js

@@ -12,22 +12,28 @@
 import { z } from 'zod';
 import { timeoutMsSchema } from './args/numeric-bounds.js';
 import { compileSequenceStep, pathOf } from '../../language/flows/replay.js';
+import { DEFAULT_SEQUENCE_STEP_TIMEOUT_MS } from '../../language/flows/flow-step-runners.js';
 import { sequenceStepArgs } from './act/act-preflight.js';
-import { ReticleTool } from '@reticlehq/core';
+import { REPLAY_PROGRAM_VERSION, ReticleTool, Verified, VerifiedReason, } from '@reticlehq/core';
 import { healthEnvelope } from '../../portal/session/session-health.js';
 import { pausedShortCircuit, pausedOutputShape, withControl, } from '../../portal/session/control-envelope.js';
 import { asRecord, isAbsenceDerived, isAdvisory } from '@reticlehq/core';
 import { sessionIdFromArgs } from './tools-helpers.js';
 import { describeStepResult, runStepWithStaleRetry } from './act/act-sequence-retry.js';
 import { assertSequenceSteps } from './act/act-preflight.js';
-import { sessionIdShape } from './tool-kit.js';
+import { EnvelopeKey, sessionIdShape } from './tool-kit.js';
+import { takeStepShot } from '../../features/visual/step-shots.js';
 import { actCommand } from './act-tools.js';
 import { PredicateSchema, waitForPredicate, } from '@reticlehq/engine/question/predicate/predicate.js';
-import { DeviationMode, gradeSequence, offerToKeep, } from './act/sequence-grade.js';
+import { DeviationMode, gradeSequence, JOURNEY_RECORDING, offerToKeep, } from './act/sequence-grade.js';
 import { stepEffect } from '@reticlehq/engine/evidence/step-effect.js';
 // resolveActTarget moved out of act-tools into its own module on this branch; #706 was written
 // against the older layout where act-tools re-exported it.
 import { resolveActTarget } from './act/act-target.js';
+import { gradeOfPredicate } from './assert/assert-grade.js';
+import { describeWaitTarget } from '@reticlehq/engine/evidence/unsettled.js';
+import { sourceOf } from './tools-helpers.js';
+import { confirmedByDeclaration } from './act/act-danger.js';
 /**
  * The step's effect record, best-effort.
  *
@@ -45,6 +51,38 @@ function effectOf(session, since) {
         return {};
     }
 }
+/** The verdict effect for one step: the same rules act_and_wait applies to one action. */
+function stepVerdictEffect(check) {
+    const { verified, reason } = check.held
+        ? 0 < check.contradicted.length
+            ? { verified: Verified.NO, reason: VerifiedReason.CONTRADICTED }
+            : { verified: Verified.YES, reason: undefined }
+        : check.undecided
+            ? { verified: Verified.UNKNOWN, reason: VerifiedReason.OBSERVATION_LOST }
+            : { verified: Verified.NO, reason: VerifiedReason.ASSERTION_FAILED };
+    const source = sourceOf(check.source);
+    return {
+        claim: describeWaitTarget(check.expect),
+        verified,
+        ...(source === undefined ? {} : { source: `${source.file}:${String(source.line)}` }),
+        ...(check.expected === undefined ? {} : { expected: check.expected }),
+        ...(check.observed === undefined ? {} : { observed: check.observed }),
+        // Named in the step before the step ran — a check, not a rationalisation.
+        declaredBeforeActing: true,
+        grade: gradeOfPredicate(check.expect),
+        kind: check.expect.kind,
+        ...(reason === undefined ? {} : { reason }),
+    };
+}
+/** One step's check, journaled best-effort: the record must never fail the drive it records. */
+function journalStep(session, args, effect) {
+    try {
+        session.recordAction(ReticleTool.ACT_SEQUENCE, args, effect);
+    }
+    catch {
+        // ponytail: a session without a journal (a test double, journaling off) keeps no check.
+    }
+}
 /**
  * Ceiling for a burst gap. Past this it is not a burst, it is a paced walk.
  *
@@ -57,6 +95,8 @@ function effectOf(session, since) {
  * number: read its own slow endpoint.
  */
 const BURST_MAX_GAP_MS = 500;
+/** A step error that means nothing was acted on, or the page went away with the observation. */
+const UNJUDGED_STEP = /matched no element|no longer resolves|session disconnected|session (was )?replaced/i;
 export const ACT_SEQUENCE_TOOL = {
     name: ReticleTool.ACT_SEQUENCE,
     // The example is required for a core tool, and this one carries weight: the loop it replaces is
@@ -96,6 +136,8 @@ export const ACT_SEQUENCE_TOOL = {
         since: z.number(),
         dispatched: z.boolean(),
         completed: z.number(),
+        /** Number of steps included in the saved recording, when a recording was created. */
+        recorded: z.number(),
         stalled_at: z.number().optional(),
         /** Index of the step whose declared consequence did not hold, when one did not. */
         stopped_at: z.number().optional(),
@@ -137,8 +179,17 @@ export const ACT_SEQUENCE_TOOL = {
         try {
             const inputSteps = Array.isArray(args['steps']) ? args['steps'] : [];
             assertSequenceSteps(inputSteps);
-            const perStepTimeout = 'number' === typeof args['timeout_ms'] ? args['timeout_ms'] : 8000;
+            const perStepTimeout = 'number' === typeof args['timeout_ms']
+                ? args['timeout_ms']
+                : DEFAULT_SEQUENCE_STEP_TIMEOUT_MS;
             const stepResults = [];
+            // Every step leaves a picture of the page as its outcome was decided — see step-shots.ts.
+            const pushStep = async (row) => {
+                stepResults.push({
+                    ...row,
+                    [EnvelopeKey.SCREENSHOT]: await takeStepShot(deps, session.id, ReticleTool.ACT),
+                });
+            };
             const expectations = [];
             // `true` means the default window; a number means that window exactly. 0 is legal and means
             // "no settle at all" — useful only when the app issues its request synchronously.
@@ -181,9 +232,9 @@ export const ACT_SEQUENCE_TOOL = {
                             // race rAF and return early anyway — a budget is a CEILING, not a floor, which is
                             // why an earlier attempt to pace with `settleMs` alone produced a 12ms step and
                             // no race at all.
-                            args: burstGapMs === undefined
-                                ? sequenceStepArgs(step)
-                                : { ...sequenceStepArgs(step), settleMs: 0 },
+                            // A step that names its dangerous control and declares its consequence is
+                            // confirmed by that declaration, as act_and_wait is — see confirmedByDeclaration.
+                            args: ((stepArgs) => burstGapMs === undefined ? stepArgs : { ...stepArgs, settleMs: 0 })(confirmedByDeclaration(sequenceStepArgs(step), step['target'], step['expect'] !== undefined)),
                         }, perStepTimeout);
                     }, session, since, perStepTimeout);
                     // Hold the gap BEFORE the next dispatch, measured from this step's own start so the
@@ -197,16 +248,19 @@ export const ACT_SEQUENCE_TOOL = {
                     }
                     if (!outcome.ok) {
                         stalledAt = i;
-                        stepResults.push({
+                        await pushStep({
                             ref: step['ref'],
                             action: step['action'],
                             dispatched: false,
                             error: outcome.error ?? 'step failed',
                         });
+                        const error = outcome.error ?? 'the step could not be performed';
                         expectations.push({
                             declared: undefined !== step['expect'],
                             held: false,
-                            observed: outcome.error ?? 'the step could not be performed',
+                            observed: error,
+                            // Nothing acted on, or the page gone with the observation: undecided, not a miss.
+                            ...(UNJUDGED_STEP.test(error) ? { undecided: error } : {}),
                         });
                         break;
                     }
@@ -218,10 +272,13 @@ export const ACT_SEQUENCE_TOOL = {
                      * cannot be read. Sharing the builder is what makes that true by construction rather than
                      * by two implementations agreeing today.
                      */
-                    const described = {
+                    const describe = () => ({
                         ...describeStepResult(step, asRecord(outcome.result)),
                         ...effectOf(session, stepSince),
-                    };
+                    });
+                    const deciding = (step) => (step.contradictions ?? [])
+                        .map((c) => c.kind)
+                        .filter((kind) => !isAdvisory(kind) && !isAbsenceDerived(kind));
                     /*
                      * Evaluate what the step SAID it would cause, in the window this step opened.
                      *
@@ -230,29 +287,61 @@ export const ACT_SEQUENCE_TOOL = {
                      * satisfy step four's assertion, which is a false green built out of correct parts.
                      */
                     const parsed = PredicateSchema.safeParse(step['expect']);
-                    const contradicted = (described.contradictions ?? [])
-                        .map((c) => c.kind)
-                        .filter((kind) => !isAdvisory(kind) && !isAbsenceDerived(kind));
-                    const disagreement = 0 === contradicted.length ? {} : { contradicted };
                     if (!parsed.success) {
-                        expectations.push({ declared: false, ...disagreement });
-                        stepResults.push(described);
+                        const described = describe();
+                        const contradicted = deciding(described);
+                        expectations.push({
+                            declared: false,
+                            ...(0 === contradicted.length ? {} : { contradicted }),
+                        });
+                        await pushStep(described);
                     }
                     else {
                         const verdict = await waitForPredicate(session, parsed.data, perStepTimeout, stepSince);
+                        // Described over the window the verdict was taken in, not the dispatch window before it:
+                        // a step that waited 1.5s for its declared 200 reported that request "still in flight"
+                        // beside `held: true`, a contradiction about a moment the verdict was not taken at.
+                        const described = describe();
+                        const contradicted = deciding(described);
+                        const disagreement = 0 === contradicted.length ? {} : { contradicted };
                         const held = true === verdict.pass;
+                        // A tab that went away (an external checkout page) or a predicate that could not be
+                        // read decided nothing: unknown, never a miss blamed on the app.
+                        const undecided = !held && (true === verdict.observationLost || verdict.inconclusive !== undefined);
+                        // One check per declared step, journaled as act_and_wait journals its own, so the
+                        // session's result, its run file and the dashboard all count it. See sequence-journal.ts.
+                        journalStep(session, { step: i, expect: step['expect'] }, stepVerdictEffect({
+                            expect: parsed.data,
+                            held,
+                            undecided,
+                            contradicted,
+                            expected: verdict.expected,
+                            observed: held ? undefined : (verdict.observed ?? verdict.failureReason),
+                            source: asRecord(outcome.result)['source'],
+                        }));
                         expectations.push({
                             declared: true,
                             held,
+                            ...(undecided
+                                ? {
+                                    undecided: true === verdict.observationLost
+                                        ? `${verdict.failureReason ?? 'the observation was lost'} (the page left)`
+                                        : (verdict.failureReason ?? 'the predicate could not be read'),
+                                }
+                                : {}),
                             ...disagreement,
                             ...(verdict.observed === undefined ? {} : { observed: verdict.observed }),
                             ...(verdict.expected === undefined ? {} : { expected: verdict.expected }),
                         });
-                        stepResults.push({
+                        await pushStep({
                             ...described,
                             expected: verdict.expected ?? true,
                             held,
                             ...(held ? {} : { observed: verdict.observed ?? verdict.failureReason }),
+                            // What would have held, on a case-only miss — the verdict stays a miss.
+                            ...(true === verdict.caseOnlyMiss
+                                ? { caseOnlyMiss: true, wouldHold: verdict.wouldHold }
+                                : {}),
                         });
                         if (!held) {
                             stoppedAt ??= i;
@@ -263,7 +352,7 @@ export const ACT_SEQUENCE_TOOL = {
                 }
                 catch (err) {
                     stalledAt = i;
-                    stepResults.push({
+                    await pushStep({
                         ref: step['ref'],
                         action: step['action'],
                         dispatched: null,
@@ -285,24 +374,30 @@ export const ACT_SEQUENCE_TOOL = {
              * The halted step counts: it WAS dispatched, and only the consequence it declared failed
              * afterwards. A stalled step never ran, which is why that index stays exclusive.
              */
-            const completed = stoppedAt !== undefined ? stoppedAt + 1 : (stalledAt ?? inputSteps.length);
+            const completed = DeviationMode.CONTINUE === onDeviation
+                ? (stalledAt ?? inputSteps.length)
+                : stoppedAt !== undefined
+                    ? stoppedAt + 1
+                    : (stalledAt ?? inputSteps.length);
             if (completed > 0) {
                 session.lastAct.markActed(since, undefined, undefined);
             }
             // Same as captureAct: no `active()` gate, so a sequence driven with nothing open still lands
-            // in the ambient tape. A stalled plan is still excluded — those steps never ran.
-            if (stalledAt === undefined) {
+            // in the ambient tape. A stalled plan keeps only the prefix whose steps actually ran.
+            let journey;
+            if (completed > 0) {
                 // A sub-step keeps its `expect` only if it held — same rule as act_and_wait, so a flow
                 // never replays an expectation that was never once observed to hold.
-                const proved = inputSteps.map((raw, i) => {
+                const proved = inputSteps.slice(0, completed).map((raw, i) => {
                     const step = asRecord(raw);
                     const { expect: _expect, ...rest } = step;
                     return true === expectations[i]?.held ? step : rest;
                 });
                 const recorded = compileSequenceStep({ ...args, steps: proved }, {
-                    count: inputSteps.length,
-                    steps: stepResults,
+                    count: completed,
+                    steps: stepResults.slice(0, completed),
                 });
+                journey = recorded;
                 deps.recordings.capture(pageBefore === undefined ? recorded : { ...recorded, page: pageBefore }, undefined, session.id);
                 deps.recordings.markEnded(pathOf(session.url), session.id);
             }
@@ -317,12 +412,26 @@ export const ACT_SEQUENCE_TOOL = {
                 planned: inputSteps.length,
                 dispatched: completed > 0,
             });
-            const ran = stoppedAt ?? stalledAt ?? inputSteps.length;
-            const tail = inputSteps.slice(ran + (stoppedAt === undefined ? 0 : 1));
+            // The journey a `keep` offer names, held as a stopped recording so `reticle_flow_save
+            // { flowName: JOURNEY_RECORDING, saveAs }` saves exactly what was just driven. The offer used
+            // to name a save that refused with no recording, a dead end that cost a round trip.
+            if (journey !== undefined && offerToKeep(grade) !== undefined) {
+                deps.recordings.saveCompiled({
+                    name: JOURNEY_RECORDING,
+                    version: REPLAY_PROGRAM_VERSION,
+                    steps: [journey],
+                    ...(pageBefore === undefined ? {} : { startPath: pageBefore }),
+                });
+            }
+            const tailStart = DeviationMode.HALT === onDeviation && stoppedAt !== undefined
+                ? stoppedAt + 1
+                : (stalledAt ?? inputSteps.length);
+            const tail = inputSteps.slice(tailStart);
             return withControl(session, {
                 since,
                 dispatched: completed > 0,
                 completed,
+                recorded: journey === undefined ? 0 : completed,
                 ...(stalledAt !== undefined ? { stalled_at: stalledAt } : {}),
                 ...(stoppedAt !== undefined ? { stopped_at: stoppedAt } : {}),
                 verified: grade.verified,

package/dist/surface/tools/act-tools.d.ts

@@ -1,12 +1,3 @@
-/**
- * Action tools — reticle_act and reticle_act_and_wait. Split out of tools.ts to keep that file under
- * the line cap and assembled back into the tool list there via ...ACT_TOOLS; the native-input attempt
- * itself lives in real-input-attempt.ts for the same reason.
- *
- * `reticle_act_sequence` is a sibling file and is assembled by `tools.ts` directly. It used to be
- * re-exported through this list, which made a cycle out of nothing: that file needs `actCommand` from
- * here, and a registry is the right place to collect a definition from.
- */
 import type { Session } from '../../portal/session/session.js';
 import { type ToolDef, type ToolDeps } from './tool-kit.js';
 /**