@reticlehq/server 2.12.0 → 2.13.1

package/dist/tools/act-tools.js

@@ -1,15 +1,11 @@
-import { normalizeQueryArgs } from './query-shape.js';
-import { resolveTargetRef } from './resolve-target.js';
-/**
- * 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 { aliasParam } from './alias-args.js';
-import { captureAct, compileSequenceStep } from '../flows/replay.js';
+import { resolveSessionWithin } from '../session/resolve-within.js';
+import { WALL_CLOCK } from '../session/wall-clock.js';
+import { ACT_SEQUENCE_TOOL } from './act-sequence-tool.js';
+import { timeoutMsSchema } from './numeric-bounds.js';
+import { captureAct } from '../flows/replay.js';
 import { ActionType, ActionWarning, CaptureLoss, DEFAULT_ASSERT_TIMEOUT_MS, InputMode, ReticleCommand, Verified, VerifiedReason, 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';
@@ -19,13 +15,14 @@ import { findContradictions } from '../events/contradictions.js';
 import { gapsForAction } from '../honesty/instrumentation-gaps.js';
 import { noteSessionGaps } from '../honesty/gap-ledger.js';
 import { isChangeUndeclared } from '../honesty/undeclared-change.js';
-import { openSessionIntents } from '../intent/open-intents.js';
+import { intentDebt, openSessionIntents } from '../intent/open-intents.js';
 import { dischargeInlineIntent, inlineVerdictId, linkInlineIntent, } from '../intent/inline-intent.js';
 import { declaresState } from '../events/predicate-asks.js';
 import { isStateUnwatched } from '../honesty/blind-spots.js';
 import { inFlightRequestLabels, repeatedRequestLabels, waitForInFlight, } from './settle-in-flight.js';
 import { waitForReaction } from './react-grace.js';
 import { decideVerified } from '../honesty/verified.js';
+import { honestyForVerdict } from '../honesty/honesty.js';
 import { declaredExpectations, declaresBodyIndependentChannel } from '../events/declared.js';
 import { readsDomState } from '../honesty/already-true.js';
 import { describeWaitTarget } from '../honesty/unsettled.js';
@@ -33,17 +30,19 @@ 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, transportGapNote, Coverage, impeachesCapture, } from '../honesty/blind-spots.js';
+import { absenceBlindSpotNote, buildCoverageStatement, blindSpotsFromState, transportGapNote, Coverage, impeachesCapture, } from '../honesty/blind-spots.js';
 import { hasAcceptedWrite } from '../honesty/accepted-write.js';
 import { unreadWriteLabels } from '../honesty/unread-outcome.js';
 import { evaluatePredicate, waitForPredicate, provenExpectedLinks, PredicateSchema, } from '../events/predicate.js';
-import { awaitDocumentSuccessor } from '../session/session-successor.js';
 import { healthEnvelope, refuseIfThrottled } from '../session/session-health.js';
 import { pausedShortCircuit, pausedOutputShape, withControl, PAUSED_NO_VERDICT, } from '../session/control-envelope.js';
 import { asString, asNumber, asRecord, sourceOf } from './tools-helpers.js';
+import { dispatchAct, preflightAct } from './act-preflight.js';
+import { followLostObservation } from './act-observation.js';
 import { intentArg, sessionIdShape } from './tool-kit.js';
 import { asActionType, gradeOf } from './act-helpers.js';
-import { tryRealInput, rewriteUploadArgs } from './real-input-attempt.js';
+import { resolveActTarget } from './act-target.js';
+import { tryRealInput, rewriteUploadArgs, HOVER_NEEDS_POINTER_MSG } from './real-input-attempt.js';
 /**
  * Single dispatch point for every ACT and ACT_SEQUENCE command.
  *
@@ -55,8 +54,25 @@ import { tryRealInput, rewriteUploadArgs } from './real-input-attempt.js';
  * the agent actually wrote) rather than the base64 blob — replay would otherwise send 750 KiB of
  * base64 to the browser as if it were an inline content call.
  */
