@reticlehq/server 2.4.0 → 2.6.0

package/dist/tools/act-tools.js

@@ -1,104 +1,35 @@
 /**
- * Action tools — reticle_act, reticle_act_sequence, reticle_act_and_wait — plus the native-input machinery
- * (asBox / tryRealInput). Split out of tools.ts to keep that file under the line cap; assembled back
- * into the tool list there via...ACT_TOOLS.
+ * Action tools — reticle_act, reticle_act_sequence, 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.
  */
 import { z } from 'zod';
-import { compileActStep, compileSequenceStep } from '../flows/replay.js';
-import { ActionType, ActionWarning, DEFAULT_ASSERT_TIMEOUT_MS, InputMode, InputModeReason, ReticleCommand, } from '@reticlehq/core';
-import { isPointerAction } from '../input/real-input.js';
+import { aliasParam } from './alias-args.js';
+import { captureAct, compileSequenceStep } from '../flows/replay.js';
+import { ActionType, ActionWarning, DEFAULT_ASSERT_TIMEOUT_MS, InputMode, ReticleCommand, Verified, PredicateKind, } from '@reticlehq/core';
+import { assertNativeInputSupported } from './act-danger.js';
 import { leanActResult, mutatedWithin } from './act-view.js';
 import { ReticleTool } from './tool-names.js';
 import { buildReactionReport, summarizeReaction } from '../events/reaction.js';
+import { parsePredicate } from '../events/predicate-parse.js';
 import { causalSummary } from '../capsule/causal-summary.js';
 import { findContradictions } from '../events/contradictions.js';
 import { decideVerified } from '../honesty/verified.js';
+import { readsDomState } from '../honesty/already-true.js';
 import { saveFailedAssertCapsule } from './act-capsule.js';
 import { buildDivergenceCapsule } from '../capsule/capsule.js';
 import { predicateToExpectedLinks } from '../capsule/predicate-to-links.js';
 import { buildHonestyBlock } from '../honesty/honesty.js';
-import { buildCoverageStatement, blindSpotsFromState, impeachesCapture, } from '../honesty/blind-spots.js';
+import { buildCoverageStatement, blindSpotsFromState, transportGapNote, Coverage, impeachesCapture, } from '../honesty/blind-spots.js';
 import { hasAcceptedWrite } from '../honesty/accepted-write.js';
 import { hasUnreadWriteOutcome } from '../honesty/unread-outcome.js';
-import { assertDragNotDestructive, assertNotDestructive } from './act-danger.js';
 import { evaluatePredicate, waitForPredicate, provenExpectedLinks, PredicateSchema, } from '../events/predicate.js';
 import { healthEnvelope, refuseIfThrottled } from '../session/session-health.js';
-import { pausedShortCircuit, pausedOutputShape, withControl } from '../session/control-envelope.js';
+import { pausedShortCircuit, pausedOutputShape, withControl, PAUSED_NO_VERDICT, } from '../session/control-envelope.js';
 import { asString, asNumber, asRecord, sourceOf } from './tools-helpers.js';
