@reticlehq/server 2.3.0 → 2.5.0

package/dist/honesty/already-true.js

@@ -0,0 +1,31 @@
+/**
+ * Which predicates can be satisfied by something that was already true before the action.
+ *
+ * Event-based kinds (net, signal, route, console, animation, settled) are evaluated against the
+ * event buffer floored at the act's own cursor, so a stale event cannot satisfy them — that floor is
+ * why `act_and_wait` can trust them at all. `state` is read through the same floored path.
+ *
+ * `element` and `text` read the LIVE DOM, where no floor exists. A condition that held before the
+ * click holds after it and passes instantly, whatever the action did. Measured in the field: a click
+ * asserted with `{ kind: 'text', contains: 'Parallel Routes' }` returned `verified: "yes"` in 478ms
+ * against `routeChanges: 0`, because the predicate matched the nav link that was already on screen —
+ * the real navigation landed 1.8 seconds later.
+ *
+ * So these are the kinds worth evaluating BEFORE the act, to find out whether the green means
+ * anything.
+ */
+import { PredicateKind } from '@reticlehq/core';
+export function readsDomState(predicate) {
+    switch (predicate.kind) {
+        case PredicateKind.ELEMENT:
+        case PredicateKind.TEXT:
+            return true;
+        case PredicateKind.ALL_OF:
+        case PredicateKind.ANY_OF:
+            return predicate.predicates.some(readsDomState);
+        case PredicateKind.NOT:
+            return readsDomState(predicate.predicate);
+        default:
+            return false;
+    }
+}

package/dist/honesty/blind-spots.d.ts

@@ -6,12 +6,25 @@
  */
 export { BlindSpotKind } from '@reticlehq/core';
 import { BlindSpotKind, type ReticleEvent } from '@reticlehq/core';
