@reticlehq/server 3.3.0 → 3.5.0

package/dist/portal/session/no-session-watch.js

@@ -9,13 +9,14 @@
  * It only probes while NOTHING is connected. Once a session is live the question is moot, and a
  * daemon that outlives the agent by hours has no business scanning ports it does not need.
  */
+import { probeRouteStatus } from './dev-server/route-status-probe.js';
 import { probeDevServers, probeDevServerStates } from './dev-server/dev-server-probe.js';
 import { homedir } from 'node:os';
 import { registeredElsewhere } from '../../memory/recall/registered-projects.js';
 import { explainNoSession } from './no-session-diagnosis.js';
 import { detectDevCommand } from './dev-server/dev-command.js';
 import { nextActionFor, renderNextAction } from './no-session-next-action.js';
-import { readProjectFramework, readProjectId, readProjectPort, } from '../../command/cli/ports/resolve/cli-port.js';
+import { readProjectFramework, readProjectId, readProjectIsDesktop, readProjectPort, } from '../../command/cli/ports/resolve/cli-port.js';
 import { discoverProjectConfigs } from '../../command/cli/config/config-discovery.js';
 import { hasProjectConnectedBefore, rememberConnected, } from '../../memory/recall/prior/connection-memory.js';
 import { isAlive, reticleStateHome } from '../../command/daemon/daemon.js';
@@ -24,6 +25,8 @@ import { stallUptime } from './stall-clock.js';
 import { probeDaemon } from '../../surface/mcp/mcp-proxy.js';
 import { findOccupiedSiblings } from '../../command/cli/ports/sibling-ports.js';
 import { isAuthRefusalReason } from '../bridge/auth-failure-reason.js';
+import { devServersForProject } from '@reticlehq/core';
+import { readDevServers } from '../../command/daemon/dev-servers.js';
 /** Slow enough to be free, fast enough that a dev server started 15s ago is already reflected. */
 const REFRESH_MS = 15_000;
 /** The URL an auto-attach opens. `localhost` for the same reason the probe uses it: both stacks. */