-import { sessionIdShape, commandOrThrow } from './tool-kit.js';
-import { asActionType, asBox, gradeOf } from './act-helpers.js';
-/** Synthetic outcome with a diagnostic reason (provider configured but native input skipped). */
-function synthetic(reason) {
-    return reason === undefined
-        ? { result: undefined, settled: false }
-        : { result: undefined, settled: false, reason };
-}
-/**
- * Attempt to drive a pointer action via native input. Returns a synthetic outcome (with a
- * `reason` when a provider is configured) whenever the synthetic path should run — no matching
- * page, unresolvable box, declined, etc. A throw inside the provider becomes a synthetic fallback
- * flagged with `fellBack`. `result` is defined only on a real success.
- */
-async function tryRealInput(deps, session, ref, action, args) {
-    const provider = deps.realInput;
-    if (provider === undefined)
-        return synthetic(); // real input not configured — no diagnostic
-    if (!isPointerAction(action))
-        return synthetic(InputModeReason.NOT_POINTER); // fill/type stay synthetic
-    const inner = asRecord(args['args']);
-    // "Don't click, run the code": a click/dblclick runs the occlusion-honest SYNTHETIC path by default
-    // even with a provider configured — no coordinate gesture to be intercepted by the HUD or missed
-    // off-screen. Opt into a trusted native click with args.native:true (file pickers, clipboard,
-    // isTrusted-gated handlers). hover/drag genuinely need native pointer state, so they stay real.
-    if ((action === ActionType.CLICK || action === ActionType.DBLCLICK) && inner['native'] !== true) {
-        return synthetic(InputModeReason.SYNTHETIC_CLICK_PREFERRED);
-    }
-    if (!(await provider.isAvailableFor(session.url)))
-        return synthetic(InputModeReason.PAGE_NOT_CORRELATED);
-    const inspected = await commandOrThrow(deps, session.id, ReticleCommand.INSPECT, { ref });
-    assertNotDestructive(action, inner, inspected);
-    const box = asBox(inspected);
-    if (box === undefined)
-        return synthetic(InputModeReason.ELEMENT_NOT_LOCATABLE);
-    let toBox;
-    if (action === ActionType.DRAG) {
-        const toRef = asString(inner['toRef']);
-        if (toRef === undefined)
-            return synthetic(InputModeReason.DRAG_TARGET_UNRESOLVED);
-        const targetInspected = await commandOrThrow(deps, session.id, ReticleCommand.INSPECT, {
-            ref: toRef,
-        });
-        // A drag is judged on BOTH ends: dropping onto "Trash" is destructive however innocent the
-        // thing being dragged looks.
-        assertDragNotDestructive(inner, inspected, targetInspected);
-        toBox = asBox(targetInspected);
-        if (toBox === undefined)
-            return synthetic(InputModeReason.DRAG_TARGET_UNRESOLVED);
-    }
-    const performArgs = {};
-    const value = asString(inner['value']);
-    if (value !== undefined)
-        performArgs.value = value;
-    const text = asString(inner['text']);
-    if (text !== undefined)
-        performArgs.text = text;
-    if (toBox !== undefined)
-        performArgs.toBox = toBox;
-    try {
-        const performed = await provider.perform(session.url, action, box, performArgs);
-        if (!performed.performed)
-            return synthetic(InputModeReason.PROVIDER_DECLINED);
-        return { result: { performed: true, center: performed.center, action }, settled: true };
-    }
-    catch {
-        return {
-            result: undefined,
-            settled: false,
-            fellBack: true,
-            reason: InputModeReason.PROVIDER_ERROR,
-        };
-    }
-}
+import { sessionIdShape } from './tool-kit.js';
+import { asActionType, gradeOf } from './act-helpers.js';
+import { tryRealInput } from './real-input-attempt.js';
 /**
  * Narrow the wire's `action` to a real ActionType, or undefined.
  *
@@ -107,22 +38,33 @@ async function tryRealInput(deps, session, ref, action, args) {
  * as a generic failure rather than "that is not an action". Validate at the boundary, per the project's
  * unknown-plus-narrowing rule, so a typo is rejected where it can still be explained.
  */