-async function actCommand(deps, session, actArgs, timeoutMs) {
+export async function actCommand(deps, session, actArgs, timeoutMs) {
     const rewritten = await rewriteUploadArgs(deps, 'string' === typeof actArgs['action'] ? actArgs['action'] : '', asRecord(actArgs['args']));
+    // Sequence and act_and_wait dispatch through here without the ACT handler's tryRealInput.
+    // A synthetic hover reports dispatched/settled while CSS :hover never applies — drive a real
+    // pointer when one is available, otherwise refuse rather than lie.
+    if (ActionType.HOVER === actArgs['action']) {
+        const ref = asString(actArgs['ref']);
+        if (ref === undefined)
+            throw new Error(HOVER_NEEDS_POINTER_MSG);
+        const real = await tryRealInput(deps, session, ref, ActionType.HOVER, actArgs);
+        if (real.result === undefined)
+            throw new Error(HOVER_NEEDS_POINTER_MSG);
+        return {
+            kind: 'command_result',
+            id: 'hover',
+            ok: true,
+            result: { dispatched: true, settled: real.settled, ...asRecord(real.result) },
+        };
+    }
     const bridgeArgs = { ...actArgs, args: rewritten };
     return timeoutMs !== undefined
         ? session.command(ReticleCommand.ACT, bridgeArgs, timeoutMs)
@@ -82,41 +98,7 @@ async function actCommand(deps, session, actArgs, timeoutMs) {
  */
 const ACTION_TYPE_VALUES = Object.values(ActionType);
 const ACTION_TYPE_LIST = ACTION_TYPE_VALUES.join(' | ');
-const actionTypeEnum = z.enum(ACTION_TYPE_VALUES);
-/**
- * Resolve an action's element: an explicit `ref`, or a `target` query resolved in the SAME call.
- *
- * Requiring a ref meant every verification paid a `reticle_query` turn first just to learn one
- * string, and the advertised tool surface is re-sent on every turn — measured on the wire, a
- * two-turn verification spent 10,756 of 11,235 tokens on schema and 479 on the actual answers. The
- * lookup still happens; it just stops costing a round trip through the model.
- *
- * `ref` wins when both are given, because it is the more specific instruction and silently
- * preferring the query would act on something the caller did not name.
- */
-async function resolveActTarget(session, args) {
-    const ref = asString(args['ref']);
-    if (ref !== undefined && ref.length > 0)
-        return { kind: 'ref', ref };
-    const target = args['target'];
-    if (target === undefined) {
-        return {
-            kind: 'error',
-            message: 'pass `ref` (from reticle_query/reticle_snapshot) or `target` (e.g. { testid } or { role, name }).',
-        };
-    }
-    const q = normalizeQueryArgs(asRecord(target));
-    const out = await session.command(ReticleCommand.QUERY, {
-        by: q['by'],
-        value: q['value'],
-        name: q['name'],
-        scope: q['scope'],
-    });
-    if (!out.ok)
-        return { kind: 'error', message: out.error ?? 'target query failed' };
-    const elements = asRecord(out.result)['elements'];
-    return resolveTargetRef(Array.isArray(elements) ? elements : []);
-}
+export const actionTypeEnum = z.enum(ACTION_TYPE_VALUES);
 export const ACT_TOOLS = [
     {
         name: ReticleTool.ACT,
@@ -249,127 +231,6 @@ export const ACT_TOOLS = [
             }
         },
     },
-    {
-        name: ReticleTool.ACT_SEQUENCE,
-        // 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()))
-                .describe('Ordered list of { ref, action, args? } objects. Each step is equivalent to one reticle_act call; put confirmDangerous:true in a destructive step args object.'),
-            timeout_ms: z
-                .number()
-                .optional()
-                .describe('Per-step timeout in milliseconds. Default: 8000. Each step gets this budget independently.'),
-            ...sessionIdShape,
-        },
-        outputSchema: {
-            since: z.number(),
-            dispatched: z.boolean(),
-            completed: z.number(),
-            stalled_at: z.number().optional(),
-            steps: z.array(z.record(z.unknown())).optional(),
-            result: z.unknown().optional(),
-            session: z
-                .object({ lastSeenMs: z.number(), throttled: z.boolean(), focused: z.boolean() })
-                .optional(),
-            // Short-circuits to pausedShortCircuit while paused — declare its fields (drained-once guidance).
-            ...pausedOutputShape,
-        },
-        handler: async (deps, args) => {
-            const session = deps.sessions.resolve(asString(args['sessionId']));
-            const paused = pausedShortCircuit(session);
-            if (paused !== undefined)
-                return paused;
-            const since = session.elapsed();
-            session.beginAction(ReticleTool.ACT_SEQUENCE, asRecord(args));
-            try {
-                const inputSteps = Array.isArray(args['steps']) ? args['steps'] : [];
-                const perStepTimeout = 'number' === typeof args['timeout_ms'] ? args['timeout_ms'] : 8000;
-                const stepResults = [];
-                let stalledAt;
-                // DIVERGENCE: live sends N individual ACT commands (for per-step timeout + progress);
-                // replay sends one batched ACT_SEQUENCE command (flows/replay.ts:294). A bug in either is
-                // invisible from the other — cover both when changing sequence semantics.
-                for (let i = 0; i < inputSteps.length; i++) {
-                    const step = asRecord(inputSteps[i]);
-                    try {
-                        const result = await actCommand(deps, session, { ref: step['ref'], action: step['action'], args: step['args'] ?? {} }, perStepTimeout);
-                        if (!result.ok) {
-                            stalledAt = i;
-                            stepResults.push({
-                                ref: step['ref'],
-                                action: step['action'],
-                                dispatched: false,
-                                error: result.error ?? 'step failed',
-                            });
-                            break;
-                        }
-                        const r = asRecord(result.result);
-                        const stepResult = {
-                            ref: r['ref'] ?? step['ref'],
-                            action: r['action'] ?? step['action'],
-                            dispatched: r['dispatched'] ?? true,
-                            settled: r['settled'] ?? null,
-                            settleReason: r['settleReason'] ?? null,
-                        };
-                        if (r['testid'] !== undefined)
-                            stepResult['testid'] = r['testid'];
-                        if (r['component'] !== undefined)
-                            stepResult['component'] = r['component'];
-                        if (r['role'] !== undefined)
-                            stepResult['role'] = r['role'];
-                        if (r['name'] !== undefined)
-                            stepResult['name'] = r['name'];
-                        if (r['source'] !== undefined)
-                            stepResult['source'] = r['source'];
-                        if (r['warning'] !== undefined)
-                            stepResult['warning'] = r['warning'];
-                        stepResults.push(stepResult);
-                    }
-                    catch (err) {
-                        stalledAt = i;
-                        stepResults.push({
-                            ref: step['ref'],
-                            action: step['action'],
-                            dispatched: null,
-                            timedOut: true,
-                            error: err instanceof Error ? err.message : 'step timed out',
-                        });
-                        break;
-                    }
-                }
-                const completed = stalledAt ?? inputSteps.length;
-                if (completed > 0) {
-                    session.lastAct.markActed(since, undefined, undefined);
-                }
-                if (deps.recordings.active().length > 0 && stalledAt === undefined) {
-                    deps.recordings.capture(compileSequenceStep(args, { count: inputSteps.length, steps: stepResults }));
-                }
-                return withControl(session, {
-                    since,
-                    dispatched: completed > 0,
-                    completed,
-                    ...(stalledAt !== undefined ? { stalled_at: stalledAt } : {}),
-                    steps: stepResults,
-                    ...healthEnvelope(session),
-                });
-            }
-            finally {
-                session.finishAction();
-            }
-        },
-    },
     {
         name: ReticleTool.ACT_AND_WAIT,
         example: {
@@ -399,8 +260,7 @@ export const ACT_TOOLS = [
                 .describe('Action-specific arguments: { value } for fill/select, { text } for type/press (the key NAME, e.g. Escape or Tab), { modifiers: ["Meta","Shift"] } for a press shortcut (Meta/Control/Shift/Alt), { toRef } for drag (the ref to drop ON — without it the drag lands nowhere), { confirmDangerous: true } for a potentially destructive control. For upload: { path } is a path on disk (absolute or relative to project root; daemon reads real bytes) or { name, content?, type? } for inline bytes.'),
             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()
+            timeout_ms: timeoutMsSchema
                 .optional()
                 .describe('Maximum wait time in milliseconds. 0 = evaluate once without waiting. Default: 4000.'),
             refuseWhenThrottled: z
@@ -422,6 +282,10 @@ export const ACT_TOOLS = [
                     .boolean()
                     .optional()
                     .describe('The tab disconnected mid-wait, so this was never observed — the verdict is UNKNOWN, not a failure of the app.'),
+                inconclusive: z
+                    .string()
+                    .optional()
+                    .describe('The wait could not be graded as a product failure — e.g. the tab is throttled and may never have rendered. The verdict is UNKNOWN, not "the UI is absent".'),
                 // 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
@@ -482,7 +346,10 @@ export const ACT_TOOLS = [
             ...pausedOutputShape,
         },
         handler: async (deps, args) => {
-            let session = deps.sessions.resolve(asString(args['sessionId']));
+            // Spend the caller's budget waiting for the APP too, not only for the consequence. This tool
+            // is the one an agent reaches for straight after `init` and a dev-server restart, which is
+            // exactly when there is no session yet and one is seconds away. See resolve-within.
+            let session = await resolveSessionWithin(deps.sessions, asString(args['sessionId']), asNumber(args['timeout_ms']) ?? DEFAULT_ASSERT_TIMEOUT_MS, WALL_CLOCK);
             const acted = session;
             const actedSessionId = session.id;
             // Live-control: refuse to drive the page (no act, no predicate eval) while paused.
@@ -507,9 +374,8 @@ export const ACT_TOOLS = [
             // the undeclared-change gap silent on THIS verdict rather than the next one: it reads the
             // ledger below and finds something open. The discharge comes after that read.
             const intentId = await linkInlineIntent(deps, asString(args['sessionId']), asString(args['intent']), PredicateKind.SETTLED === until.kind ? undefined : until);
-            // 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']));
+            // Everything refusable without touching the page — see act-preflight.ts.
+            preflightAct(asRecord(args['args']), until);
             // Resolve `target` to a ref BEFORE the action window opens, so the lookup is not attributed to
             // the act and cannot be mistaken for something the action caused.
             const resolved = await resolveActTarget(session, args);
@@ -535,41 +401,47 @@ export const ACT_TOOLS = [
                 : false;
             try {
                 // actCommand is the single interception point for upload+path rewrite.
-                const actResult = await actCommand(deps, session, {
+                //
+                // A replacement can land BETWEEN resolving the target and dispatching, and the tool used to
+                // throw that transport fact at the agent verbatim: no verdict at all, from the layer whose
+                // whole job is to answer in verdicts, worded as though the app were at fault. `dispatchAct`
+                // returns null instead (see act-preflight.ts for why a write is never re-sent), and the
+                // successor block below then asks whether the consequence held on the NEW document — a
+                // green if it did, an honest observation_lost if it did not.
+                const actResult = await dispatchAct(() => actCommand(deps, session, {
                     ref: resolved.ref,
                     action: args['action'],
                     args: args['args'] ?? {},
-                });
-                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)), asString(args['ref']));
+                }));
+                if (actResult !== null) {
+                    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)), asString(args['ref']));
+                }
                 // Honesty: floor the predicate at this act's cursor so a stale buffered event can't satisfy it.
                 const predicateStarted = session.elapsed();
-                let verdict = timeout > 0
-                    ? await waitForPredicate(session, until, timeout, since)
-                    : await evaluatePredicate(session, until, since);
-                // A full-document navigation tears the SDK down mid-wait. `navigate` already waits for the
-                // HELLO and returns the new id; this path used to grade `observation_lost` and leave the
-                // agent holding a dead id, so the next assert failed even though the new page had loaded.
-                // Follow the unique same-origin successor (the awaitArrival idea, without a known URL) and
-                // evaluate there. Two live tabs at that origin is still a guess — we do not follow then.
-                if (true === verdict.observationLost && timeout > 0) {
-                    const remaining = timeout - (session.elapsed() - predicateStarted);
-                    const next = remaining > 0 ? await awaitDocumentSuccessor(deps.sessions, session, remaining) : null;
-                    if (next !== null) {
-                        // Compute leftover on the departed session before we point `session` at the successor —
-                        // the new session's elapsed() starts at 0 and would refund the whole budget.
-                        const leftover = timeout - (session.elapsed() - predicateStarted);
-                        session = next;
-                        since = 0;
-                        if (leftover > 0) {
-                            verdict = await waitForPredicate(session, until, leftover, since);
-                        }
-                    }
-                }
+                let verdict = null === actResult
+                    ? { pass: false, observationLost: true }
+                    : timeout > 0
+                        ? await waitForPredicate(session, until, timeout, since)
+                        : await evaluatePredicate(session, until, since);
+                // The SDK may have gone away mid-act — see act-observation.ts.
+                const followed = await followLostObservation({
+                    sessions: deps.sessions,
+                    session,
+                    verdict,
+                    timeout,
+                    predicateStarted,
+                    reevaluate: (next, budget) => waitForPredicate(next, until, budget, 0),
+                });
+                if (followed.followed)
+                    since = 0;
+                session = followed.session;
+                verdict = followed.verdict;
                 // The predicate resolves the INSTANT it holds, which on an optimistically-navigating app is
                 // while the write is still in flight — so the verdict was taken over a window the app had not
                 // finished, and came back `unknown / unsettled` asking the CALLER to re-check. A login that
@@ -599,7 +471,7 @@ export const ACT_TOOLS = [
                     // moved after it — and short enough that a genuinely dropped response is still reported.
                     await waitForReaction(session, since, spent(), sleep);
                 }
-                const r = asRecord(actResult.result);
+                const r = asRecord(actResult?.result);
                 if ('boolean' === typeof r['settled'])
                     settledOutcome = r['settled'];
                 // Where the acted element is written. Captured at act time alongside the anchor, so it is
@@ -626,8 +498,9 @@ export const ACT_TOOLS = [
                 // stronger than this block. Grade from the strongest asserted consequence; integrity from evictions.
                 // Coverage: cross-origin frames / other blind spots the SDK reported during this window mean the
                 // verdict didn't see everything — say so, never imply full coverage.
-                const spots = blindSpotsFromState(session.blindSpots());
+                const spots = blindSpotsFromState(session.blindSpots(), session.runtime);
                 const coverage = buildCoverageStatement(spots);
+                const absenceBlindSpot = absenceBlindSpotNote(until, spots);
                 // Nothing subscribed ⇒ the state channel is dark, and the summary must say so rather than
                 // report an empty diff list that reads like a fact about the app. See CausalSummary.
                 const stateUnwatched = isStateUnwatched(spots);
@@ -665,6 +538,7 @@ export const ACT_TOOLS = [
                     // evictions that happened outside the window they impeached.
                     truncated: bufferLost,
                     coveragePartial: Coverage.PARTIAL === coverage.coverage,
+                    ...(coverage.note === undefined ? {} : { coverageNote: coverage.note }),
                     // Settlement no longer vetoes a declared consequence that held, so the fact is carried
                     // here instead of only in the verdict it used to decide. Omitted when never measured.
                     ...(settledOutcome === undefined ? {} : { settled: settledOutcome }),
@@ -677,7 +551,11 @@ export const ACT_TOOLS = [
                     capsule,
                     links,
                     args,
-                    actResult,
+                    // The session actually driven — after any navigation follow — so the capsule is filed
+                    // against the codebase that produced the failure, not wherever the daemon stands.
+                    root: session.artifactRoot,
+                    // No dispatch result to capture when the transport was displaced mid-write.
+                    actResult: actResult ?? {},
                     ...(actedSource === undefined ? {} : { actedSource }),
                 });
                 // Pass the action: an EMPTY window then reads as "the target does not react" rather than as a
@@ -710,6 +588,7 @@ export const ACT_TOOLS = [
                     ...session.lastAct.effect(),
                     currentDocumentId: session.currentDocumentId,
                     currentEditEpoch: session.currentEditEpoch,
+                    appOrigin: session.url,
                 });
                 // The single field an agent reads. Everything below it is the evidence it was derived from;
                 // this is the only one that has to be interpreted, and now it interprets itself.
@@ -732,6 +611,7 @@ export const ACT_TOOLS = [
                     // 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 } : {}),
+                    ...(absenceBlindSpot === undefined ? {} : { absenceBlindSpot }),
                     honesty,
                     contradictions,
                     ...(outcomePending ? { outcomePending } : {}),
@@ -778,7 +658,7 @@ export const ACT_TOOLS = [
                     // "1 declared intent(s) are still unproved" while the ledger recorded it `proved`. A gap
                     // that fires on the one path doing everything right is noise, and noise is what gets
                     // filtered out — taking the honest gaps with it.
-                    openIntentCount: openIntents.filter((i) => !(intentId !== undefined && Verified.YES === decision.verified && i.id === intentId)).length,
+                    ...intentDebt(openIntents, intentId !== undefined && Verified.YES === decision.verified ? intentId : undefined, deps.now()),
                     domMutated: (session.lastAct.effect().mutatedWithin ?? 0) > 0,
                     signalsFired: actionSummary.signals.length,
                     routeChanged: actionSummary.route !== undefined,
@@ -794,7 +674,10 @@ export const ACT_TOOLS = [
                         verdictId: inlineVerdictId(ReticleTool.ACT_AND_WAIT, deps.now()),
                         grade,
                         at: deps.now(),
-                    });
+                    }, 
+                    // Where the acted element is written, so the record can name a file somebody would open
+                    // to change the thing it describes.
+                    actedSourceLabel);
                 }
                 verdictEffect = {
                     claim: describeWaitTarget(until),
@@ -807,7 +690,9 @@ export const ACT_TOOLS = [
                 noteSessionGaps(session, gaps);
                 return withControl(session, {
                     ...decision,
-                    effect: leanActResult(actResult.result),
+                    // An unobserved act has no effect to report, and inventing an empty one would read as
+                    // "the page did nothing" — a claim about the app, from a call that never saw it.
+                    ...(null === actResult ? {} : { effect: leanActResult(actResult.result) }),
                     verdict,
                     // Promoted out of `effect` on red only. On green nobody needs it and it is noise; on red it
                     // is the first thing the agent wants, and burying a file:line inside the effect block is
@@ -831,7 +716,7 @@ export const ACT_TOOLS = [
                     // agent cannot miss it by not asking. Omitted entirely when clean, so a healthy action
                     // pays nothing.
                     ...(contradictions.length > 0 ? { contradictions } : {}),
-                    honesty,
+                    honesty: honestyForVerdict(String(decision.verified), honesty),
                     ...(capsule === undefined ? {} : { capsule }),
                     since,
                     ...(session.id === actedSessionId ? {} : { sessionId: session.id }),
@@ -843,4 +728,6 @@ export const ACT_TOOLS = [
             }
         },
     },
+    // Split into its own module for size; still shipped as one of the acting tools.
+    ACT_SEQUENCE_TOOL,
 ];

package/dist/tools/assert-verdict.js

@@ -1,11 +1,11 @@
-import { BlindSpotKind, CaptureLoss, PredicateKind } from '@reticlehq/core';
+import { CaptureLoss, PredicateKind } from '@reticlehq/core';
 import { gapsForAction } from '../honesty/instrumentation-gaps.js';
 import { noteSessionGaps } from '../honesty/gap-ledger.js';
 import { declaresState } from '../events/predicate-asks.js';
 import { isStateUnwatched } from '../honesty/blind-spots.js';
 import { findContradictions } from '../events/contradictions.js';
 import { declaredExpectations, declaresBodyIndependentChannel } from '../events/declared.js';
-import { blindSpotsFromState, buildCoverageStatement, Coverage, impeachesCapture, transportGapNote, } from '../honesty/blind-spots.js';
+import { absenceBlindSpotNote, blindSpotsFromState, buildCoverageStatement, restsOnCompleteWindow, Coverage, impeachesCapture, transportGapNote, } from '../honesty/blind-spots.js';
 import { buildHonestyBlock } from '../honesty/honesty.js';
 import { hasAcceptedWrite } from '../honesty/accepted-write.js';
 import { unreadWriteLabels } from '../honesty/unread-outcome.js';
@@ -14,17 +14,6 @@ import { describeWaitTarget } from '../honesty/unsettled.js';
 import { inFlightRequestLabels, repeatedRequestLabels } from './settle-in-flight.js';
 import { gradeOfPredicate } from './assert-grade.js';
 import { assertSource } from './assert-source.js';
-function absenceBlindSpotNote(predicate, spots) {
-    if (predicate.kind !== 'element' || predicate.absent !== true)
-        return undefined;
-    const relevant = spots.filter((spot) => spot.count > 0 &&
-        spot.kind === BlindSpotKind.CROSS_ORIGIN_IFRAME &&
-        undefined !== predicate.query.scope);
-    if (0 === relevant.length)
-        return undefined;
-    const statement = buildCoverageStatement(relevant);
-    return `the absence assertion targeted a region Reticle could not observe (${statement.note ?? 'partial coverage'}), so a passing DOM check cannot prove absence`;
-}
 /**
  * The honesty verdict for a plain `reticle_assert`.
  *
@@ -63,7 +52,7 @@ changeUndeclared) {
     // in that session partial — including ones about a region it cannot affect. That errs toward
     // over-warning, which is the correct direction here: the failure this guards against is a green
     // that implies coverage it never had, and a needless caveat costs the agent a sentence.
-    const spots = blindSpotsFromState(session.blindSpots());
+    const spots = blindSpotsFromState(session.blindSpots(), session.runtime);
     const statement = buildCoverageStatement(spots);
     const absenceBlindSpot = absenceBlindSpotNote(predicate, spots);
     // Omitted entirely when coverage is full, so an intact page pays nothing and the field's PRESENCE
@@ -94,6 +83,7 @@ changeUndeclared) {
         prior,
         currentDocumentId: session.currentDocumentId,
         currentEditEpoch: session.currentEditEpoch,
+        appOrigin: session.url,
         expectedFailures: declared.netFailures,
         renderProved: pass && declared.rendersContent,
         ...(actCursor !== undefined && actCursor >= since ? { actionSince: actCursor } : {}),
@@ -121,11 +111,27 @@ changeUndeclared) {
         honesty: buildHonestyBlock({
             grade: gradeOfPredicate(predicate),
             attribution: 'window',
+            // Did the buffer evict SCARCE evidence belonging to this window, AND does a green here rest on
+            // the window being complete. assert never consulted the buffer at all, on the reasoning that it
+            // "observes an already-open window" — but eviction happens on push regardless of who opened the
+            // window, so `{ console, absent: true }` returned `yes` over a window whose evidence was gone,
+            // which is absence of evidence read as evidence of absence.
+            //
+            // The second half of the condition is not a refinement, it is what keeps this usable. Scarce
+            // loss is recorded for AGE eviction too, so `lostSince(0)` is true on any session past the 60s
+            // cutoff, and assert takes a caller-chosen `since` that is often 0. Impeaching every verdict
+            // over a wide window would make `unknown` the answer to everything — the failure this repo has
+            // already paid for once, when `unclean_capture` became the dominant cause of `unknown` in the
+            // field. The act path needs no such guard: its cursor is the action's own.
+            truncated: session.lostSince(since) && restsOnCompleteWindow(predicate),
             coveragePartial: Coverage.PARTIAL === statement.coverage,
+            ...(statement.note === undefined ? {} : { coverageNote: statement.note }),
             ...(0 === impeachingNotes.length ? {} : { blindSpots: impeachingNotes }),
-            // Which loss, as an enum, beside the prose. `assert` observes an already-open window and never
-            // consults the ring buffer's health, so `buffer_loss` is not one of its answers.
+            // Which loss, as an enum, beside the prose.
             losses: [
+                ...(session.lostSince(since) && restsOnCompleteWindow(predicate)
+                    ? [CaptureLoss.BUFFER_LOSS]
+                    : []),
                 ...(gap === undefined ? [] : [CaptureLoss.TRANSPORT_GAP]),
                 ...(impeaching.note === undefined ? [] : [CaptureLoss.BLIND_SPOT]),
             ],

package/dist/tools/browser-tools.js

@@ -1,3 +1,4 @@
+import { carryReticleIdentity } from './lease-tools.js';
 import { z } from 'zod';
 import { navigateResult } from './navigate-result.js';
 import { awaitArrival } from './navigate-arrival.js';
@@ -64,12 +65,15 @@ export const BROWSER_TOOLS = [
                 // likely to need it. See reload-result.
                 return reloadResult(back);
             }
-            const url = asString(args['url']);
-            if (url === undefined || 0 === url.length)
+            const requested = asString(args['url']);
+            if (requested === undefined || 0 === requested.length)
                 return { ok: false, reason: 'url required' };
             // Record navigate as an action. Its window is usually empty (the page unloads and the SDK
             // reconnects), but the action record itself — "navigated to X" — is the causal fact worth keeping.
             const session = deps.sessions.resolve(asString(args['sessionId']));
+            // A leased tab is addressed by a URL param, so navigating away from it used to strand the
+            // lease — see carryReticleIdentity. A tab that claims no identity is untouched.
+            const url = carryReticleIdentity(session.url, requested);
             session.beginAction(ReticleTool.NAVIGATE, { url });
             // Same floor as the reload path above, for the same reason: going to a new URL replaces the
             // document just as thoroughly. `beginAction` attributes events to this action; it does not move