@reticlehq/server 3.8.2 → 3.10.0

package/dist/features/visual/visual-tools.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { AppRuntime, ReticleCommand, RETICLE_CAPTURE_FILE_PREFIX, VISUAL_NO_PROVIDER_RECOMMENDATION, RETICLE_TAURI_INERT_MARKER, TAURI_INERT_RECOMMENDATION, VisualReason, } from '@reticlehq/core';
+import { AppRuntime, ReticleCommand, VISUAL_NO_PROVIDER_RECOMMENDATION, VisualReason, realmOf, } from '@reticlehq/core';
 import { ReticleTool } from '@reticlehq/core';
 import { sessionIdShape } from '../../surface/tools/tool-kit.js';
 import { ratioSchema } from '../../surface/tools/args/numeric-bounds.js';
@@ -21,10 +21,7 @@ function captureRoot(deps, sessionId) {
         return deps.reticleRoot;
     }
 }
-import { trackCaptureDirectory } from './capture-cleanup.js';
-import { readFile, unlink } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { basename, dirname } from 'node:path';
+import { desktopCapture } from './desktop-capture.js';
 const rectShape = z.object({
     x: z.number(),
     y: z.number(),
@@ -37,6 +34,38 @@ function screenshotProvider(deps) {
         ? p
         : undefined;
 }
+/**
+ * Whether this call can photograph the session: a lease of this caller, a desktop shell, or a page
+ * that the driven browser has.
+ *
+ * A desktop shell counts before its capture is known to work. Only a CAPTURE command can tell, and
+ * a person who connected a desktop app most likely wants that window, not a lease beside it.
+ */
+async function canCapture(deps, session) {
+    // A lease of this caller. Another agent's lease is never this caller's to photograph (#1226).
+    if (true === deps.pool?.heldBy(session.id, deps.attachId)) {
+        return true;
+    }
+    if (realmOf(session.runtime).isDesktopShell) {
+        return true;
+    }
+    // A driven browser photographs only a page it has. Having a driven browser is not enough.
+    const driven = screenshotProvider(deps);
+    if (driven === undefined) {
+        return false;
+    }
+    return driven.isAvailableFor(session.url);
+}
+/**
+ * The one session this call photographs, chosen once (#1959).
+ *
+ * capture() and captureRoot() each resolve the id again. With no id, each could choose another
+ * session, and capture() never tried a lease at all. After this, they all get the same, named id.
+ */
+async function captureTarget(deps, args) {
+    const session = await deps.sessions.resolveServing(asString(args['sessionId']), (s) => canCapture(deps, s));
+    return session.id;
+}
 /** The "you need a driven browser" envelope, shared by both visual tools. */
 const noProvider = {
     ok: false,
@@ -45,8 +74,9 @@ const noProvider = {
 };
 /** The answer when no pixels came back: the shell's own recommendation over the web one. */
 function unavailable(reason, recommendation) {
-    if (recommendation !== undefined)
+    if (recommendation !== undefined) {
         return { ok: false, reason, recommendation };
+    }
     return reason === VisualReason.NO_PROVIDER ? noProvider : { ok: false, reason };
 }
 function asBox(value) {
@@ -55,10 +85,12 @@ function asBox(value) {
     const y = asNumber(b['y']);
     const w = asNumber(b['width']);
     const h = asNumber(b['height']);
-    if (x === undefined || y === undefined || w === undefined || h === undefined)
+    if (x === undefined || y === undefined || w === undefined || h === undefined) {
         return undefined;
-    if (w <= 0 || h <= 0)
+    }
+    if (w <= 0 || h <= 0) {
         return undefined;
+    }
     return { x, y, width: w, height: h };
 }
 /** Build capture options from args: explicit clip > ref (resolved via INSPECT) > fullPage. */
@@ -67,59 +99,21 @@ async function buildOpts(deps, sessionId, args) {
     if (clipArg !== undefined) {
         const c = asRecord(clipArg);
         const box = asBox({ box: c });
-        if (box !== undefined)
+        if (box !== undefined) {
             return { clip: box };
+        }
     }
     const ref = asString(args['ref']);
     if (ref !== undefined) {
         const session = deps.sessions.resolve(sessionId);
         const res = await session.command(ReticleCommand.INSPECT, { ref });
         const box = res.ok ? asBox(res.result) : undefined;
-        if (box !== undefined)
+        if (box !== undefined) {
             return { clip: box };
+        }
     }
     return true === args['fullPage'] ? { fullPage: true } : {};
 }
-/**
- * Ask the desktop shell to photograph its own window.
- *
- * Returns undefined for a plain web page (no capture helper) and for a desktop app that did not
- * install `@reticlehq/electron/main`. Deliberately NOT a screen-region capture: photographing
- * the glass returns whatever window is on top, which would save a picture of the user's editor as a
- * visual baseline — the exact false green Reticle exists to eliminate.
- */
-async function desktopCapture(deps, sessionId, fullPage) {
-    const session = deps.sessions.resolve(sessionId);
-    // A session that cannot take commands (no live browser behind it) simply has no pixels to give.
-    if (typeof session.command !== 'function')
-        return {};
-    const res = await session.command(ReticleCommand.CAPTURE, { fullPage });
-    if (!res.ok)
-        return {};
-    const r = asRecord(res.result);
-    if (r['ok'] !== true) {
-        // The shell refused a full-page capture it cannot do. That is a different answer from "capture
-        // broke", and the caller has to hear it — otherwise they read `fullPage` as honoured.
-        if (r['reason'] === VisualReason.FULL_PAGE_UNSUPPORTED)
-            return { reason: VisualReason.FULL_PAGE_UNSUPPORTED };
-        // A Tauri release build with the capture compiled out: say that, never the web answer.
-        return true === asString(r['reason'])?.includes(RETICLE_TAURI_INERT_MARKER)
-            ? { reason: VisualReason.NO_PROVIDER, recommendation: TAURI_INERT_RECOMMENDATION }
-            : {};
-    }
-    const path = asString(r['path']);
-    if (path === undefined || !isCapturePath(path))
-        return {};
-    try {
-        const bytes = await readFile(path);
-        await unlink(path).catch(() => undefined);
-        trackCaptureDirectory(path);
-        return isCompletePng(bytes) ? { png: new Uint8Array(bytes) } : {};
-    }
-    catch {
-        return {};
-    }
-}
 /**
  * One picture of the tab a chat-requested drive is driving, or undefined when there is none to take.
  *
@@ -131,14 +125,16 @@ async function desktopCapture(deps, sessionId, fullPage) {
 export async function driveFrame(deps, sessionId, jpegQuality) {
     try {
         const leased = await deps.pool?.screenshotLease(sessionId, { jpegQuality });
-        if (leased !== undefined)
+        if (leased !== undefined) {
             return leased;
+        }
         // The window `reticle drive` opened: neither a lease nor a desktop shell, but its page is ours.
         const url = deps.sessions.resolve(sessionId).url;
         if (true === (await deps.realInput?.isAvailableFor(url))) {
             const shot = await deps.realInput?.screenshot?.(url, { jpegQuality });
-            if (shot !== undefined)
+            if (shot !== undefined) {
                 return shot;
+            }
         }
         return (await desktopCapture(deps, sessionId, false)).png;
     }
@@ -146,42 +142,6 @@ export async function driveFrame(deps, sessionId, jpegQuality) {
         return undefined;
     }
 }
-/**
- * Only read a capture the shell wrote. The path arrives from the PAGE, and the daemon must not
- * become a file-read oracle for whatever a compromised renderer names.
- *
- * Two layouts are accepted, and the pair is the whole subtlety:
- *
- * - `<tmp>/<prefix><dir>/<prefix><n>.png` — the shell's own PRIVATE capture directory, created 0700
- *   so no other local user can read the screenshot or pre-place a symlink at the path we write.
- * - `<tmp>/<prefix><pid>-<n>.png` — the legacy flat layout. Kept because the shell ships as a
- *   SEPARATE package on the user's own upgrade schedule: an app still on the older
- *   `@reticlehq/electron` talking to a newer daemon must keep getting screenshots, not silently
- *   start returning no image. It grants the daemon nothing it did not already have.
- *
- * Every comparison is an exact match against an UNRESOLVED path, which is what refuses traversal:
- * `<tmp>/<prefix>x/../../etc/<prefix>passwd.png` has a grandparent of `<tmp>/<prefix>x/..`, not
- * `<tmp>`. Exactly one directory level is allowed, so a deeper nesting is refused too.
- */
-export function isCapturePath(path) {
-    if (!basename(path).startsWith(RETICLE_CAPTURE_FILE_PREFIX))
-        return false;
-    const parent = dirname(path);
-    if (parent === tmpdir())
-        return true;
-    return dirname(parent) === tmpdir() && basename(parent).startsWith(RETICLE_CAPTURE_FILE_PREFIX);
-}
-/**
- * A PNG is complete only if it ends with IEND. This check exists because a truncated image once
- * sailed through as a saved baseline: the tool answered `saved: true` with a path, and the file was
- * undecodable. A screenshot that cannot be read must fail loudly, never bank a corrupt baseline that
- * a later visual_diff will compare against.
- */
-function isCompletePng(bytes) {
-    if (bytes.byteLength < 12)
-        return false;
-    return 'IEND' === bytes.subarray(bytes.byteLength - 8, bytes.byteLength - 4).toString('ascii');
-}
 /**
  * Which runtime this session is, for scoping a visual artifact.
  *
@@ -232,8 +192,9 @@ async function capture(deps, sessionId, args) {
         // A driven browser renders the session's URL in a BROWSER — so the pixels are web even when the
         // session named is a desktop window. Scoping those under the desktop runtime would corrupt that
         // runtime's baseline with a picture of a different renderer.
-        if (png !== undefined)
+        if (png !== undefined) {
             return { png, runtime: AppRuntime.WEB };
+        }
     }
     // The window's own backing store, via the Electron/Tauri adapter — the only route whose pixels
     // really are the desktop app.
@@ -246,8 +207,9 @@ async function capture(deps, sessionId, args) {
         }
         return { png: desktop.png, runtime: runtimeOf(deps, sessionId) };
     }
-    if (desktop.reason !== undefined)
+    if (desktop.reason !== undefined) {
         return desktop;
+    }
     /*
      * A LEASED page is a real browser page, so the pixels were always there — the visual tools simply
      * had no route to them. Without this, `reticle_screenshot` answered "no provider" for every context
@@ -261,20 +223,23 @@ async function capture(deps, sessionId, args) {
             // shot of a lease saved the whole viewport and answered `saved: true`.
             await deps.pool?.screenshotLease(sessionId, await buildOpts(deps, sessionId, args));
     // A leased page is a real browser page, whatever the session is.
-    if (leased !== undefined)
+    if (leased !== undefined) {
         return { png: leased, runtime: AppRuntime.WEB };
+    }
     return {
         reason: provider === undefined ? VisualReason.NO_PROVIDER : VisualReason.CAPTURE_FAILED,
     };
 }
 function rectsFrom(value) {
-    if (!Array.isArray(value))
+    if (!Array.isArray(value)) {
         return undefined;
+    }
     const rects = [];
     for (const r of value) {
         const box = asBox({ box: r });
-        if (box !== undefined)
+        if (box !== undefined) {
             rects.push(box);
+        }
     }
     return rects.length > 0 ? rects : undefined;
 }
@@ -316,10 +281,11 @@ export const VISUAL_TOOLS = [
             recommendation: z.string().optional(),
         },
         handler: async (deps, args) => {
-            const sessionId = asString(args['sessionId']);
+            const sessionId = await captureTarget(deps, args);
             const { png, reason, recommendation, runtime } = await capture(deps, sessionId, args);
-            if (png === undefined)
+            if (png === undefined) {
                 return unavailable(reason, recommendation);
+            }
             const name = asString(args['name']) ?? 'default';
             // Beside the app that was captured. The tool RETURNS this path to the agent, so a wrong root
             // is not only a stray PNG — it is a path the agent is told to look at in a tree that has
@@ -369,22 +335,24 @@ export const VISUAL_TOOLS = [
         },
         handler: async (deps, args) => {
             const baseline = asString(args['baseline']) ?? '';
-            const store = new VisualStore(deps.fs, captureRoot(deps, asString(args['sessionId'])));
+            const sessionId = await captureTarget(deps, args);
+            const store = new VisualStore(deps.fs, captureRoot(deps, sessionId));
             // Capture FIRST, then fetch the baseline for the runtime that produced these pixels. Reading it
             // by the session's runtime looked equivalent and is not: the route decides the renderer, so a
             // desktop session captured through a driven browser must be compared against the WEB baseline,
             // not the desktop one. Comparing across renderers is a confident wrong diff in one direction
             // and a silently overwritten baseline in the other.
-            const sessionId = asString(args['sessionId']);
             const captured = await capture(deps, sessionId, args);
             const { png: current, runtime } = captured;
-            if (current === undefined)
+            if (current === undefined) {
                 return unavailable(captured.reason, captured.recommendation);
+            }
             // A baseline from another runtime is not missing by accident — it is a different rendering, and
             // "no baseline for this one" is the honest answer.
             const baselineBytes = await store.readBaseline(baseline, runtime);
-            if (baselineBytes === undefined)
+            if (baselineBytes === undefined) {
                 return { ok: false, reason: VisualReason.BASELINE_MISSING };
+            }
             const masks = rectsFrom(args['masks']);
             const threshold = asNumber(args['threshold']);
             const maxRatio = asNumber(args['maxRatio']);

package/dist/import-graph.js

@@ -75,12 +75,11 @@ export function importsOf(sourceRoot, file) {
 export function reachableFrom(sourceRoot, entry) {
     /*
      * The entry is normalised the same way `resolveImport` normalises everything this walker
-     * DISCOVERS, because callers build it with `join()` and on Windows that yields `features\ee\x.ts`
-     * while every other key in the map is `features/ee/x.ts`. A caller then filters the result with
-     * `startsWith('features/ee/')` and the seed — the one path it did not walk to — silently drops
-     * out. That is how `ee-boundary`, the guard that says the free build cannot reach the
-     * separately-licensed code, passed on Windows while checking nothing at all: both of its real
-     * assertions expect an EMPTY list, so a walker that finds nothing agrees with them. Only its
+     * DISCOVERS, because callers build it with `join()` and on Windows that yields `features\x\y.ts`
+     * while every other key in the map is `features/x/y.ts`. A caller then filters the result with
+     * `startsWith('features/x/')` and the seed — the one path it did not walk to — silently drops
+     * out. That is how a boundary guard passed on Windows while checking nothing at all: its real
+     * assertions expected an EMPTY list, so a walker that finds nothing agrees with them. Only its
      * negative control could see it, and that is the whole reason the negative control exists.
      *
      * Both separators, not `sep`: on a POSIX machine `sep` is `/`, so splitting on it leaves a

package/dist/index.d.ts

@@ -102,8 +102,10 @@ export { registerContradictionFold, registeredContradictionFolds, } from '@retic
 export type { ContradictionFold } from '@reticlehq/engine/disagreement/contradiction-folds.js';
 export { MCP_SSE_PATH, MCP_MESSAGE_PATH } from '@reticlehq/core';
 export { BrowserPool, DEFAULT_LEASE_TTL_MS } from './portal/pool/browser-pool.js';
-export type { Lease, Launcher, PooledBrowser } from './portal/pool/browser-pool.js';
+export type { Lease, Launcher, PooledBrowser, PooledPageError, } from './portal/pool/browser-pool.js';
 export { playwrightLauncher, resolveMaxContexts } from './portal/pool/playwright-launcher.js';
+export { makePageErrorJournal, uncaughtIdentity } from './portal/pool/page-error-journal.js';
+export type { JournalableSession, PageErrorJournal } from './portal/pool/page-error-journal.js';
 export { appendReticleParams } from './surface/tools/lease-tools.js';
 export { writePid, removePid, isRunning, logPath, readPid, isAlive, } from './command/daemon/daemon.js';
 export { classifyDaemonLife, DaemonEnd, DAEMON_HEARTBEAT_EVENT, DAEMON_HEARTBEAT_MS, type DaemonLife, } from './command/daemon/lifetime/heartbeat.js';

package/dist/index.js

@@ -54,11 +54,12 @@ import { AGENT_ALREADY_DRIVING_ELSEWHERE, shouldGreetWithLeaseNotice, } from './
 import { LeaseReaper } from './portal/pool/lease-reaper.js';
 import { findProjectConfig, readJournalEnabled, readProjectId, } from './command/cli/ports/resolve/cli-port.js';
 import { probeLaunchableChromium } from './launch-chromium.js';
+import { portAcceptsConnection } from './portal/session/dev-server/dev-server-probe.js';
 import { attachJournal } from './wire-journal.js';
 import { reportOnboardingStep } from './telemetry/onboarding-funnel.js';
 import { readRetainPolicy } from './memory/journal/on-disk/retain-policy.js';
 import { log } from './log.js';
-import { createBrowserPool, knownProjectRoots, loadHarnessConfig, makeNetworkDetailRouter, platformEnvFor, readerConnect, resolveRealInput, sdkFixForProject, } from './start-wiring.js';
+import { attachPageErrorJournal, createBrowserPool, knownProjectRoots, loadHarnessConfig, makeNetworkDetailRouter, platformEnvFor, readerConnect, resolveRealInput, sdkFixForProject, } from './start-wiring.js';
 export { replayVerdictLine } from './language/flows/replay-from-hud.js';
 // Re-exported from the contract, where the names now live: a consumer importing the server should
 // not have to know that the vocabulary moved.
@@ -149,14 +150,18 @@ export async function start(options = {}) {
     // Then to the agent's own git worktree: every worktree declares the same projectId.
     bridge.sessions.setCheckoutScope(liveCheckoutSource());
     const baselines = new BaselineStore();
-    const recordings = new RecordingStore(() => currentDrivenBy() !== undefined);
+    const recordings = new RecordingStore(() => currentDrivenBy() !== undefined, (session) => bridge.sessions.successorId(session));
     // drive precedence: driveUrl (launch+own a browser) → CDP (attach) → none.
     let pool;
     let leaseReaper;
     // Route CDP-authoritative network detail (drive path only) onto the driven session's journal: the
     // page and the SDK session share an origin, so a NET_DETAIL is pushed to the matching connected session.
     const routeNetworkDetail = makeNetworkDetailRouter(bridge, options.driveUrl);
-    const { realInput, owned } = await resolveRealInput(options, () => bridge.close(), routeNetworkDetail);
+    // Journal the uncaught page errors the pool hears — an import-time throw lands before any SDK
+    // exists to see it, and it was previously invisible to the agent (#1966). The bridge hook is
+    // registered here; the pool gets the sink at its creation below.
+    const pageErrorJournal = attachPageErrorJournal(bridge);
+    const { realInput, owned } = await resolveRealInput(options, () => bridge.close(), routeNetworkDetail, readerConnect(port, security.token));
     let chatDrives;
     if (options.mcp !== false) {
         // cwd/Date.now are confined to start — never inside reticle-dir.ts's pure logic (rule 7).
@@ -184,7 +189,7 @@ export async function start(options = {}) {
         const project = new ProjectStore(fs, reticleRoot, { now });
         attachRouteLearning(bridge, projectStoreResolver(fs, project, reticleRoot, now));
         const annotations = new AnnotationStore();
-        pool = createBrowserPool(options.headless ?? true, readerConnect(port, security.token));
+        pool = createBrowserPool(options.headless ?? true, readerConnect(port, security.token), (leaseId, error) => pageErrorJournal.onPoolPageError(leaseId, error), (leaseId) => pageErrorJournal.onLeaseClosed(leaseId), bridge.nonces, (leaseId, dialog) => pageErrorJournal.onPoolDialog(leaseId, dialog));
         leaseReaper = new LeaseReaper(pool);
         leaseReaper.start();
         /*
@@ -223,6 +228,7 @@ export async function start(options = {}) {
             bridgePort: port,
             nonces: bridge.nonces,
             browserProbe: probeLaunchableChromium,
+            portAccepts: portAcceptsConnection,
             // The daemon's OWN project, so a tool can tell "this session is mine" from "this session
             // belongs to a sibling app under the same daemon". contract_save refuses on the second.
             ...(activeProjectId === undefined ? {} : { projectId: activeProjectId }),
@@ -346,7 +352,11 @@ export async function startDaemon(options = {}) {
     }, AGENT_DETACH_GRACE_MS));
     const reaper = new SessionReaper(bridge.sessions);
     reaper.start();
-    const { realInput, owned } = await resolveRealInput(options, () => shared.close(), makeNetworkDetailRouter(bridge, options.driveUrl));
+    // Same page-error journal the `start` path wires: an import-time crash reaches the agent through
+    // it instead of reading as a blank page (#1966). Kept beside the other shared wiring so the two
+    // entry points cannot drift.
+    const pageErrorJournal = attachPageErrorJournal(bridge);
+    const { realInput, owned } = await resolveRealInput(options, () => shared.close(), makeNetworkDetailRouter(bridge, options.driveUrl), readerConnect(port, security.token));
     const fs = createNodeFileSystem();
     const reticleRoot = options.reticleRoot ?? join(process.cwd(), ReticleDir.ROOT);
     const now = options.now ?? (() => Date.now());
@@ -357,7 +367,7 @@ export async function startDaemon(options = {}) {
     const flows = new FlowStore(fs, reticleRoot, { now }, { onWrote: () => syncNudge.run?.() });
     // Built here rather than inside `deps` below, so teardown can save what a drive recorded. Both
     // paths pass the same pair — `daemon-parity.test.ts` is what keeps them from drifting apart.
-    const recordings = new RecordingStore(() => currentDrivenBy() !== undefined);
+    const recordings = new RecordingStore(() => currentDrivenBy() !== undefined, (session) => bridge.sessions.successorId(session));
     /*
      * Bound AFTER the sync daemon exists, read only when a run is actually written.
      *
@@ -380,7 +390,7 @@ export async function startDaemon(options = {}) {
     const project = new ProjectStore(fs, reticleRoot, { now });
     attachRouteLearning(bridge, projectStoreResolver(fs, project, reticleRoot, now));
     const annotations = new AnnotationStore();
-    const pool = createBrowserPool(options.headless ?? true, readerConnect(port, security.token));
+    const pool = createBrowserPool(options.headless ?? true, readerConnect(port, security.token), (leaseId, error) => pageErrorJournal.onPoolPageError(leaseId, error), (leaseId) => pageErrorJournal.onLeaseClosed(leaseId), bridge.nonces, (leaseId, dialog) => pageErrorJournal.onPoolDialog(leaseId, dialog));
     const leaseReaper = new LeaseReaper(pool);
     leaseReaper.start();
     /*
@@ -453,6 +463,7 @@ export async function startDaemon(options = {}) {
         bridgePort: port,
         nonces: bridge.nonces,
         browserProbe: probeLaunchableChromium,
+        portAccepts: portAcceptsConnection,
         ...agentWiring(bridge.sessions, leaseUrl),
         // A finished verification should not sit behind a one-minute timer — see ToolDeps.onRunPersisted.
         onRunPersisted: () => cloudSync.nudge(),
@@ -587,6 +598,7 @@ export { registerContradictionFold, registeredContradictionFolds, } from '@retic
 export { MCP_SSE_PATH, MCP_MESSAGE_PATH } from '@reticlehq/core';
 export { BrowserPool, DEFAULT_LEASE_TTL_MS } from './portal/pool/browser-pool.js';
 export { playwrightLauncher, resolveMaxContexts } from './portal/pool/playwright-launcher.js';
+export { makePageErrorJournal, uncaughtIdentity } from './portal/pool/page-error-journal.js';
 export { appendReticleParams } from './surface/tools/lease-tools.js';
 export { writePid, removePid, isRunning, logPath, readPid, isAlive, } from './command/daemon/daemon.js';
 // The daemon's own liveness vocabulary, exported so a GATE can read a daemon log back and say how

package/dist/judgement/capsule/causal-summary.js

@@ -94,6 +94,8 @@ export function causalSummary(events, context = {}) {
     const signals = [];
     const fieldsChanged = [];
     let layoutShift;
+    // The shift inside this window, summed from each entry's own `shift` (#1784).
+    let windowShift;
     let longTasks = 0;
     let ignoredBookkeeping = 0;
     for (const event of events) {
@@ -166,7 +168,11 @@ export function causalSummary(events, context = {}) {
                 pushUnique(fieldsChanged, data['field']);
                 break;
             case EventType.PERF:
-                if (data['metric'] === PerfMetric.CLS && 'number' === typeof data['value']) {
+                if (data['metric'] === PerfMetric.CLS && 'number' === typeof data['shift']) {
+                    windowShift = (windowShift ?? 0) + data['shift'];
+                }
+                else if (data['metric'] === PerfMetric.CLS && 'number' === typeof data['value']) {
+                    // An SDK older than #1784 sends only the running total: the most it allows is its max.
                     layoutShift = Math.max(layoutShift ?? 0, data['value']);
                 }
                 else if (data['metric'] === PerfMetric.LONGTASK) {
@@ -182,6 +188,7 @@ export function causalSummary(events, context = {}) {
     // store, and shrinking it because the evidence was trimmed would make the transient window read as
     // narrower than it was — the one number here that must survive the trim intact.
     const settle = stateSettle(stateDiffs);
+    const shiftInWindow = windowShift ?? layoutShift;
     return {
         net: {
             total: netTotal,
@@ -204,7 +211,7 @@ export function causalSummary(events, context = {}) {
             ? {}
             : { fieldsChanged: cap(fieldsChanged, 'fieldsChanged', elided) }),
         ...(0 === Object.keys(elided).length ? {} : { elided }),
-        ...(layoutShift === undefined ? {} : { layoutShift }),
+        ...(shiftInWindow === undefined ? {} : { layoutShift: shiftInWindow }),
         longTasks,
         ...(true === context.stateUnwatched ? { stateUnwatched: true } : {}),
         ...(true === context.truncated ? { truncated: true } : {}),

package/dist/judgement/runs/artifact/replay-mapping.d.ts

@@ -4,8 +4,20 @@
  * perspective a flow that drifted no longer behaves, so it must not read as green. The actionable
  * "why" is lifted from the replay's decision envelope (or its error) into failureReason.
  */
-import { ReplayStatus, RunFlowStatus, type FlowFile, type FlowReplayResult, type RunFlowResult } from '@reticlehq/core';
+import { ReplayStatus, RunFlowStatus, type FlowFile, type FlowReplayResult, type RunFlowResult, type RunStepResult } from '@reticlehq/core';
 /** OK → PASS; UNVERIFIABLE → SKIPPED; DRIFT/ERROR → FAIL (a healed flow is produced by the heal path, not plain replay). */
 export declare function runFlowStatusOf(status: ReplayStatus): RunFlowStatus;
+/** One step as synced: what it did, where, and whether it held. */
+/**
+ * A run step with how far a sequence got. Kept out of the shared run schema on purpose: that schema
+ * ships in the page SDK, where every byte counts, and only the CLI score in this same process reads
+ * the field. A schema reader strips it, which loses nothing it needs.
+ */
+export interface ScoredRunStep extends RunStepResult {
+    subSteps?: {
+        passed: number;
+        total: number;
+    };
+}
 /** Map one replay (plus its measured duration) into a RunFlowResult for the artifact's flows[]. */
 export declare function mapReplayToFlowResult(replay: FlowReplayResult, durationMs: number, flow?: FlowFile): RunFlowResult;

package/dist/judgement/runs/artifact/replay-mapping.js

@@ -15,7 +15,6 @@ export function runFlowStatusOf(status) {
     return RunFlowStatus.FAIL;
 }
 const clip = (text) => text.length > RUN_TEXT_MAX ? `${text.slice(0, RUN_TEXT_MAX - 1)}…` : text;
-/** One step as synced: what it did, where, and whether it held. */
 function stepResultOf(step) {
     return {
         step: step.step,
@@ -26,6 +25,7 @@ function stepResultOf(step) {
         ...(step.consequence === undefined ? {} : { consequence: clip(step.consequence) }),
         ...(step.error === undefined ? {} : { error: clip(step.error) }),
         ...(step.drift === undefined ? {} : { drift: step.drift.reasonKind }),
+        ...(step.subSteps === undefined ? {} : { subSteps: step.subSteps }),
     };
 }
 /**

package/dist/judgement/runs/reticle-runner.js

@@ -10,12 +10,26 @@
  * same artifact byte-for-byte.
  */
 import { reportRunTelemetry } from '../../telemetry/run-telemetry.js';
-import { boundFlowName, RunFlowStatus, VerifyPhase, } from '@reticlehq/core';
+import { boundFlowName, RunFlowStatus, VerifyPhase, ReplayStatus, } from '@reticlehq/core';
 import { buildVerificationRun, } from './artifact/build-verification-run.js';
 import { mapReplayToFlowResult } from './artifact/replay-mapping.js';
 import { buildRepairPackets } from './repair-prompt.js';
 import { withShotRun } from './default-run-id.js';
 import { buildRisks, classifyChangedFiles, } from './risk-classify.js';
+/**
+ * A flow whose replay threw (its browser session was lost, the app stopped answering) proves
+ * nothing, and it must not take the other flows of the suite down with it. It is graded as a replay
+ * that could not be completed: skipped, never a pass, with the error as the reason.
+ */
+function replayThatCouldNotRun(name, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        name,
+        status: ReplayStatus.UNVERIFIABLE,
+        steps: [],
+        unverifiable: { reason: `the replay stopped before it could be graded: ${message}` },
+    };
+}
 export class ReticleRunner {
     #port;
     constructor(port) {
@@ -58,7 +72,7 @@ export class ReticleRunner {
                 name: boundFlowName(name),
                 at: start,
             });
-            const replay = await withShotRun(runId, () => this.#port.replayFlow(name));
+            const replay = await withShotRun(runId, () => this.#port.replayFlow(name)).catch((error) => replayThatCouldNotRun(name, error));
             replays.push(replay);
             const mapped = mapReplayToFlowResult(replay, this.#port.now() - start);
             flows.push(mapped);

package/dist/judgement/runs/run-ledger.d.ts

@@ -1,10 +1,12 @@
 import { Verified, type JournalAction, type RunReport } from '@reticlehq/core';
+/** A run with no agent call for this long is dropped. A working agent calls much more often. */
+export declare const RUN_IDLE_LIMIT_MS: number;
 export declare class RunLedger {
     #private;
-    /** An agent call starts. The first one starts the run, and a call from another agent starts a new one. */
+    /** An agent call starts. The agent's first call starts its run. A run idle too long is dropped. */
     begin(now: number, owner: string): void;
     /** An agent call ended. The first one that left a verdict sets the time to the first verdict. */
-    after(now: number): void;
+    after(now: number, owner?: string): void;
     /** A journal record from the agent's own call. A record with no verdict is not a claim. */
     verdict(action: JournalAction): void;
     flowSaved(name: string): void;
@@ -13,9 +15,9 @@ export declare class RunLedger {
     memoryWritten(count?: number): void;
     /** Notes given to the agent. Each one counts once, however often it is shown. */
     memoryRead(notes: readonly string[]): void;
-    isEmpty(): boolean;
-    /** The report, without the cloud line (the caller knows the project). Empties the ledger. */
-    take(now: number): RunReport;
+    isEmpty(owner?: string): boolean;
+    /** The owner's report, without the cloud line (the caller knows the project). Ends that run. */
+    take(now: number, owner?: string): RunReport;
 }
 /** The daemon's ledger. */
 export declare const runLedger: RunLedger;