+/**
+ * The action vocabulary, derived from ActionType — never retyped.
+ *
+ * The description used to list thirteen actions while ActionType had seventeen: blur, upload, drag
+ * and webmcp were real, callable, and undocumented, because a hand-copied list drifts the moment
+ * someone adds an arm. Deriving both the schema and the prose from the enum makes that impossible.
+ *
+ * The handler already refused an unknown action with a good message; the schema now refuses it
+ * one layer earlier, before any session is resolved or any work is done.
+ */
+const ACTION_TYPE_VALUES = Object.values(ActionType);
+const ACTION_TYPE_LIST = ACTION_TYPE_VALUES.join(' | ');
+const actionTypeEnum = z.enum(ACTION_TYPE_VALUES);
 export const ACT_TOOLS = [
     {
         name: ReticleTool.ACT,
         example: { ref: 'e42', action: 'fill', args: { value: 'hello' } },
-        description: 'Execute one action against a ref: click|dblclick|hover|focus|fill|type|clear|select|check|uncheck|submit|press|scrollIntoView. Returns immediately with a `since` cursor — observe the reaction with reticle_observe. Carries effect:{dispatched,targetMatched,visible,enabled,focusMoved,valueChanged,domMutatedWithin,occluded,occludedBy,scrolledIntoView} to tell "action missed" from "app didn\'t react"; dispatched=landed, settled=a real frame flushed, and a settle timeout never fails the tool. Fields at their uninformative default are OMITTED so a clean action collapses to its consequence: an absent dispatched/targetMatched/visible/enabled means true, an absent occluded/scrolledIntoView/valueChanged/defaultPrevented means false, an absent focusMoved/occludedBy means null. occluded=true means the click point is covered by another element (a real user could not click it) — synthetic dispatch still delivered the event; scrolledIntoView=true means an off-viewport target was scrolled in first. inputMode is "real" (native CDP, no synthetic effect block) or "synthetic"; clicks default to the occlusion-honest synthetic path even when CDP is configured — pass args.native:true to force a trusted native click (file pickers, clipboard). inputModeReason explains any real→synthetic choice so it is never silent. Full model (real-input, throttled tabs, `reticle drive`): docs/usage.md §18.',
+        description: 'Act WITHOUT checking the result — if the action is supposed to cause something, use reticle_act_and_wait { until } instead and get the verdict in the same call. This tool returns immediately with a `since` cursor; observe the reaction yourself with reticle_observe. Use it for actions with no observable consequence to assert (focus, hover, scrollIntoView, a fill you are about to submit). One action against a ref: click|dblclick|hover|focus|fill|type|clear|select|check|uncheck|submit|press|scrollIntoView. Carries effect:{dispatched,targetMatched,visible,enabled,focusMoved,valueChanged,domMutatedWithin,occluded,occludedBy,scrolledIntoView} to tell "action missed" from "app didn\'t react"; dispatched=landed, settled=a real frame flushed, and a settle timeout never fails the tool. Fields at their uninformative default are OMITTED so a clean action collapses to its consequence: an absent dispatched/targetMatched/visible/enabled means true, an absent occluded/scrolledIntoView/valueChanged/defaultPrevented means false, an absent focusMoved/occludedBy means null. occluded=true means the click point is covered by another element (a real user could not click it) — synthetic dispatch still delivered the event; scrolledIntoView=true means an off-viewport target was scrolled in first. inputMode is "real" (native CDP, no synthetic effect block) or "synthetic"; clicks default to the occlusion-honest synthetic path even when CDP is configured — pass args.native:true to force a trusted native click (file pickers, clipboard). args.holdMs keeps the pointer DOWN for that long between mousedown and mouseup — the only way to drive a hold-to-confirm control (hold-to-delete, hold-to-record, long-press); effect.heldMs reports the hold actually achieved, which a throttled background tab can stretch. args.confirmDangerous is a permission gate and NOT a duration: it allows a destructive control, it does not hold one. inputModeReason explains any real→synthetic choice so it is never silent. Full model (real-input, throttled tabs, `reticle drive`): docs/usage.md §18.',
         inputSchema: {
             ref: z
                 .string()
                 .describe(`Element ref (e.g. 'e42') from reticle_snapshot/reticle_query — stable until the element leaves the DOM, so no re-snapshot between actions.`),
-            action: z
-                .string()
-                .describe('Action to perform: click | dblclick | hover | focus | fill | type | clear | select | check | uncheck | submit | press | scrollIntoView'),
+            action: actionTypeEnum.describe(`Action to perform: ${ACTION_TYPE_LIST}`),
             args: z
                 .record(z.unknown())
                 .optional()
-                .describe('Action-specific arguments: { value } for fill/select, { text } for type/press, { native: true } to force a trusted native click, { confirmDangerous: true } to allow a potentially destructive control.'),
+                .describe('Action-specific arguments: { value } for fill/select, { text } for type/press, { native: true } to force a trusted native click, { holdMs: N } to keep the pointer DOWN for N ms (hold-to-confirm controls; effect.heldMs reports what was achieved), { confirmDangerous: true } to allow a potentially destructive control — a permission gate, NOT a duration.'),
             refuseWhenThrottled: z
                 .boolean()
                 .optional()
@@ -163,10 +105,8 @@ export const ACT_TOOLS = [
                 return paused;
             refuseIfThrottled(session, args['refuseWhenThrottled']);
             const since = session.elapsed();
-            session.lastAct.markCursor(since); // honesty: wait_for/assert default their floor to this cursor
-            // Cleared up front: a throw between here and the result must not leave the PREVIOUS act's
-            // measurement standing, which would judge this window with the last one's evidence.
-            session.lastAct.markEffect(asString(args['action']), undefined);
+            // The act cursor + effect are marked only once the action has actually DISPATCHED (below, on
+            // each success path) — a refused act must leave nothing behind for the next observe to judge.
             const ref = asString(args['ref']) ?? '';
             // Open the journal's action-attribution window BEFORE dispatching, so it covers the native path
             // too. It used to open only on the synthetic path, and the native path returned above it — so a
@@ -181,10 +121,11 @@ export const ACT_TOOLS = [
                 // drive native pointer input when a provider is available; otherwise fall back.
                 const real = await tryRealInput(deps, session, ref, action, args);
                 if (real.result !== undefined) {
-                    if (deps.recordings.active().length > 0) {
-                        deps.recordings.capture(compileActStep(args, real.result));
-                    }
+                    captureAct(deps.recordings, args, real.result);
                     settledOutcome = real.settled ?? undefined;
+                    // Native input reports no synthetic effect block, so nothing measured in-target: undefined
+                    // (the weaker empty-window test), never a fabricated zero.
+                    session.lastAct.markActed(since, action, undefined);
                     return withControl(session, {
                         since,
                         inputMode: InputMode.REAL,
@@ -202,17 +143,15 @@ export const ACT_TOOLS = [
                 });
                 if (!result.ok)
                     throw new Error(result.error ?? 'act failed');
-                if (deps.recordings.active().length > 0) {
-                    deps.recordings.capture(compileActStep(args, result.result));
-                }
+                captureAct(deps.recordings, args, result.result);
                 // lift dispatch/settle status to the envelope (a settle timeout is NOT a failure).
                 const r = asRecord(result.result);
-                if (typeof r['settled'] === 'boolean')
+                if ('boolean' === typeof r['settled'])
                     settledOutcome = r['settled'];
                 // Keep what only this call measured, so the observe that judges this window can ask whether
                 // anything happened INSIDE the target — the one fact that separates a dead control from a
                 // page that was merely busy with something else.
-                session.lastAct.markEffect(asString(args['action']), mutatedWithin(r));
+                session.lastAct.markActed(since, action, mutatedWithin(r));
                 return withControl(session, {
                     since,
                     inputMode: InputMode.SYNTHETIC,
@@ -222,19 +161,30 @@ export const ACT_TOOLS = [
                     settled: r['settled'] ?? null,
                     settleReason: r['settleReason'] ?? null,
                     result: leanActResult(result.result),
-                    ...(real.fellBack === true ? { warning: ActionWarning.REAL_INPUT_FELL_BACK } : {}),
+                    ...(true === real.fellBack ? { warning: ActionWarning.REAL_INPUT_FELL_BACK } : {}),
                     ...healthEnvelope(session),
                 });
             }
             finally {
                 // Close the window on every exit (settle or throw), recording the action + settle outcome.
-                session.finishAction(undefined, settledOutcome, settledOutcome === true ? session.elapsed() - since : undefined);
+                session.finishAction(undefined, settledOutcome, true === settledOutcome ? session.elapsed() - since : undefined);
             }
         },
     },
     {
         name: ReticleTool.ACT_SEQUENCE,
-        description: 'Run multiple actions in order (fill -> fill -> submit) in one round-trip. Returns per-step effects[] (see reticle_act).',
+        // The example is required for a core tool, and this one carries weight: the measured loop it
+        // replaces is literally a login form driven as three separate reticle_act calls (98 clicks and
+        // 21 fills inside looping sessions, 2026-08-10/11). Showing fill -> fill -> click is showing the
+        // exact shape an agent otherwise spends three round trips on.
+        example: {
+            steps: [
+                { ref: 'e12', action: 'fill', args: { value: 'a@b.com' } },
+                { ref: 'e13', action: 'fill', args: { value: 'hunter2' } },
+                { ref: 'e14', action: 'click' },
+            ],
+        },
+        description: 'Run multiple actions in order (fill -> fill -> submit) in ONE round-trip. Prefer this over repeating reticle_act for a multi-step journey, then assert its consequence once. Returns per-step effects[] (see reticle_act).',
         inputSchema: {
             steps: z
                 .array(z.record(z.unknown()))
@@ -258,12 +208,15 @@ export const ACT_TOOLS = [
             if (paused !== undefined)
                 return paused;
             const since = session.elapsed();
-            session.lastAct.markCursor(since); // honesty: a later wait_for/assert floors at this cursor
             session.beginAction(ReticleTool.ACT_SEQUENCE, asRecord(args));
             try {
                 const result = await session.command(ReticleCommand.ACT_SEQUENCE, { steps: args['steps'] });
                 if (!result.ok)
                     throw new Error(result.error ?? 'act_sequence failed');
+                // Marked only once the sequence ran: a refused sequence must leave no cursor behind for a
+                // later observe to judge. No single action and no in-target measurement here — per-step
+                // effects live in steps[] — so the effect is cleared rather than inherited from an earlier act.
+                session.lastAct.markActed(since, undefined, undefined);
                 if (deps.recordings.active().length > 0) {
                     deps.recordings.capture(compileSequenceStep(args, result.result));
                 }
@@ -283,7 +236,11 @@ export const ACT_TOOLS = [
     },
     {
         name: ReticleTool.ACT_AND_WAIT,
-        example: { ref: 'e42', action: 'click', until: { kind: 'signal', name: 'todos:loaded' } },
+        example: {
+            ref: 'e42',
+            action: 'click',
+            until: { kind: PredicateKind.SIGNAL, name: 'todos:loaded' },
+        },
         description: 'Act on a ref, then wait for a predicate to hold — one hop for the act->observe->assert loop. ' +
             'Omit `until` to wait for the page to settle (network + DOM idle) — use this instead of a fixed sleep. ' +
             'Returns { effect } (the action result), { verdict } (predicate pass/evidence/near-miss), ' +
@@ -294,13 +251,12 @@ export const ACT_TOOLS = [
             ref: z
                 .string()
                 .describe(`Element ref (e.g. 'e42') from reticle_snapshot/reticle_query — stable until the element leaves the DOM, so no re-snapshot between actions.`),
-            action: z
-                .string()
-                .describe('Action to perform: click | dblclick | hover | focus | fill | type | clear | select | check | uncheck | submit | press | scrollIntoView'),
+            action: actionTypeEnum.describe(`Action to perform: ${ACTION_TYPE_LIST}`),
             args: z
                 .record(z.unknown())
                 .optional()
                 .describe('Action-specific arguments: { value } for fill/select, { text } for type/press, { confirmDangerous: true } for a potentially destructive control.'),
+            predicate: PredicateSchema.optional().describe('Alias for `until` (the name reticle_assert / reticle_wait_for use).'),
             until: PredicateSchema.optional().describe('Predicate to wait for after the action completes (same shape as reticle_assert). OMIT to wait for the page to SETTLE — network + DOM idle — the deterministic default instead of a sleep. To assert a consequence AND settle, allOf them: { kind: "allOf", predicates: [<your predicate>, { kind: "settled" }] }.'),
             timeout_ms: z
                 .number()
@@ -320,6 +276,10 @@ export const ACT_TOOLS = [
                 pass: z.boolean(),
                 evidence: z.unknown().optional(),
                 failureReason: z.string().optional(),
+                observationLost: z
+                    .boolean()
+                    .optional()
+                    .describe('The tab disconnected mid-wait, so this was never observed — the verdict is UNKNOWN, not a failure of the app.'),
                 // The STRUCTURED cause — observed / expected / assertion — is what the repair literature ranks
                 // above the prose failureReason (structured feedback beat narrative by 10.5pp) and above a bare
                 // pointer. `verdict` is `await waitForPredicate(...)`, whose EvalResult carries these on a
@@ -374,26 +334,44 @@ export const ACT_TOOLS = [
         handler: async (deps, args) => {
             const session = deps.sessions.resolve(asString(args['sessionId']));
             // Live-control: refuse to drive the page (no act, no predicate eval) while paused.
+            //
+            // A VERDICT rides out with the refusal. This is the one tool here that promises `verified`,
+            // and the bare pause payload omitted it — so an agent reading `result.verified` got undefined
+            // from a call that carried no error, which is neither yes, no, nor unknown. It also broke this
+            // tool's own outputSchema, where `because` is required.
             const paused = pausedShortCircuit(session);
-            if (paused !== undefined)
-                return paused;
+            if (paused !== undefined) {
+                return { ...paused, verified: Verified.UNKNOWN, because: PAUSED_NO_VERDICT };
+            }
             refuseIfThrottled(session, args['refuseWhenThrottled']);
             // Omitting `until` waits for the page to settle (idle) — the deterministic default vs a sleep.
-            const until = args['until'] !== undefined
-                ? PredicateSchema.parse(args['until'])
-                : { kind: 'settled' };
+            // `predicate` is what reticle_assert / reticle_wait_for call this — see alias-args.ts.
+            const withUntil = aliasParam(args, 'until', ['predicate']);
+            const until = withUntil['until'] !== undefined
+                ? parsePredicate(withUntil['until'])
+                : { kind: PredicateKind.SETTLED };
             const timeout = asNumber(args['timeout_ms']) ?? DEFAULT_ASSERT_TIMEOUT_MS;
+            // Before anything is driven: this path cannot honour a native-input request, and taking the
+            // argument and ignoring it told the agent its trusted click had happened. See act-danger.
+            assertNativeInputSupported(asRecord(args['args']));
             const since = session.elapsed();
             // `dropped` is cumulative for the SESSION, so comparing against a pre-action reading is what
             // asks "did the buffer lose anything while THIS action was observed?" — the question the
             // honesty block means. Reading the raw total pinned every later verdict to `unknown` after a
             // single early eviction (measured on the Next.js demo at dropped:51, windows intact).
             const droppedBefore = session.bufferHealth().dropped;
-            session.lastAct.markCursor(since);
+            // The cursor + effect are marked after the act dispatches (below) — a refused act leaves none.
             // The attribution window stays open across the settle wait below, so post-dispatch async events
             // (the whole point of act_and_wait) attribute to this action. finishAction fires after the wait.
             session.beginAction(ReticleTool.ACT_AND_WAIT, asRecord(args));
             let settledOutcome;
+            // Was the declared consequence ALREADY TRUE? Only asked for predicates that read live DOM
+            // state — event-based ones are floored at this act's cursor and cannot be satisfied by the
+            // past, so they need no pre-check and pay nothing. One extra query, on the path where a green
+            // is otherwise unfalsifiable. See honesty/already-true.
+            const alreadyTrue = until !== undefined && readsDomState(until)
+                ? (await evaluatePredicate(session, until, since, false)).pass
+                : false;
             try {
                 const actResult = await session.command(ReticleCommand.ACT, {
                     ref: args['ref'],
@@ -402,12 +380,16 @@ export const ACT_TOOLS = [
                 });
                 if (!actResult.ok)
                     throw new Error(actResult.error ?? 'act failed');
+                captureAct(deps.recordings, args, actResult.result);
+                // Dispatched — now this act owns the cursor and the effect. Marking its OWN measurement also
+                // stops the spread below from inheriting an earlier reticle_act's action and mutation count.
+                session.lastAct.markActed(since, asString(args['action']), mutatedWithin(asRecord(actResult.result)));
                 // Honesty: floor the predicate at this act's cursor so a stale buffered event can't satisfy it.
                 const verdict = timeout > 0
                     ? await waitForPredicate(session, until, timeout, since)
                     : await evaluatePredicate(session, until, since);
                 const r = asRecord(actResult.result);
-                if (typeof r['settled'] === 'boolean')
+                if ('boolean' === typeof r['settled'])
                     settledOutcome = r['settled'];
                 // Where the acted element is written. Captured at act time alongside the anchor, so it is
                 // available even when the action unmounted its own target.
@@ -438,12 +420,19 @@ export const ACT_TOOLS = [
                 // structural boundary (virtualized rows, a cross-origin frame) is reported as coverage and
                 // must not downgrade a verdict about what WAS observed.
                 const impeaching = buildCoverageStatement(spots.filter((s) => impeachesCapture(s.kind)));
+                // Same rule as reticle_assert: a browser-side transport gap means part of this window was
+                // never seen, which is what `blindSpots` exists to say. `truncated` above covers the SERVER
+                // ring buffer evicting; this covers the BROWSER queue overflowing, and they are not the same
+                // loss — an act_and_wait that graded `proved` over 34 dropped events said so in a sentence
+                // whose own words were "over a clean capture".
+                const gapNote = transportGapNote(windowEvents);
+                const impeachingNotes = [impeaching.note, gapNote].filter((n) => n !== undefined);
                 const honesty = buildHonestyBlock({
                     grade: gradeOf(gradedLinks),
                     attribution: 'window',
                     truncated: session.bufferHealth().dropped > droppedBefore,
-                    coveragePartial: coverage.coverage === 'partial',
-                    ...(impeaching.note === undefined ? {} : { blindSpots: [impeaching.note] }),
+                    coveragePartial: Coverage.PARTIAL === coverage.coverage,
+                    ...(0 === impeachingNotes.length ? {} : { blindSpots: impeachingNotes }),
                 });
                 const capsuleSaved = await saveFailedAssertCapsule({
                     deps,
@@ -467,6 +456,13 @@ export const ACT_TOOLS = [
                 const outcomeUnread = hasUnreadWriteOutcome(windowEvents);
                 const decision = decideVerified({
                     pass: verdict.pass,
+                    ...(alreadyTrue ? { alreadyTrue } : {}),
+                    // An assertion nobody could evaluate must not be reported as one the app failed.
+                    ...(verdict.inconclusive === undefined ? {} : { inconclusive: verdict.inconclusive }),
+                    // Nor must one nobody could OBSERVE. This is the act path, so it is the one that produced
+                    // the measured false red: a reload mid-wait, graded assertion_failed at the clicked
+                    // component's own file and line.
+                    ...(true === verdict.observationLost ? { observationLost: true } : {}),
                     honesty,
                     contradictions,
                     ...(outcomePending ? { outcomePending } : {}),
@@ -505,7 +501,7 @@ export const ACT_TOOLS = [
                 });
             }
             finally {
-                session.finishAction(undefined, settledOutcome, settledOutcome === true ? session.elapsed() - since : undefined);
+                session.finishAction(undefined, settledOutcome, true === settledOutcome ? session.elapsed() - since : undefined);
             }
         },
     },

package/dist/tools/act-view.js

@@ -23,11 +23,11 @@ const NULL_NOISE = new Set(['occludedBy', 'focusMoved']);
 function leanEffect(effect) {
     const out = {};
     for (const [k, v] of Object.entries(effect)) {
-        if (TRUE_NOISE.has(k) && v === true)
+        if (TRUE_NOISE.has(k) && true === v)
             continue;
-        if (FALSE_NOISE.has(k) && v === false)
+        if (FALSE_NOISE.has(k) && false === v)
             continue;
-        if (NULL_NOISE.has(k) && v === null)
+        if (NULL_NOISE.has(k) && null === v)
             continue;
         out[k] = v;
     }
@@ -35,11 +35,11 @@ function leanEffect(effect) {
 }
 /** Return a copy of an act command result with its `effect` block leaned. Non-objects pass through. */
 export function leanActResult(result) {
-    if (result === null || typeof result !== 'object')
+    if (null === result || typeof result !== 'object')
         return result;
     const r = result;
     const effect = r['effect'];
-    if (effect === null || typeof effect !== 'object')
+    if (null === effect || typeof effect !== 'object')
         return result;
     return { ...r, effect: leanEffect(effect) };
 }
@@ -51,8 +51,8 @@ export function leanActResult(result) {
  */
 export function mutatedWithin(result) {
     const effect = result['effect'];
-    if (typeof effect !== 'object' || effect === null)
+    if (typeof effect !== 'object' || null === effect)
         return undefined;
     const value = effect['domMutatedWithin'];
-    return typeof value === 'number' ? value : 0;
+    return 'number' === typeof value ? value : 0;
 }

package/dist/tools/alias-args.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Accepting a neighbouring tool's spelling for the same parameter.
+ *
+ * Reticle's surface has a few places where one concept has two names, and every one of them is a
+ * rejected call for an agent that learned the other spelling from the tool next door:
+ *
+ *   reticle_act_and_wait { until }  vs  reticle_wait_for / reticle_assert { predicate }
+ *   reticle_annotate     { flow }   vs  every other flow tool          { flowName }
+ *
+ * Both cross a path the product prescribes — `act_and_wait` is the most-used tool, and
+ * `reticle_flow_save`'s own description tells the agent to go and call `reticle_annotate`.
+ *
+ * Aliasing, not renaming: the canonical name stays the contract, an explicit canonical value always
+ * wins, and a call carrying neither is left untouched so the schema error still names what was
+ * missing instead of being replaced by a guess.
+ */
+export declare function aliasParam(args: Record<string, unknown>, canonical: string, aliases: readonly string[]): Record<string, unknown>;

package/dist/tools/alias-args.js

@@ -0,0 +1,25 @@
+/**
+ * Accepting a neighbouring tool's spelling for the same parameter.
+ *
+ * Reticle's surface has a few places where one concept has two names, and every one of them is a
+ * rejected call for an agent that learned the other spelling from the tool next door:
+ *
+ *   reticle_act_and_wait { until }  vs  reticle_wait_for / reticle_assert { predicate }
+ *   reticle_annotate     { flow }   vs  every other flow tool          { flowName }
+ *
+ * Both cross a path the product prescribes — `act_and_wait` is the most-used tool, and
+ * `reticle_flow_save`'s own description tells the agent to go and call `reticle_annotate`.
+ *
+ * Aliasing, not renaming: the canonical name stays the contract, an explicit canonical value always
+ * wins, and a call carrying neither is left untouched so the schema error still names what was
+ * missing instead of being replaced by a guess.
+ */
+export function aliasParam(args, canonical, aliases) {
+    if (args[canonical] !== undefined)
+        return args;
+    for (const alias of aliases) {
+        if (args[alias] !== undefined)
+            return { ...args, [canonical]: args[alias] };
+    }
+    return args;
+}

package/dist/tools/assert-grade.js

@@ -10,18 +10,18 @@
  *
  * Pure: no IO, no clock.
  */
-import { isConsequenceKind, isPresenceKind } from '@reticlehq/core';
+import { isConsequenceKind, isPresenceKind, PredicateKind } from '@reticlehq/core';
 import { HonestyGrade } from '../honesty/honesty.js';
 export const PRESENCE_ONLY_ADVICE = 'This predicate only checks element/text presence, not an observable consequence. A locator healed to the wrong element (or a stale render) can satisfy it while the feature is broken. Prefer a { signal } or { net } assertion — or allOf it with one — so green means the feature actually worked.';
 function walk(predicate) {
-    if (predicate.kind === 'allOf' || predicate.kind === 'anyOf') {
+    if (PredicateKind.ALL_OF === predicate.kind || PredicateKind.ANY_OF === predicate.kind) {
         const subs = predicate.predicates.map(walk);
         return {
             consequence: subs.some((s) => s.consequence),
             presence: subs.some((s) => s.presence),
         };
     }
-    if (predicate.kind === 'not')
+    if (PredicateKind.NOT === predicate.kind)
         return walk(predicate.predicate);
     // Leaf: classify against the single source of truth in core. Kinds that are neither consequence
     // nor presence (route/console/settled/animation) correctly return false for both.
@@ -50,12 +50,12 @@ export const DERIVED_IPC_STATUS_ADVICE = 'This asserts on a status code Reticle
  * Recognised by the `ipc://` scheme, so a genuine HTTP status is never second-guessed.
  */
 export function assertsDerivedIpcStatus(predicate) {
-    if (predicate.kind === 'allOf' || predicate.kind === 'anyOf') {
+    if (PredicateKind.ALL_OF === predicate.kind || PredicateKind.ANY_OF === predicate.kind) {
         return predicate.predicates.some(assertsDerivedIpcStatus);
     }
-    if (predicate.kind === 'not')
+    if (PredicateKind.NOT === predicate.kind)
         return assertsDerivedIpcStatus(predicate.predicate);
-    if (predicate.kind !== 'net')
+    if (predicate.kind !== PredicateKind.NET)
         return false;
     return (predicate.status !== undefined &&
         predicate.ok === undefined &&
@@ -74,11 +74,11 @@ export function isPresenceOnlyAssertion(predicate) {
  */
 export function gradeOfPredicate(predicate) {
     switch (predicate.kind) {
-        case 'signal':
+        case PredicateKind.SIGNAL:
             return HonestyGrade.SIGNAL;
-        case 'net':
+        case PredicateKind.NET:
             return HonestyGrade.NET;
-        case 'state':
+        case PredicateKind.STATE:
             return HonestyGrade.STATE;
         default:
             return HonestyGrade.PRESENCE;

package/dist/tools/assert-verdict.d.ts

@@ -14,7 +14,15 @@ import { type Contradiction } from '../events/contradictions.js';
  * consult it. Asserting a moment earlier — while the POST was still open — is the same story with a
  * different name: `request-never-settled`, also unreported.
  */
-export declare function assertVerdict(session: Session, predicate: Predicate, pass: boolean, since: number): Promise<{
+export declare function assertVerdict(session: Session, predicate: Predicate, pass: boolean, since: number, 
+/** Set when the assertion was never evaluated — see honesty/verified.ts. */
+inconclusive?: string, 
+/**
+ * Set when the tab went away mid-wait, so the assertion was never OBSERVED. `reticle_assert` and
+ * `reticle_wait_for` reach the same disconnect path as the act tools, and a verdict that blames
+ * the app for a lost connection is no more honest on this route than on that one.
+ */
+observationLost?: boolean): Promise<{
     decision: Record<string, unknown>;
     contradictions: Contradiction[];
     coverage: Record<string, unknown>;

package/dist/tools/assert-verdict.js

@@ -1,5 +1,5 @@
 import { findContradictions } from '../events/contradictions.js';
-import { blindSpotsFromState, buildCoverageStatement, impeachesCapture, } from '../honesty/blind-spots.js';
+import { blindSpotsFromState, buildCoverageStatement, Coverage, impeachesCapture, transportGapNote, } from '../honesty/blind-spots.js';
 import { buildHonestyBlock } from '../honesty/honesty.js';
 import { hasAcceptedWrite } from '../honesty/accepted-write.js';
 import { hasUnreadWriteOutcome } from '../honesty/unread-outcome.js';
@@ -18,7 +18,15 @@ import { gradeOfPredicate } from './assert-grade.js';
  * consult it. Asserting a moment earlier — while the POST was still open — is the same story with a
  * different name: `request-never-settled`, also unreported.
  */
-export async function assertVerdict(session, predicate, pass, since) {
+export async function assertVerdict(session, predicate, pass, since, 
+/** Set when the assertion was never evaluated — see honesty/verified.ts. */
+inconclusive, 
+/**
+ * Set when the tab went away mid-wait, so the assertion was never OBSERVED. `reticle_assert` and
+ * `reticle_wait_for` reach the same disconnect path as the act tools, and a verdict that blames
+ * the app for a lost connection is no more honest on this route than on that one.
+ */
+observationLost) {
     // Scope caveat, stated because it is a real limitation and not a bug: blind spots are tracked per
     // SESSION, not per assertion window, so a cross-origin iframe seen once marks every later verdict
     // in that session partial — including ones about a region it cannot affect. That errs toward
@@ -28,9 +36,9 @@ export async function assertVerdict(session, predicate, pass, since) {
     const statement = buildCoverageStatement(spots);
     // Omitted entirely when coverage is full, so an intact page pays nothing and the field's PRESENCE
     // is the warning.
-    const coverage = statement.coverage === 'partial'
+    const coverage = Coverage.PARTIAL === statement.coverage
         ? {
-            coverage: statement.note ?? 'partial',
+            coverage: statement.note ?? Coverage.PARTIAL,
             coverage_spots: statement.spots.map((sp) => ({ kind: sp.kind, count: sp.count })),
         }
         : {};
@@ -44,15 +52,22 @@ export async function assertVerdict(session, predicate, pass, since) {
     // Only a spot that IMPEACHES the capture downgrades a verdict. A structural boundary (virtualized
     // rows, a cross-origin frame) is reported as coverage and must not impugn what WAS observed.
     const impeaching = buildCoverageStatement(spots.filter((sp) => impeachesCapture(sp.kind)));
+    // A gap in the WINDOW, as opposed to a standing limit of the page. Both mean the same thing to the
+    // rule — part of what happened was not seen — so both belong in `blindSpots`, which is the only
+    // input `decideVerified` reads for that.
+    const gap = transportGapNote(windowEvents);
+    const impeachingNotes = [impeaching.note, gap].filter((n) => n !== undefined);
     const outcomePending = hasAcceptedWrite(windowEvents);
     const outcomeUnread = hasUnreadWriteOutcome(windowEvents);
     const decision = decideVerified({
         pass,
+        ...(inconclusive === undefined ? {} : { inconclusive }),
+        ...(true === observationLost ? { observationLost: true } : {}),
         honesty: buildHonestyBlock({
             grade: gradeOfPredicate(predicate),
             attribution: 'window',
-            coveragePartial: statement.coverage === 'partial',
-            ...(impeaching.note === undefined ? {} : { blindSpots: [impeaching.note] }),
+            coveragePartial: Coverage.PARTIAL === statement.coverage,
+            ...(0 === impeachingNotes.length ? {} : { blindSpots: impeachingNotes }),
         }),
         contradictions,
         ...(outcomePending ? { outcomePending } : {}),