@@ -63,6 +66,15 @@ export function startNoSessionWatch(options) {
      */
     let slowListeners = [];
     let siblingListeners = [];
+    /**
+     * What the last-known route answered, cached beside the port scan for the same reason the scan
+     * is cached: the hint is read synchronously, so every fact it carries has to be gathered before
+     * it is asked. Keyed by URL so a status is never attributed to a route other than the one it
+     * came from — a fresh departure on a different URL reads as "not asked yet", not as the old
+     * answer.
+     */
+    let lastKnownStatus;
+    const routeStatus = options.routeStatus ?? probeRouteStatus;
     let running = false;
     /** Ports auto-attach has already spent its one attempt on. Bounded: never a loop, never a retry. */
     const attempted = new Set();
@@ -155,6 +167,31 @@ export function startNoSessionWatch(options) {
      * Bounded by construction: one attempt per port per daemon. A failure is recorded, never retried —
      * a retry loop against a broken Chromium install would spin for the daemon's whole life.
      */
+    const ownDevServerPorts = options.ownDevServerPorts ??
+        (() => devServersForProject(readDevServers(stateDir), {
+            projectId: readProjectId(directory),
+            root: directory,
+        }).map((entry) => entry.port));
+    /**
+     * Is `port` demonstrably this project's app? Either its dev server announced it, or this
+     * project's own last session was on it. Anything else is a guess, and a guess that opens a
+     * browser is worse than the sentence the diagnosis already writes about the ports it saw.
+     */
+    const attributable = (port) => {
+        if (ownDevServerPorts().includes(port))
+            return true;
+        const known = options.sessions.lastKnown?.();
+        const projectId = readProjectId(directory);
+        if (known === undefined || projectId === undefined || known.projectId !== projectId) {
+            return false;
+        }
+        try {
+            return Number(new URL(known.url).port) === port;
+        }
+        catch {
+            return false;
+        }
+    };
     const autoAttach = async (ports) => {
         const attach = options.attach;
         if (attach === undefined)
@@ -166,6 +203,8 @@ export function startNoSessionWatch(options) {
             return;
         if (!isWired())
             return;
+        if (!attributable(only))
+            return;
         attempted.add(only);
         try {
             await attach(`${LOCALHOST}:${String(only)}`);
@@ -193,6 +232,14 @@ export function startNoSessionWatch(options) {
                     : options.probe === undefined
                         ? await findOccupiedSiblings(options.port, probeDaemon)
                         : [];
+            // Asked once per departed URL, on the same background cadence as the port scan, and never
+            // on the hint's own path. A url already answered is not asked again; a new departure is.
+            const known = options.sessions.lastKnown?.();
+            if (known !== undefined && lastKnownStatus?.url !== known.url) {
+                const status = await routeStatus(known.url);
+                if (status !== undefined)
+                    lastKnownStatus = { url: known.url, status };
+            }
             await autoAttach(ports);
         })
             .catch(() => {
@@ -225,6 +272,21 @@ export function startNoSessionWatch(options) {
      */
     const lastCloseWasAuthFailure = () => isAuthRefusalReason(options.sessions.lastClosure?.()?.reason) &&
         true !== options.sessions.connectedSinceLastClosure?.();
+    /**
+     * A hello refused for anything but its token, while it is still the bridge's current state.
+     *
+     * Only closures that carry the refused page count: the bridge attaches one exactly when a HELLO
+     * was turned away, so an origin or handshake-pool refusal (which has its own sentence on
+     * `resolve`) is not mistaken for one. Same ordering clause as the token refusal above.
+     */
+    const currentHelloRefusal = () => {
+        const closure = options.sessions.lastClosure?.();
+        if (closure?.page === undefined || isAuthRefusalReason(closure.reason))
+            return undefined;
+        if (true === options.sessions.connectedSinceLastClosure?.())
+            return undefined;
+        return { reason: closure.reason, ...closure.page };
+    };
     const nextAction = (scope) => {
         const split = splitBrain();
         return nextActionFor({
@@ -235,8 +297,18 @@ export function startNoSessionWatch(options) {
             // Read when asked, like every other fact here: a page can dial at any moment, and a daemon
             // that cached "nothing has been refused" at boot would keep saying so.
             authRefused: lastCloseWasAuthFailure(),
+            ...(() => {
+                const refused = currentHelloRefusal();
+                return refused === undefined ? {} : { helloRefused: refused.reason };
+            })(),
             ...(split === undefined ? {} : { splitBrain: split }),
             listening,
+            // The url the departed tab was on — the same tombstone the prose diagnosis quotes, so the
+            // command and the sentence beside it name the same page.
+            ...(() => {
+                const known = options.sessions.lastKnown?.();
+                return known === undefined ? {} : { lastKnownUrl: known.url };
+            })(),
             // Read when asked, like everything else here: a `package.json` can gain a dev script, and a
             // daemon that cached "there is none" at boot would keep saying so for the rest of the day.
             dev: detectDevCommand(directory),
@@ -272,12 +344,19 @@ export function startNoSessionWatch(options) {
             // beside it still said the tab had been closed. One fact, two answers, and only one of them
             // was right. Read when asked, like the rest: a page can be refused at any moment.
             authRefused: lastCloseWasAuthFailure(),
+            ...(() => {
+                const refused = currentHelloRefusal();
+                return refused === undefined ? {} : { helloRefused: refused };
+            })(),
             // Ranks the causes. Read when asked, like the rest: `init` writes this file after the daemon
             // starts on an ordinary first install.
             ...(() => {
                 const framework = readProjectFramework(directory);
                 return framework === undefined ? {} : { framework };
             })(),
+            // A desktop app is opened by its own dev command, never by a browser URL or a lease. Read when
+            // asked, like the framework: `init` may wire the app after this daemon started.
+            ...(readProjectIsDesktop(directory) ? { desktop: true } : {}),
             // Decided from the session that actually went away, not from a lifetime tally: the lease
             // sentence is only right when the thing that vanished WAS a lease.
             leaseExpired: (() => {
@@ -289,7 +368,14 @@ export function startNoSessionWatch(options) {
             // has none to name.
             ...(() => {
                 const known = options.sessions.lastKnown?.();
-                return undefined === known ? {} : { lastKnownUrl: known.url };
+                if (undefined === known)
+                    return {};
+                // The status rides only when it was fetched for THIS url. A departure since the fetch
+                // means the cached answer is about a route nobody is asking about.
+                const status = lastKnownStatus !== undefined && lastKnownStatus.url === known.url
+                    ? { lastKnownStatus: lastKnownStatus.status }
+                    : {};
+                return { lastKnownUrl: known.url, ...status };
             })(),
             // How long this daemon has been waiting with no app. The diagnosis uses it to surface
             // "install never finished" — the same condition telemetry already knows about.

package/dist/portal/session/session-health.js

@@ -29,7 +29,8 @@ export const PENDING_NAVIGATION_NOTICE_MS = 10_000;
  */
 const SKEW_VERDICT_WARNING = 'version skew: `dispatched` and `settled` on this session mean the event was sent, NOT that the ' +
     'app acted on it — a skewed pair drops actions silently. Re-read the control (aria-checked, ' +
-    'data-state, its text) before trusting any verdict from this session, and converge the versions:';
+    'data-state, its text) before trusting any verdict from this session, and converge the versions ' +
+    '(see session.versionSkew).';
 /**
  * The age of the oldest request that STARTED and never completed, or undefined when there is none
  * worth reporting.
@@ -100,7 +101,7 @@ export function healthEnvelope(session) {
     // a skewed link makes the ACTION unreliable, and there is no point warning about the quality of an
     // observation of something that may never have happened.
     if (health.versionSkew !== undefined) {
-        return { session: health, warning: `${SKEW_VERDICT_WARNING} ${health.versionSkew}` };
+        return { session: health, warning: SKEW_VERDICT_WARNING };
     }
     return health.throttled ? { session: health, warning: THROTTLED_WARNING } : { session: health };
 }

package/dist/portal/session/session-manager.d.ts

@@ -14,6 +14,17 @@ interface ResolveScope {
 }
 /** The scheme://host:port of a URL, or undefined if it can't be parsed. Used to compare origins. */
 export declare function originOf(url: string | undefined): string | undefined;
+/** What a refused hello said about itself: the page it was on and the project it claimed. */
+export interface RefusedPage {
+    readonly url?: string;
+    readonly projectId?: string;
+}
+/** One bridge-initiated close, with the page that was turned away when the hello named one. */
+export interface ClosureRecord {
+    readonly at: number;
+    readonly reason: string;
+    readonly page?: RefusedPage;
+}
 export declare class SessionManager {
     #private;
     /** Set the active project's default resolve scope (called once at daemon wiring). */
@@ -57,13 +68,16 @@ export declare class SessionManager {
     setNoSessionNextAction(next: (() => NoSessionNextAction | undefined) | undefined): void;
     noSessionNextAction(): NoSessionNextAction | undefined;
     everConnected(): boolean;
-    /** Record a bridge-initiated close so `resolve` can explain a session that vanished. */
-    noteClosure(reason: string, at: number): void;
+    /**
+     * Record a bridge-initiated close so `resolve` can explain a session that vanished.
+     *
+     * `page` is what the refused hello said about itself, when it said anything. A refusal is the one
+     * piece of positive evidence the no-session diagnosis has, and "a page was refused" without WHICH
+     * page leaves the reader unable to tell their app from another project's tab on the same port.
+     */
+    noteClosure(reason: string, at: number, page?: RefusedPage): void;
     /** The most recent bridge-initiated close, if any. */
-    lastClosure(): {
-        at: number;
-        reason: string;
-    } | undefined;
+    lastClosure(): ClosureRecord | undefined;
     connectedSinceLastClosure(): boolean;
     /**
      * The id of the session that most recently went away, if any.

package/dist/portal/session/session-manager.js

@@ -325,9 +325,15 @@ export class SessionManager {
     everConnected() {
         return this.#everConnected;
     }
-    /** Record a bridge-initiated close so `resolve` can explain a session that vanished. */
-    noteClosure(reason, at) {
-        this.#recentClosures.push({ at, reason });
+    /**
+     * Record a bridge-initiated close so `resolve` can explain a session that vanished.
+     *
+     * `page` is what the refused hello said about itself, when it said anything. A refusal is the one
+     * piece of positive evidence the no-session diagnosis has, and "a page was refused" without WHICH
+     * page leaves the reader unable to tell their app from another project's tab on the same port.
+     */
+    noteClosure(reason, at, page) {
+        this.#recentClosures.push({ at, reason, ...(page === undefined ? {} : { page }) });
         if (this.#recentClosures.length > MAX_REMEMBERED_CLOSURES)
             this.#recentClosures.shift();
         this.#connectedSinceLastClosure = false;
@@ -512,6 +518,16 @@ export class SessionManager {
         const allThrottled = bestScore >= 1;
         const RECENCY_GAP_MS = allThrottled ? 0 : 1_000;
         const clearWinner = runnerUp === undefined || best.ms + RECENCY_GAP_MS < runnerUp.ms;
+        // Healthy tabs heartbeat on the same cadence, so the recency gap between two of them is noise.
+        // When exactly one has the window focus it is the one a human is looking at: tabs piled up one
+        // per `init` run, and every tool called without a sessionId was refused while one of them was
+        // plainly the tab in front. Only among healthy ones — focus says nothing about a wedged tab.
+        const focused = allThrottled ? [] : candidates.filter((x) => x.s.health().focused);
+        const [onlyFocused, secondFocused] = focused;
+        if (!clearWinner && onlyFocused !== undefined && secondFocused === undefined) {
+            onlyFocused.s.markAgentActivity();
+            return onlyFocused.s;
+        }
         if (!clearWinner) {
             // Ambiguous: list sessions with their health so the agent can choose.
             const detail = all

package/dist/portal/session/session-reaper.d.ts

@@ -22,6 +22,34 @@ export declare function composeEndedNotice(base: string, undelivered: string[]):
  * not a crash, since the agent is still connected and revives on its next action. Returns the ids.
  */
 export declare function reapIdleSessions(sessions: SessionManager): string[];
+/**
+ * Drop sessions that have ENDED, gone quiet and lost their socket, so a listing stops offering them.
+ *
+ * `reticle_session { action: "end" }` sets state and nothing else -- it never calls
+ * `sessions.remove`. `SessionManager.list()` does not filter by state, and `reapIdleSessions`
+ * above skips ended sessions by design. The only code path in the whole server that removes a
+ * session is the socket `close` handler in bridge.ts. So an ended session whose socket is already
+ * gone has nothing left that can remove it, and the row is listed for the life of the daemon
+ * (#938).
+ *
+ * That is what the field report describes: `{ ended: true }` three times, the row back on the next
+ * `reticle_sessions` call each time, still there after every tab on the origin was closed, 17 hours
+ * attached. And Reticle's own advice for a stale session is
+ * `Call reticle_session{action:"end"} to free this session` -- which is the one thing that does not
+ * free it.
+ *
+ * Deliberately NOT "remove on end". The panel is client-side, so `setState` has already pushed the
+ * ended state to the browser and the HUD keeps it; but `end` is documented idempotent, and removing
+ * immediately would make a second call fail to resolve. Waiting for the session to go quiet keeps
+ * that, keeps a just-ended session inspectable, and still collects the case that actually hurts: a
+ * row nobody can get rid of.
+ *
+ * Only once the socket is no longer open. An ended session whose tab is still connected but quiet
+ * belongs to a page that holds a live connection; dropping the record would orphan that socket,
+ * leaving a connection the daemon no longer tracks. Such a session is still removed the ordinary
+ * way, by the `close` handler, when the tab goes.
+ */
+export declare function reapEndedSessions(sessions: SessionManager, staleAfterMs?: number): string[];
 /** End every active session immediately (the agent / MCP client disconnected → WARN). Returns ended ids. */
 export declare function endAllSessions(sessions: SessionManager, reason: string): string[];
 /**

package/dist/portal/session/session-reaper.js

@@ -1,4 +1,4 @@
-import { PresenterTone, SESSION_LIFECYCLE, UNDELIVERED_NOTES_LABEL } from '@reticlehq/core';
+import { PresenterTone, SESSION_LEASE, SESSION_LIFECYCLE, UNDELIVERED_NOTES_LABEL, } from '@reticlehq/core';
 import { log } from '../../log.js';
 /**
  * Server-authoritative session liveness. The browser idle timer is throttled in a backgrounded tab
@@ -51,6 +51,50 @@ export function reapIdleSessions(sessions) {
         log('session_reaped_idle', { sessions: ended });
     return ended;
 }
+/**
+ * Drop sessions that have ENDED, gone quiet and lost their socket, so a listing stops offering them.
+ *
+ * `reticle_session { action: "end" }` sets state and nothing else -- it never calls
+ * `sessions.remove`. `SessionManager.list()` does not filter by state, and `reapIdleSessions`
+ * above skips ended sessions by design. The only code path in the whole server that removes a
+ * session is the socket `close` handler in bridge.ts. So an ended session whose socket is already
+ * gone has nothing left that can remove it, and the row is listed for the life of the daemon
+ * (#938).
+ *
+ * That is what the field report describes: `{ ended: true }` three times, the row back on the next
+ * `reticle_sessions` call each time, still there after every tab on the origin was closed, 17 hours
+ * attached. And Reticle's own advice for a stale session is
+ * `Call reticle_session{action:"end"} to free this session` -- which is the one thing that does not
+ * free it.
+ *
+ * Deliberately NOT "remove on end". The panel is client-side, so `setState` has already pushed the
+ * ended state to the browser and the HUD keeps it; but `end` is documented idempotent, and removing
+ * immediately would make a second call fail to resolve. Waiting for the session to go quiet keeps
+ * that, keeps a just-ended session inspectable, and still collects the case that actually hurts: a
+ * row nobody can get rid of.
+ *
+ * Only once the socket is no longer open. An ended session whose tab is still connected but quiet
+ * belongs to a page that holds a live connection; dropping the record would orphan that socket,
+ * leaving a connection the daemon no longer tracks. Such a session is still removed the ordinary
+ * way, by the `close` handler, when the tab goes.
+ */
+export function reapEndedSessions(sessions, staleAfterMs = SESSION_LEASE.STALE_AFTER_MS) {
+    const dropped = [];
+    // Snapshot first: `remove` mutates the map this iterates.
+    for (const session of [...sessions.all()]) {
+        if (!session.isEnded())
+            continue;
+        if (session.socketOpen())
+            continue;
+        if (session.staleMs() < staleAfterMs)
+            continue;
+        if (sessions.remove(session))
+            dropped.push(session.id);
+    }
+    if (dropped.length > 0)
+        log('session_reaped_ended', { sessions: dropped });
+    return dropped;
+}
 /** End every active session immediately (the agent / MCP client disconnected → WARN). Returns ended ids. */
 export function endAllSessions(sessions, reason) {
     const ended = [];
@@ -81,6 +125,10 @@ export class SessionReaper {
             return;
         this.#timer = setInterval(() => {
             reapIdleSessions(this.#sessions);
+            // Second rule, same sweep, kept as its own function: one ends a live session that went
+            // quiet, the other collects one that already ended. Merging them would put "end this" and
+            // "forget this" behind a single condition.
+            reapEndedSessions(this.#sessions);
         }, this.#intervalMs);
         this.#timer.unref();
     }

package/dist/portal/session/session.d.ts

@@ -91,6 +91,8 @@ export declare class Session implements HandshakeFacts {
      * `reticle_session{action:"end"}` — a flag on the record, not on the page — could not help.
      */
     unresponsive(): boolean;
+    /** False once the socket is closing or closed: dropping this record then orphans nothing. */
+    socketOpen(): boolean;
     /** Wall-clock age of the session in milliseconds. */
     staleMs(): number;
     /** The document the most recent stamped event was observed under. See `#documentId`. */
@@ -114,6 +116,9 @@ export declare class Session implements HandshakeFacts {
      * against the same control after a re-render gave it a different ref.
      */
     private recordActedLabelFrom;
+    /** A control whose action PROVED its declared consequence — the coverage ledger's `proved`. */
+    recordProvedFrom(actPayload: unknown): void;
+    provedLabels(): ReadonlySet<string>;
     actedRefs(): ReadonlySet<string>;
     noteRateLimited(dropped: number): void;
     blindSpots(): Readonly<Record<string, number>>;
@@ -211,16 +216,13 @@ export declare class Session implements HandshakeFacts {
         total: number;
         dropped: number;
     };
+    /** Did the event store lose scarce evidence from a window opened at `cursor`? See `windowLost`. */
+    lostSince(cursor: number): boolean;
     /**
-     * Did the EVENT STORE lose scarce evidence from a window opened at `cursor`? The input to whether a
-     * verdict's capture was clean — see `RingBuffer.lostSince`, and never the raw drop counter, which
-     * moves for the age and churn evictions that every live page produces continuously. The journal is
-     * the other half of that store, so a durable read that could not reach back to `cursor` lost
-     * exactly what an eviction would have. Both boundaries are INCLUSIVE (`t` is a millisecond many
-     * records share) and an absent `lostThroughT` impeaches every window rather than none — the
-     * conservative direction, both times.
+     * Hold events at/after `cursor` against count-cap eviction until the returned function runs, so a
+     * predicate's own match cannot be dropped inside the window it is graded on (#668).
      */
-    lostSince(cursor: number): boolean;
+    protectWindow(cursor: number): () => void;
     onEvent(listener: (event: ReticleEvent) => void): () => void;
     onDisconnect(listener: () => void): () => void;
     /** Send a command to the browser and await its reply (or time out). */

package/dist/portal/session/session.js

@@ -14,9 +14,9 @@ import { span } from '../../trace.js';
 import { keepCallerContextInDaemon, noteToDaemonLog } from './daemon-answers.js';
 import { isKnownRealm, EventType, HumanControlDataSchema, HumanControlKind, HumanMarkDataSchema, HudUseDataSchema, ReticleCommand, MessageKind, parseEventPayload, PresenterTone, SESSION_HEALTH, SESSION_LEASE, SESSION_LIFECYCLE, SessionState, } from '@reticlehq/core';
 import { RingBuffer } from '@reticlehq/engine/window/ring-buffer.js';
-import { readJournalWriteLoss, readQueryEvents, } from '../../memory/journal/journal-query.js';
+import { readJournalWriteLoss, readQueryEvents, windowLost, } from '../../memory/journal/journal-query.js';
 import {} from '@reticlehq/engine/window/ambient.js';
-import { ObservedState } from './facts/observed-state.js';
+import { ObservedState, controlLabelsOf } from './facts/observed-state.js';
 import { recordBrowserLatency, recordHudUse, recordSdkFailure, } from '../../telemetry/session-metrics.js';
 import { LiveControl } from './human/live-control.js';
 import { ReviewStore } from './human/review-store.js';
@@ -241,6 +241,10 @@ export class Session {
     unresponsive() {
         return this.#unansweredCommands >= UNRESPONSIVE_AFTER_TIMEOUTS;
     }
+    /** False once the socket is closing or closed: dropping this record then orphans nothing. */
+    socketOpen() {
+        return this.#socket.readyState === WS_OPEN;
+    }
     /** Wall-clock age of the session in milliseconds. */
     staleMs() {
         return this.#clock() - this.#startedAt;
@@ -352,24 +356,16 @@ export class Session {
      * against the same control after a re-render gave it a different ref.
      */
     recordActedLabelFrom(result) {
-        const payload = result.result;
-        if (typeof payload !== 'object' || null === payload)
-            return;
-        const record = payload;
-        // The TESTID first: it is the strongest identity a control has and it survives any re-render.
-        // Coverage previously matched only on `role "name"`, so a control with a testid but no accessible
-        // name — or on a stack where the act reply carried neither — was unrecognisable after a
-        // re-render, and coverage read `exercised: 0` however much work had been done.
-        const testid = record['testid'];
-        if ('string' === typeof testid && testid.length > 0)
-            this.#observed.recordActedLabel(testid);
-        const role = record['role'];
-        const name = record['name'];
-        if (typeof role !== 'string' || typeof name !== 'string')
-            return;
-        if (0 === role.length || 0 === name.length)
-            return;
-        this.#observed.recordActedLabel(`${role} "${name}"`);
+        for (const label of controlLabelsOf(result.result))
+            this.#observed.recordActedLabel(label);
+    }
+    /** A control whose action PROVED its declared consequence — the coverage ledger's `proved`. */
+    recordProvedFrom(actPayload) {
+        for (const label of controlLabelsOf(actPayload))
+            this.#observed.recordProvedLabel(label);
+    }
+    provedLabels() {
+        return this.#observed.provedLabels();
     }
     actedRefs() {
         return this.#observed.actedRefs();
@@ -532,20 +528,16 @@ export class Session {
     bufferHealth() {
         return this.#buffer.bufferHealth();
     }
+    /** Did the event store lose scarce evidence from a window opened at `cursor`? See `windowLost`. */
+    lostSince(cursor) {
+        return windowLost(this.#journalReader, this.#buffer, cursor);
+    }
     /**
-     * Did the EVENT STORE lose scarce evidence from a window opened at `cursor`? The input to whether a
-     * verdict's capture was clean — see `RingBuffer.lostSince`, and never the raw drop counter, which
-     * moves for the age and churn evictions that every live page produces continuously. The journal is
-     * the other half of that store, so a durable read that could not reach back to `cursor` lost
-     * exactly what an eviction would have. Both boundaries are INCLUSIVE (`t` is a millisecond many
-     * records share) and an absent `lostThroughT` impeaches every window rather than none — the
-     * conservative direction, both times.
+     * Hold events at/after `cursor` against count-cap eviction until the returned function runs, so a
+     * predicate's own match cannot be dropped inside the window it is graded on (#668).
      */
-    lostSince(cursor) {
-        if (this.#buffer.lostSince(cursor))
-            return true;
-        const lost = this.#journalReader?.readLoss?.();
-        return lost !== undefined && (lost.lostThroughT === undefined || lost.lostThroughT >= cursor);
+    protectWindow(cursor) {
+        return this.#buffer.protect(cursor);
     }
     onEvent(listener) {
         this.#listeners.add(listener);

package/dist/surface/http-server.d.ts

@@ -8,9 +8,10 @@ export interface SharedServer {
      * so each concurrent Claude Code client needs its own McpServer.
      * Must be called before listen.
      */
-    attachMcp(factory: () => McpServer): void;
+    attachMcp(factory: (peerSkew?: string) => McpServer): void;
     /** Register the JSON the daemon returns from GET /status (live sessions + health for `reticle status`). */
-    attachStatus(provider: () => unknown): void;
+    /** `held`: the request carried STATUS_HOLD_QUERY — a setup run is waiting on this daemon. */
+    attachStatus(provider: (held: boolean) => unknown): void;
     /**
      * Register the handler behind POST /drive: open a driveable browser at `url` and answer with the
      * session it registered.

package/dist/surface/http-server.js

@@ -1,8 +1,8 @@
 import * as http from 'node:http';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import { MCP_SSE_PATH, MCP_MESSAGE_PATH, MCP_SHUTDOWN_EVENT, STATUS_PATH, DRIVE_PATH, } from '@reticlehq/core';
+import { MCP_SSE_PATH, MCP_MESSAGE_PATH, MCP_SHUTDOWN_EVENT, STATUS_PATH, STATUS_HOLD_QUERY, DRIVE_PATH, } from '@reticlehq/core';
 import { getSessionMetrics } from '../telemetry/session-metrics.js';
-import { noteAgentPeer, PEER_VERSION_PARAM, PEER_CONTRACT_PARAM, } from '../command/version/peer-announce.js';
+import { agentPeerSkew, PEER_VERSION_PARAM, PEER_CONTRACT_PARAM, } from '../command/version/peer-announce.js';
 import { log } from '../log.js';
 import { isLoopbackHost, isLocalWebOrigin, isLoopbackPeer, requestToken, tokensMatch, } from '../portal/bridge/token-auth.js';
 import { LOOPBACK_IDLE_MS } from './loopback-agent.js';
@@ -76,7 +76,9 @@ export function createSharedServer(options = {}) {
             }
         }
         if ('GET' === req.method && path === STATUS_PATH) {
-            const body = JSON.stringify(statusProvider?.() ?? { running: true });
+            // A setup run waiting on this daemon says so on its polls; see daemon-usefulness.
+            const held = url.searchParams.has(STATUS_HOLD_QUERY);
+            const body = JSON.stringify(statusProvider?.(held) ?? { running: true });
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(body);
             return;
@@ -139,7 +141,7 @@ export function createSharedServer(options = {}) {
             // own check (a stderr line no agent reads), a nudge queued here rides out on the agent's next
             // tool result. That is the pair the user hits after `npm update`: a cached npx MCP package
             // talking to a daemon from a different build.
-            noteAgentPeer(url.searchParams.get(PEER_VERSION_PARAM), url.searchParams.get(PEER_CONTRACT_PARAM));
+            const peerSkew = agentPeerSkew(url.searchParams.get(PEER_VERSION_PARAM), url.searchParams.get(PEER_CONTRACT_PARAM));
             if (mcpFactory === undefined) {
                 res.writeHead(503, { 'Content-Type': 'text/plain' });
                 res.end('MCP server not ready');
@@ -148,7 +150,8 @@ export function createSharedServer(options = {}) {
             // Fresh McpServer per connection: the MCP SDK's Protocol layer only supports
             // one active transport per Server instance, so concurrent clients each need
             // their own instance backed by the same shared ToolDeps.
-            const mcpServer = mcpFactory();
+            // Handed to THIS connection's server only: the skew is about this agent, not the daemon (#1136).
+            const mcpServer = mcpFactory(peerSkew);
             const transport = new SSEServerTransport(MCP_MESSAGE_PATH, res);
             const sid = transport.sessionId;
             transports.set(sid, transport);

package/dist/surface/mcp/mcp-proxy.d.ts

@@ -1,11 +1,11 @@
 export { SseFrameParser, type SseFrame } from './sse-frame-parser.js';
-export { probeDaemon, waitForDaemon } from './proxy/proxy-daemon-probe.js';
+export { probeDaemon, waitForDaemon, waitForDaemonBind } from './proxy/proxy-daemon-probe.js';
 /**
  * Re-exported so every existing caller (and every spec) keeps importing the proxy's log from the
  * proxy. Where the code lives is a file-size decision; where it is imported from is an API.
  */
 export { accountProxyLogWrite, proxyLog, proxyLogPath, PROXY_LOG_CHECK_BYTES, recoverOversizedProxyLog, setProxyLogPort, } from './proxy/proxy-log.js';
-export { reconnectDelayMs, RECONNECT_BASE_MS, RECONNECT_CAP_MS } from './proxy/proxy-backoff.js';
+export { reconnectDelayMs } from './proxy/proxy-backoff.js';
 export { MCP_PROXY_HTTP_AGENT_OPTIONS, postToSession, shouldRetryUnsentPost, type PostFailure, } from './proxy/mcp-post-transport.js';
 /**
  * Overridable so the survival spec can reach exhaustion in seconds instead of minutes — the same

package/dist/surface/mcp/mcp-proxy.js

@@ -6,7 +6,7 @@ import { toolsChangedNotification } from './proxy/proxy-handshake.js';
 import { LOOPBACK_HOST, MCP_SSE_PATH, MCP_SHUTDOWN_EVENT, ReticleEnv, CONTRACT_FINGERPRINT, } from '@reticlehq/core';
 import { SseFrameParser } from './sse-frame-parser.js';
 export { SseFrameParser } from './sse-frame-parser.js';
-export { probeDaemon, waitForDaemon } from './proxy/proxy-daemon-probe.js';
+export { probeDaemon, waitForDaemon, waitForDaemonBind } from './proxy/proxy-daemon-probe.js';
 import { probeDaemon } from './proxy/proxy-daemon-probe.js';
 import { SERVER_VERSION } from '../../command/version/identity/server-version.js';
 import { buildServerInstructions } from './server-instructions.js';
@@ -33,7 +33,7 @@ import { OutageReason, OutageStage, reportMcpOutage } from './faults/mcp-outage.
 import { postToSession } from './proxy/mcp-post-transport.js';
 import { reconnectDelayMs } from './proxy/proxy-backoff.js';
 import { PROXY_IDLE_EXIT_EVENT, ProxyIdleExit, resolveProxyIdleExitMs } from './proxy-idle-exit.js';
-export { reconnectDelayMs, RECONNECT_BASE_MS, RECONNECT_CAP_MS } from './proxy/proxy-backoff.js';
+export { reconnectDelayMs } from './proxy/proxy-backoff.js';
 export { MCP_PROXY_HTTP_AGENT_OPTIONS, postToSession, shouldRetryUnsentPost, } from './proxy/mcp-post-transport.js';
 /**
  * How many consecutive failed reconnects before the proxy stops RETRYING. It does not stop serving:

package/dist/surface/mcp/mcp.js

@@ -103,7 +103,7 @@ import { firstSentence } from '../tools/first-sentence.js';
  * making it a pointer costs nothing.
  */
 const PREDICATE_KINDS = 'Predicate object: { kind, ...fields }. kind is one of element | text | net | route | console | ' +
-    'animation | signal | state | settled | allOf | anyOf | not.';
+    'animation | signal | state | settled | compare | allOf | anyOf | not.';
 /**
  * Said once per turn: the bug-catching options, and where to get the rest of the field grammar.
  *
@@ -118,9 +118,11 @@ const PREDICATE_KINDS = 'Predicate object: { kind, ...fields }. kind is one of e
  * paying for six.
  */
 const PREDICATE_FIELD_GRAMMAR_HINT = ' Bug-catching options: net.count (exact request count — catches double-submit), ' +
-    'net.bodyMatches (a shallow JSON match on what the SERVER answered — say the FIELD and its value, ' +
+    'net.bodyMatches (a JSON field match on what the SERVER answered — say the FIELD (a dotted path reaches nested ones) and its value, ' +
     'because a substring of the body matches key names too), net.requestBodyMatches (the same on what ' +
     'the UI SENT — the verdict for "applying this filter actually puts it in the payload"), ' +
+    'compare (page text vs server answer, no expected value: { left:{from:"text",scope}, ' +
+    'right:{from:"net",urlContains,path}, as:"number" }), ' +
     'console.absent:true (action completed with a CLEAN ' +
     'console), absent:true on element/text (it should be gone). Call reticle_tools for the full field ' +
     'grammar of a kind.';
@@ -660,7 +662,7 @@ tools = tableForSurface(profile)) {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify(liveCallValues(takeVersionSkewOnto(buildErrorPayload(message)), advertisedNames)),
+                            text: JSON.stringify(liveCallValues(takeVersionSkewOnto(buildErrorPayload(message), deps.peerSkew), advertisedNames)),
                         },
                     ],
                 };