-export interface BlindSpot {
+interface BlindSpot {
     kind: BlindSpotKind;
     count: number;
 }
-export interface CoverageStatement {
-    coverage: 'full' | 'partial';
+/**
+ * Whether the observation window saw everything it was asked about.
+ *
+ * NOT core's VerdictStatus, which happens to spell one of its values 'partial' too: that one grades
+ * a verification RUN (some flows passed, some failed), this one grades what could be OBSERVED. Two
+ * meanings behind one string is exactly how a comparison ends up reading the wrong field, so they
+ * stay separate vocabularies.
+ */
+export declare const Coverage: {
+    readonly FULL: "full";
+    readonly PARTIAL: "partial";
+};
+export type Coverage = (typeof Coverage)[keyof typeof Coverage];
+interface CoverageStatement {
+    coverage: Coverage;
     /** Present only when partial — the human/agent-legible list of what went unobserved. */
     note?: string;
     spots: BlindSpot[];

package/dist/honesty/blind-spots.js

@@ -8,22 +8,34 @@
 // honesty-side imports keep working.
 export { BlindSpotKind } from '@reticlehq/core';
 import { BlindSpotKind, EventType } from '@reticlehq/core';
+/**
+ * Whether the observation window saw everything it was asked about.
+ *
+ * NOT core's VerdictStatus, which happens to spell one of its values 'partial' too: that one grades
+ * a verification RUN (some flows passed, some failed), this one grades what could be OBSERVED. Two
+ * meanings behind one string is exactly how a comparison ends up reading the wrong field, so they
+ * stay separate vocabularies.
+ */
+export const Coverage = {
+    FULL: 'full',
+    PARTIAL: 'partial',
+};
 const LABEL = {
-    [BlindSpotKind.CLOSED_SHADOW_ROOT]: (n) => `${String(n)} closed shadow root${n === 1 ? '' : 's'} unobserved`,
-    [BlindSpotKind.CROSS_ORIGIN_IFRAME]: (n) => `${String(n)} cross-origin frame${n === 1 ? '' : 's'} unobserved`,
+    [BlindSpotKind.CLOSED_SHADOW_ROOT]: (n) => `${String(n)} closed shadow root${1 === n ? '' : 's'} unobserved`,
+    [BlindSpotKind.CROSS_ORIGIN_IFRAME]: (n) => `${String(n)} cross-origin frame${1 === n ? '' : 's'} unobserved`,
     // The DOM of these frames IS observed; only their network is not. Saying so precisely matters — a
     // flat "unobserved" would discard a real capability and push agents back to guessing.
-    [BlindSpotKind.UNINSTRUMENTED_FRAME]: (n) => `${String(n)} same-origin frame${n === 1 ? '' : 's'} observed for DOM but not network — requests they make are invisible`,
-    [BlindSpotKind.VIRTUALIZED_UNMOUNTED]: (n) => `${String(n)} virtualized unmounted row${n === 1 ? '' : 's'} unobserved`,
+    [BlindSpotKind.UNINSTRUMENTED_FRAME]: (n) => `${String(n)} same-origin frame${1 === n ? '' : 's'} observed for DOM but not network — requests they make are invisible`,
+    [BlindSpotKind.VIRTUALIZED_UNMOUNTED]: (n) => `${String(n)} virtualized unmounted row${1 === n ? '' : 's'} unobserved`,
     // Not "some rows we could not see" — the events never reached the observer, so this window is a
     // SAMPLE of what the app did. Phrased as a caveat on what the whole result MEANS.
-    [BlindSpotKind.RATE_LIMITED]: (n) => `${String(n)} event${n === 1 ? '' : 's'} dropped by the bridge rate cap, so this window is SAMPLED — raise RETICLE_MAX_MESSAGES_PER_SECOND for a busy app`,
+    [BlindSpotKind.RATE_LIMITED]: (n) => `${String(n)} event${1 === n ? '' : 's'} dropped by the bridge rate cap, so this window is SAMPLED — raise RETICLE_MAX_MESSAGES_PER_SECOND for a busy app`,
     // Not a count of things — a single fact about the page. Phrased so the coverage line reads as a
     // caveat on what the network view MEANS, not as a tally.
     // A count of unverifiable ACTIONS, not of things we failed to look at. The distinction matters:
     // nothing here was missed, there was simply never a verdict to observe, and no amount of extra
     // instrumentation would produce one.
-    [BlindSpotKind.VERDICTLESS_SEND]: (n) => `${String(n)} one-way IPC send${n === 1 ? '' : 's'} dispatched with NO verdict — the renderer never learns whether the main process handled ${n === 1 ? 'it' : 'them'}, so this cannot be confirmed from the page`,
+    [BlindSpotKind.VERDICTLESS_SEND]: (n) => `${String(n)} one-way IPC send${1 === n ? '' : 's'} dispatched with NO verdict — the renderer never learns whether the main process handled ${1 === n ? 'it' : 'them'}, so this cannot be confirmed from the page`,
     [BlindSpotKind.WRAPPED_NETWORK]: () => 'fetch was already wrapped before Reticle, so recorded requests may differ from what was sent',
     // A fact about the app's wiring, not a tally. Says what the empty network view MEANS, because an
     // empty one here is indistinguishable from "this app made no backend calls" — and that reading is
@@ -53,8 +65,8 @@ export function impeachesCapture(kind) {
 /** Compose the coverage statement. `full` (no note) when nothing was unobserved. */
 export function buildCoverageStatement(spots) {
     const present = spots.filter((s) => s.count > 0);
-    if (present.length === 0)
-        return { coverage: 'full', spots: [] };
+    if (0 === present.length)
+        return { coverage: Coverage.FULL, spots: [] };
     // Each label carries its own ending. Appending a blanket " unobserved" here produced
     // "...may differ from what was sent unobserved" for the wrapped-network caveat, which is a
     // sentence rather than a count — and the same dangle appeared the moment a second prose-shaped
@@ -63,9 +75,9 @@ export function buildCoverageStatement(spots) {
     // daemon can report one, and `LABEL[kind](count)` threw a TypeError on the verdict path when it
     // did — turning "there is something I could not see" into a crashed assert, which is worse than
     // either the caveat or the silence. Unknown kinds degrade to their own name.
-    const label = (s) => typeof LABEL[s.kind] === 'function' ? LABEL[s.kind](s.count) : `${s.kind} (${String(s.count)})`;
-    const note = `partial — ${present.map(label).join(', ')}`;
-    return { coverage: 'partial', note, spots: present };
+    const label = (s) => 'function' === typeof LABEL[s.kind] ? LABEL[s.kind](s.count) : `${s.kind} (${String(s.count)})`;
+    const note = `${Coverage.PARTIAL} — ${present.map(label).join(', ')}`;
+    return { coverage: Coverage.PARTIAL, note, spots: present };
 }
 /**
  * Reduce a window's BLIND_SPOT events to one spot per kind — the LATEST reported count wins (the sensor
@@ -79,7 +91,7 @@ export function blindSpotsFromEvents(events) {
             continue;
         const kind = e.data['kind'];
         const count = e.data['count'];
-        if (typeof kind === 'string' && typeof count === 'number') {
+        if ('string' === typeof kind && 'number' === typeof count) {
             latest.set(kind, count);
         }
     }

package/dist/honesty/honesty.d.ts

@@ -14,7 +14,7 @@ export declare const HonestyGrade: {
     readonly NONE: "none";
 };
 export type HonestyGrade = (typeof HonestyGrade)[keyof typeof HonestyGrade];
-export interface HonestyInputs {
+interface HonestyInputs {
     grade: HonestyGrade;
     /** Present when a causal chain is presented; `window` = time-heuristic, never dataflow truth. */
     attribution?: string;
@@ -43,7 +43,7 @@ export interface HonestyBlock {
     };
 }
 export declare function buildHonestyBlock(inputs: HonestyInputs): HonestyBlock;
-export interface HonestyBar {
+interface HonestyBar {
     /** The minimum grade a green must carry to be trusted (default: any). */
     minGrade?: HonestyGrade;
     /** Require capture integrity to be clean (no truncation / blind spots). */
@@ -54,3 +54,4 @@ export declare function meetsHonestyBar(block: HonestyBlock, bar?: HonestyBar):
     ok: boolean;
     reasons: string[];
 };
+export {};

package/dist/honesty/honesty.js

@@ -26,7 +26,7 @@ const MIN_ENVELOPE_SAMPLES = 3;
 const FULL_COVERAGE_PCT = 100;
 export function buildHonestyBlock(inputs) {
     const issues = [];
-    if (inputs.truncated === true)
+    if (true === inputs.truncated)
         issues.push('capture truncated');
     for (const spot of inputs.blindSpots ?? [])
         issues.push(`blind spot: ${spot}`);
@@ -46,7 +46,7 @@ export function buildHonestyBlock(inputs) {
             ? {}
             : { envelope: { samples, sufficient: samples >= MIN_ENVELOPE_SAMPLES } }),
         coverage: { ...(pct === undefined ? {} : { pct }), partial },
-        integrity: { clean: issues.length === 0, issues },
+        integrity: { clean: 0 === issues.length, issues },
     };
 }
 /** Whether a verdict's honesty block clears the harness's bar. Reasons list every failed criterion. */
@@ -55,8 +55,8 @@ export function meetsHonestyBar(block, bar = {}) {
     if (bar.minGrade !== undefined && GRADE_RANK[block.grade] < GRADE_RANK[bar.minGrade]) {
         reasons.push(`grade ${block.grade} below required ${bar.minGrade}`);
     }
-    if (bar.requireIntegrityClean === true && !block.integrity.clean) {
+    if (true === bar.requireIntegrityClean && !block.integrity.clean) {
         reasons.push(`integrity not clean: ${block.integrity.issues.join('; ')}`);
     }
-    return { ok: reasons.length === 0, reasons };
+    return { ok: 0 === reasons.length, reasons };
 }

package/dist/honesty/uncaptured-bodies.js

@@ -15,7 +15,7 @@ const BODY_BEARING_METHODS = new Set(['POST', 'PUT', 'PATCH']);
  */
 export function bodiesNotCaptured(calls) {
     const bodyBearing = calls.filter((c) => BODY_BEARING_METHODS.has((c.method ?? '').toUpperCase()));
-    if (bodyBearing.length === 0)
+    if (0 === bodyBearing.length)
         return {};
     if (bodyBearing.some((c) => c.requestBody !== undefined))
         return {};

package/dist/honesty/unread-outcome.js

@@ -36,7 +36,7 @@ export function hasUnreadWriteOutcome(events) {
     return events.some((event) => {
         if (event.type !== EventType.NET_REQUEST)
             return false;
-        const method = (typeof event.data['method'] === 'string' ? event.data['method'] : '').toUpperCase();
+        const method = ('string' === typeof event.data['method'] ? event.data['method'] : '').toUpperCase();
         if (method === IPC_METHOD || !MUTATING_METHODS.includes(method))
             return false;
         const status = event.data['status'];
@@ -45,6 +45,6 @@ export function hasUnreadWriteOutcome(events) {
         if (event.data['responseBody'] !== undefined)
             return false; // read — findBodyFailures judged it
         const size = event.data['responseSize'];
-        return typeof size === 'number' && size > 0;
+        return 'number' === typeof size && size > 0;
     });
 }

package/dist/honesty/verified.d.ts

@@ -1,4 +1,4 @@
-import { Verified } from '@reticlehq/core';
+import { Verified, VerifiedReason } from '@reticlehq/core';
 import { type HonestyBlock } from './honesty.js';
 /**
  * The decision rule: eight trust dimensions in, one answer out.
@@ -11,10 +11,21 @@ import { type HonestyBlock } from './honesty.js';
  * Ordering is deliberate, because the first matching clause also writes `because`, and the reader
  * should be told the most actionable fact rather than the first true one.
  */
-export interface VerifiedInputs {
+interface VerifiedInputs {
     /** Did the declared consequence hold? Undefined when the action declared none. */
     pass?: boolean;
     honesty: HonestyBlock;
+    /**
+     * Set when the assertion could not be EVALUATED at all — an under-specified call, or nothing
+     * instrumented to read. Carries the sentence naming what is missing.
+     */
+    inconclusive?: string;
+    /**
+     * The declared consequence was ALREADY TRUE before the action ran, so its holding afterwards says
+     * nothing about the action. Only meaningful for predicates that read live DOM state — event-based
+     * ones are floored at the act's cursor and cannot be satisfied by the past.
+     */
+    alreadyTrue?: boolean;
     /** Cross-channel disagreements found in the action's window. */
     contradictions?: readonly {
         kind: string;
@@ -32,9 +43,17 @@ export interface VerifiedInputs {
      */
     outcomeUnread?: boolean;
 }
-export interface VerifiedVerdict {
+interface VerifiedVerdict {
     verified: Verified;
+    /**
+     * WHICH clause below decided this, as a closed enum. `verified` has three values and this rule has
+     * ten clauses, so the verdict alone collapses opposite facts — "Reticle caught a real bug", "the
+     * agent wrote a bad predicate" and "Reticle could not see" all arrived as one string. Named here,
+     * beside the sentence, so the vocabulary cannot drift from the branches that produce it.
+     */
+    verifiedReason: VerifiedReason;
     /** One sentence naming the deciding evidence — never a restatement of the field. */
     because: string;
 }
 export declare function decideVerified(inputs: VerifiedInputs): VerifiedVerdict;
+export {};

package/dist/honesty/verified.js

@@ -1,10 +1,25 @@
-import { Verified } from '@reticlehq/core';
+import { Verified, VerifiedReason } from '@reticlehq/core';
 import { HonestyGrade } from './honesty.js';
 export function decideVerified(inputs) {
     const { pass, honesty, contradictions = [], settled, outcomePending, outcomeUnread } = inputs;
-    // A failed assertion is the most actionable fact there is; it leads.
-    if (pass === false) {
-        return { verified: Verified.NO, because: 'the declared consequence did not hold' };
+    // Ahead of the failure clause, because a failure is only the most actionable fact when there WAS
+    // one. An assertion nobody could evaluate is not a defect in the app, and calling it one was
+    // putting the agent's own malformed calls into the bug count.
+    if (inputs.inconclusive !== undefined) {
+        return {
+            verified: Verified.UNKNOWN,
+            verifiedReason: VerifiedReason.INCONCLUSIVE,
+            because: `the assertion could not be evaluated: ${inputs.inconclusive}`,
+        };
+    }
+    // A failed assertion is the most actionable fact there is; it leads — including over
+    // `alreadyTrue`, because a condition that held before AND fails now is a real regression.
+    if (false === pass) {
+        return {
+            verified: Verified.NO,
+            verifiedReason: VerifiedReason.ASSERTION_FAILED,
+            because: 'the declared consequence did not hold',
+        };
     }
     // A contradiction outranks a passing assertion, and that inversion is the whole point: the case
     // this product exists to catch is a green assertion sitting on top of a failed write. Measured on
@@ -14,15 +29,35 @@ export function decideVerified(inputs) {
         const kinds = contradictions.map((c) => c.kind).join(', ');
         return {
             verified: Verified.NO,
+            verifiedReason: VerifiedReason.CONTRADICTED,
             because: `channels disagree about this action (${kinds}) even though the assertion passed`,
         };
     }
+    // Below the contradiction clause, and for the same reason a contradiction outranks a dirty
+    // capture: evidence AGAINST beats absence of evidence, whichever absence it is. Both can hold at
+    // once — assert `{ text: 'Saved' }` that was already on screen while the write 500s — and ordering
+    // this first downgraded a DETECTED false green from NO to UNKNOWN, which reads as "assert
+    // something else" rather than "this is broken".
+    //
+    // A green that was already green before the action is not evidence about the action. Measured in
+    // the field: a click asserted with `{ text: 'Parallel Routes' }` returned verified "yes" in 478ms
+    // with routeChanges 0, because the text was the nav link already on screen — the real navigation
+    // landed 1.8s later. UNKNOWN rather than NO on purpose: the app may well be fine, and reporting a
+    // failure we did not observe would be its own false claim.
+    if (true === inputs.alreadyTrue) {
+        return {
+            verified: Verified.UNKNOWN,
+            verifiedReason: VerifiedReason.ALREADY_TRUE,
+            because: 'the declared consequence was already true before this action, so it proves nothing about it — assert something the action CHANGES (a signal, a request, a route, or store state)',
+        };
+    }
     // Dirty capture is NOT failure. The layer could not see part of the window, so any green is a
     // statement about what it happened to observe — which is precisely the thing that must not be
     // reported as proof.
     if (!honesty.integrity.clean) {
         return {
             verified: Verified.UNKNOWN,
+            verifiedReason: VerifiedReason.UNCLEAN_CAPTURE,
             because: `capture was not clean (${honesty.integrity.issues.join('; ')}), so a green here would only describe what was observed`,
         };
     }
@@ -32,6 +67,7 @@ export function decideVerified(inputs) {
     if (honesty.grade === HonestyGrade.NONE) {
         return {
             verified: Verified.UNKNOWN,
+            verifiedReason: VerifiedReason.VACUOUS_GRADE,
             because: 'nothing was asserted at a real grade, so passing proves nothing — assert a signal, request, or state path',
         };
     }
@@ -43,9 +79,10 @@ export function decideVerified(inputs) {
     // optimistically rendered "dispatched", the page settled, and the verdict came back `yes` — then
     // the server REVERTED it to `held` 1.2s later. Every channel agreed, and every channel was early.
     // UNKNOWN rather than NO: nothing has failed, and saying it has would be its own false report.
-    if (outcomePending === true) {
+    if (true === outcomePending) {
         return {
             verified: Verified.UNKNOWN,
+            verifiedReason: VerifiedReason.OUTCOME_PENDING,
             because: 'a write returned 202 Accepted, so the server has not finished processing it — this window cannot contain the outcome; re-check once it reconciles',
         };
     }
@@ -56,16 +93,18 @@ export function decideVerified(inputs) {
     //
     // UNKNOWN, not NO: nothing is known to have failed. The remedy is in the sentence, because an
     // agent that cannot act on a caveat will learn to skip it.
-    if (outcomeUnread === true) {
+    if (true === outcomeUnread) {
         return {
             verified: Verified.UNKNOWN,
+            verifiedReason: VerifiedReason.OUTCOME_UNREAD,
             because: 'a write returned 2xx with a response body that was never recorded, so its outcome is unread — a 200 describes the transport, not the result (a batch reports per-item failures in the body, and every GraphQL error is a 200). Enable it where your app calls connect(): `reticle.connect({ captureNetworkBodies: true })`, then re-run',
         };
     }
     // Never settled: the page may still be moving, so the observation window may have closed early.
-    if (settled === false) {
+    if (false === settled) {
         return {
             verified: Verified.UNKNOWN,
+            verifiedReason: VerifiedReason.UNSETTLED,
             because: 'the page never settled, so the reaction window may have closed before the app finished',
         };
     }
@@ -79,7 +118,8 @@ export function decideVerified(inputs) {
     // own. Seen on a one-way IPC send: coverage said the outcome was unobservable, `because` said clean.
     return {
         verified: Verified.YES,
-        because: honesty.coverage?.partial === true
+        verifiedReason: VerifiedReason.PROVED,
+        because: true === honesty.coverage?.partial
             ? `assertion held at ${honesty.grade} grade with no channel disagreeing, but coverage was PARTIAL — see \`coverage\` for what went unobserved`
             : `assertion held at ${honesty.grade} grade over a clean capture with no channel disagreeing`,
     };

package/dist/http-server.js

@@ -1,9 +1,10 @@
 import * as http from 'node:http';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { MCP_SSE_PATH, MCP_MESSAGE_PATH, STATUS_PATH } from '@reticlehq/core';
+import { noteAgentPeer, PEER_VERSION_PARAM, PEER_CONTRACT_PARAM } from './version/peer-announce.js';
 import { log } from './log.js';
 import { reportMcpConnected } from './telemetry/mcp-connection.js';
-import { isLoopbackHost, isLocalWebOrigin, isLoopbackPeer, requestToken, tokensMatch, } from './token-auth.js';
+import { isLoopbackHost, isLocalWebOrigin, isLoopbackPeer, requestToken, tokensMatch, } from './bridge/token-auth.js';
 /**
  * Creates a shared HTTP server that handles both the WebSocket bridge (browser SDK) and the
  * SSE MCP transport (Claude/agent). Does NOT call listen — caller controls that.
@@ -52,13 +53,19 @@ export function createSharedServer(options = {}) {
                 return;
             }
         }
-        if (req.method === 'GET' && path === STATUS_PATH) {
+        if ('GET' === req.method && path === STATUS_PATH) {
             const body = JSON.stringify(statusProvider?.() ?? { running: true });
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(body);
             return;
         }
-        if (req.method === 'GET' && path === MCP_SSE_PATH) {
+        if ('GET' === req.method && path === MCP_SSE_PATH) {
+            // The agent's MCP server announces itself here, on the connect it already makes. The daemon is
+            // the single judge of skew, so this is where the third pair is decided — and unlike the CLI's
+            // 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));
             if (mcpFactory === undefined) {
                 res.writeHead(503, { 'Content-Type': 'text/plain' });
                 res.end('MCP server not ready');
@@ -71,14 +78,14 @@ export function createSharedServer(options = {}) {
             const transport = new SSEServerTransport(MCP_MESSAGE_PATH, res);
             const sid = transport.sessionId;
             transports.set(sid, transport);
-            if (transports.size === 1)
+            if (1 === transports.size)
                 agentPresence?.(true); // first agent attached
             res.on('close', () => {
                 transports.delete(sid);
                 transport.close().catch(() => undefined);
                 mcpServer.close().catch(() => undefined);
                 log('mcp_client_disconnected', { sessionId: sid });
-                if (transports.size === 0)
+                if (0 === transports.size)
                     agentPresence?.(false); // last agent detached → it's the human's turn
             });
             mcpServer
@@ -96,9 +103,9 @@ export function createSharedServer(options = {}) {
             });
             return;
         }
-        if (req.method === 'POST' && path === MCP_MESSAGE_PATH) {
+        if ('POST' === req.method && path === MCP_MESSAGE_PATH) {
             const sessionId = url.searchParams.get('sessionId');
-            if (sessionId === null) {
+            if (null === sessionId) {
                 res.writeHead(400, { 'Content-Type': 'text/plain' });
                 res.end('missing sessionId');
                 return;

package/dist/hunt/hunt-report.d.ts

@@ -33,7 +33,7 @@ export interface HuntRun {
     /** Controls actually driven. A run that drove nothing proves nothing and is reported separately. */
     stepsRun?: number;
 }
-export interface HuntSummary {
+interface HuntSummary {
     runs: number;
     /** Runs that actually drove at least one control. The denominator that can honestly be quoted. */
     runsWithCoverage: number;
@@ -48,3 +48,4 @@ export interface HuntSummary {
     headline: string;
 }
 export declare function summarizeHunt(runs: readonly HuntRun[]): HuntSummary;
+export {};

package/dist/hunt/hunt-report.js

@@ -74,10 +74,10 @@ export function summarizeHunt(runs) {
  * this project exists to distrust.
  */
 function buildHeadline(withCoverage, flaggedRuns, contradictions) {
-    if (withCoverage === 0) {
+    if (0 === withCoverage) {
         return 'no run drove a single control — nothing was measured, which is not the same as nothing being wrong';
     }
-    if (flaggedRuns === 0) {
+    if (0 === flaggedRuns) {
         return `${String(withCoverage)} merged changes crawled, no cross-channel contradictions found — confirm coverage was real before reading this as clean`;
     }
     return `${String(flaggedRuns)} of ${String(withCoverage)} merged, already-green changes carried a candidate false green (${String(contradictions)} contradictions) — each needs manual confirmation before it is counted`;

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { Bridge } from './bridge.js';
+import { Bridge } from './bridge/bridge.js';
 import type { OwnedRealInputProvider, RealInputProvider, InjectConnectOptions } from './input/real-input.js';
 export { ReticleTool } from './tools/tool-names.js';
 export { RingBuffer } from './events/ring-buffer.js';
-export { Bridge } from './bridge.js';
+export { Bridge } from './bridge/bridge.js';
 export { Session, SessionManager } from './session/session.js';
 export type { SessionInfo, SessionHealth } from './session/session.js';
 export { buildSessionRecommendation } from './session/session-recommendation.js';
@@ -33,12 +33,12 @@ export { BrowserPool, DEFAULT_LEASE_TTL_MS } from './pool/browser-pool.js';
 export type { Lease, Launcher, PooledBrowser } from './pool/browser-pool.js';
 export { playwrightLauncher, resolveMaxContexts } from './pool/playwright-launcher.js';
 export { appendReticleParams } from './tools/lease-tools.js';
-export { writePid, removePid, isRunning, logPath, readPid, isAlive } from './daemon.js';
+export { writePid, removePid, isRunning, logPath, readPid, isAlive } from './daemon/daemon.js';
 export type { CrawlReport, CrawlAnomaly, CrawlOptions, CrawlSession } from './crawl/crawl.js';
 export { scrollToFind } from './input/scroll-find.js';
 export type { ScrollFindResult, ScrollFindQuery, ScrollFindSession } from './input/scroll-find.js';
-export { CORE_TOOL_NAMES, TOOL_PROFILE, TOOL_PROFILE_ENV, filterTools, resolveToolProfile, } from './tools/profiles.js';
-export type { ToolProfile } from './tools/profiles.js';
+export { CORE_TOOL_NAMES, TOOL_SURFACE, TOOL_PROFILE_ENV, filterTools, resolveToolSurface, } from './tools/tool-surface.js';
+export type { ToolSurface } from './tools/tool-surface.js';
 export { AnnotationStore } from './flows/annotation-store.js';
 export { replayFlow, nearestTestid } from './flows/flow-replay.js';
 export type { FlowReplaySession, WaitForSignal } from './flows/flow-replay.js';
@@ -118,11 +118,13 @@ export interface RunningServer {
     /** True when nothing is using the daemon: no agent connected, no browser session, no pool lease.
      * The daemon entry (cli.ts) polls this to self-shut-down when idle so Reticle never lingers. */
     isIdle?: () => boolean;
+    /** True while an agent's MCP client is attached — see IdleShutdownOptions.agentAttached. */
+    agentAttached?: () => boolean;
     /** The pairing token the bridge is enforcing (explicit, env, or auto-provisioned); undefined if none. */
     token?: string;
     close: () => Promise<void>;
 }
-export { resolveBridgeSecurity } from './bridge-security.js';
+export { resolveBridgeSecurity } from './bridge/bridge-security.js';
 /** Start the Reticle bridge (browser WS endpoint) and, by default, the MCP stdio server. */
 export declare function start(options?: StartOptions): Promise<RunningServer>;
 /**