@reticlehq/server 2.4.0 → 2.6.0

package/dist/oracles/propose-consequences.js

@@ -1,4 +1,4 @@
-import { EventType } from '@reticlehq/core';
+import { EventType, PredicateKind } from '@reticlehq/core';
 const TIER = { SIGNAL: 0, CONSEQUENCE: 1, PRESENCE: 2 };
 function pathname(url) {
     if (typeof url !== 'string')
@@ -25,9 +25,9 @@ export function proposeConsequences(events) {
         switch (event.type) {
             case EventType.SIGNAL: {
                 const name = data['name'];
-                if (typeof name === 'string') {
+                if ('string' === typeof name) {
                     add(`signal:${name}`, {
-                        predicate: { kind: 'signal', name },
+                        predicate: { kind: PredicateKind.SIGNAL, name },
                         tier: TIER.SIGNAL,
                         label: `signal "${name}" fires`,
                         weak: false,
@@ -37,10 +37,15 @@ export function proposeConsequences(events) {
             }
             case EventType.NET_REQUEST: {
                 const path = pathname(data['url']);
-                const method = typeof data['method'] === 'string' ? data['method'] : 'GET';
+                const method = 'string' === typeof data['method'] ? data['method'] : 'GET';
                 if (path !== undefined) {
                     add(`net:${method} ${path}`, {
-                        predicate: { kind: 'net', method, urlContains: path, status: data['status'] },
+                        predicate: {
+                            kind: PredicateKind.NET,
+                            method,
+                            urlContains: path,
+                            status: data['status'],
+                        },
                         tier: TIER.CONSEQUENCE,
                         label: `${method} ${path} responds`,
                         weak: false,
@@ -50,9 +55,9 @@ export function proposeConsequences(events) {
             }
             case EventType.STATE_CHANGE: {
                 const name = data['name'];
-                if (typeof name === 'string') {
+                if ('string' === typeof name) {
                     add(`state:${name}`, {
-                        predicate: { kind: 'state', store: name, path: data['path'] },
+                        predicate: { kind: PredicateKind.STATE, store: name, path: data['path'] },
                         tier: TIER.CONSEQUENCE,
                         label: `state "${name}" changes`,
                         weak: false,
@@ -62,9 +67,9 @@ export function proposeConsequences(events) {
             }
             case EventType.ROUTE_CHANGE: {
                 const to = data['pathname'];
-                if (typeof to === 'string') {
+                if ('string' === typeof to) {
                     add(`route:${to}`, {
-                        predicate: { kind: 'route', to },
+                        predicate: { kind: PredicateKind.ROUTE, to },
                         tier: TIER.CONSEQUENCE,
                         label: `route changes to ${to}`,
                         weak: false,
@@ -74,9 +79,9 @@ export function proposeConsequences(events) {
             }
             case EventType.DOM_ADDED: {
                 const name = data['name'];
-                if (typeof name === 'string' && name.length > 0) {
+                if ('string' === typeof name && name.length > 0) {
                     add(`presence:${name}`, {
-                        predicate: { kind: 'element', name },
+                        predicate: { kind: PredicateKind.ELEMENT, name },
                         tier: TIER.PRESENCE,
                         label: `"${name}" appears (presence only — prefer a consequence)`,
                         weak: true,

package/dist/oracles/self-instrument.d.ts

@@ -20,7 +20,7 @@ export interface InstrumentationGap {
     /** Why this gap matters (e.g. "checkout flow asserts presence only"). */
     context?: string;
 }
-export interface InstrumentationProposal {
+interface InstrumentationProposal {
     file: string;
     line: number;
     /** The code to insert. */
@@ -29,3 +29,4 @@ export interface InstrumentationProposal {
 }
 /** Turn located capability gaps into ready-to-apply instrumentation proposals. Deterministic. */
 export declare function proposeInstrumentation(gaps: readonly InstrumentationGap[]): InstrumentationProposal[];
+export {};

package/dist/oracles/self-instrument.js

@@ -12,7 +12,7 @@ export const InstrumentationGapKind = {
 };
 /** PascalCase a store name for a `useX.getState` hint (cart → Cart). */
 function pascal(name) {
-    return name.length === 0 ? name : name[0]?.toUpperCase() + name.slice(1);
+    return 0 === name.length ? name : name[0]?.toUpperCase() + name.slice(1);
 }
 function insertFor(gap) {
     switch (gap.kind) {

package/dist/phenomena/phenomena.js

@@ -28,14 +28,14 @@ export function detectHidden500(events) {
     for (const event of events) {
         if (event.type === EventType.PAGE_HEALTH) {
             const h = event.data['hidden'];
-            if (typeof h === 'boolean')
+            if ('boolean' === typeof h)
                 hidden = h;
             continue;
         }
         if (event.type !== EventType.NET_REQUEST)
             continue;
         const status = event.data['status'];
-        if (hidden && typeof status === 'number' && status >= 500) {
+        if (hidden && 'number' === typeof status && status >= 500) {
             findings.push({
                 phenomenon: PhenomenonType.HIDDEN_500,
                 evidence: { url: event.data['url'], status, method: event.data['method'] },
@@ -83,7 +83,7 @@ export function detectSwallowedErrors(events) {
             const detail = event.data['data'];
             findings.push({
                 phenomenon: PhenomenonType.SWALLOWED_ERROR,
-                evidence: typeof detail === 'object' && detail !== null ? detail : {},
+                evidence: 'object' === typeof detail && detail !== null ? detail : {},
             });
         }
     }

package/dist/platform.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The `process.platform` values this daemon actually branches on, named once.
+ *
+ * They were spelled inline in five files — `cli-launch`, `cloud-cli`, `init/node-io`, `update/updater`
+ * — and every one of them gates real behaviour rather than cosmetics: whether a spawn needs a shell,
+ * whether the npm binary is `npm.cmd`, which command opens a browser. A typo in any of those reads as
+ * "Windows is broken" and is invisible on the machine of whoever wrote it, because the wrong branch
+ * simply never runs there.
+ *
+ * Node-side only, so deliberately NOT in `@reticlehq/core` — core is the wire contract, and a
+ * platform name never crosses the wire.
+ */
+export declare const NodePlatform: {
+    readonly WINDOWS: "win32";
+    readonly MACOS: "darwin";
+};

package/dist/platform.js

@@ -0,0 +1,16 @@
+/**
+ * The `process.platform` values this daemon actually branches on, named once.
+ *
+ * They were spelled inline in five files — `cli-launch`, `cloud-cli`, `init/node-io`, `update/updater`
+ * — and every one of them gates real behaviour rather than cosmetics: whether a spawn needs a shell,
+ * whether the npm binary is `npm.cmd`, which command opens a browser. A typo in any of those reads as
+ * "Windows is broken" and is invisible on the machine of whoever wrote it, because the wrong branch
+ * simply never runs there.
+ *
+ * Node-side only, so deliberately NOT in `@reticlehq/core` — core is the wire contract, and a
+ * platform name never crosses the wire.
+ */
+export const NodePlatform = {
+    WINDOWS: 'win32',
+    MACOS: 'darwin',
+};

package/dist/pool/browser-pool.d.ts

@@ -77,6 +77,15 @@ export declare class BrowserPool {
      * forever. Returns the released sessionIds. This is the fault-tolerance backstop for the pool.
      */
     sweepExpired(): Promise<string[]>;
+    /**
+     * How many leases this pool has reclaimed for going stale.
+     *
+     * Read by the no-session diagnosis: an aged-out lease used to be reported as "the tab was closed
+     * … ask the human to reopen the app", which is wrong on every clause and sent one reporter looking
+     * for a port mismatch (#157). A count is enough — the message says "likeliest", not "certainly",
+     * because nothing here knows WHICH session the caller just lost.
+     */
+    reapedLeaseCount(): number;
     /**
      * Lease an isolated context, navigate it to `url`, and return a handle. If the pool is at capacity,
      * waits FIFO until a slot frees (or until `signal` aborts, if provided).

package/dist/pool/browser-pool.js

@@ -27,6 +27,8 @@ export class BrowserPool {
     #browser;
     #launching;
     #closed = false;
+    /** Leases reclaimed for going stale — see reapedLeaseCount(). */
+    #reapedLeases = 0;
     #active = new Map();
     /**
      * Slots claimed-or-active — the real concurrency gate. Incremented SYNCHRONOUSLY the instant an
@@ -85,8 +87,20 @@ export class BrowserPool {
             .map(([sessionId]) => sessionId);
         for (const sessionId of expired)
             await this.#release(sessionId);
+        this.#reapedLeases += expired.length;
         return expired;
     }
+    /**
+     * How many leases this pool has reclaimed for going stale.
+     *
+     * Read by the no-session diagnosis: an aged-out lease used to be reported as "the tab was closed
+     * … ask the human to reopen the app", which is wrong on every clause and sent one reporter looking
+     * for a port mismatch (#157). A count is enough — the message says "likeliest", not "certainly",
+     * because nothing here knows WHICH session the caller just lost.
+     */
+    reapedLeaseCount() {
+        return this.#reapedLeases;
+    }
     /**
      * Lease an isolated context, navigate it to `url`, and return a handle. If the pool is at capacity,
      * waits FIFO until a slot frees (or until `signal` aborts, if provided).
@@ -138,6 +152,15 @@ export class BrowserPool {
         this.#active.clear();
         this.#occupied = 0;
         await Promise.all(contexts.map((c) => c.close().catch(() => undefined)));
+        // If a launch is in flight, await it so we can close the resulting browser — otherwise it
+        // resolves after shutdown returns and the Chromium process is orphaned (hundreds of MB leaked).
+        const inflight = this.#launching;
+        if (inflight !== undefined) {
+            const launched = await inflight.catch(() => undefined);
+            if (launched !== undefined && launched !== this.#browser) {
+                await launched.close().catch(() => undefined);
+            }
+        }
         const browser = this.#browser;
         this.#browser = undefined;
         if (browser !== undefined)
@@ -168,27 +191,33 @@ export class BrowserPool {
             const onFree = () => {
                 // The pool shut down while we waited → reject rather than relaunch a browser.
                 if (this.#closed) {
+                    if (signal !== undefined)
+                        signal.removeEventListener('abort', onAbort);
                     reject(new Error('browser pool is shut down'));
                     return;
                 }
                 // Claim the freed slot; if another woken waiter beat us to it, re-queue.
-                if (this.#tryClaim())
+                if (this.#tryClaim()) {
+                    if (signal !== undefined)
+                        signal.removeEventListener('abort', onAbort);
                     resolve();
-                else
+                }
+                else {
                     this.#waiters.push(onFree);
+                }
+            };
+            const onAbort = () => {
+                const i = this.#waiters.indexOf(onFree);
+                if (i >= 0)
+                    this.#waiters.splice(i, 1);
+                reject(new Error('acquire aborted'));
             };
             if (signal !== undefined) {
                 if (signal.aborted) {
                     reject(new Error('acquire aborted'));
                     return;
                 }
-                signal.addEventListener('abort', () => {
-                    // Remove ourselves from the queue so a later wake doesn't claim a slot we'll never use.
-                    const i = this.#waiters.indexOf(onFree);
-                    if (i >= 0)
-                        this.#waiters.splice(i, 1);
-                    reject(new Error('acquire aborted'));
-                }, { once: true });
+                signal.addEventListener('abort', onAbort, { once: true });
             }
             this.#waiters.push(onFree);
         });

package/dist/pool/playwright-launcher.d.ts

@@ -6,8 +6,21 @@
  * Headless by default — the pool exists for fault-tolerant headless multi-agent testing.
  */
 import type { Launcher } from './browser-pool.js';
-/** The fix for the most common first-run failure: Chromium isn't installed for Playwright. */
-export declare const CHROMIUM_MISSING_HINT = "Chromium is not installed for Playwright. Run: npx playwright install chromium";
+/**
+ * How a leased tab navigates. Pure, and exported, because the decision in it is worth a test while
+ * the rest of this file needs a real Chromium.
+ *
+ * `waitUntil: 'domcontentloaded'` — NOT Playwright's default of `load`. `load` waits for every
+ * subresource, so an app with one that never finishes burns the whole nav budget and the lease then
+ * reports "is the app running?" about an app that is running. Measured on the sveltekit fixture:
+ * 30,501ms and a false diagnosis. The SDK connect is a module script and runs before
+ * DOMContentLoaded, and the pool separately waits for the session to register, so the load event was
+ * never what proved the page was usable.
+ */
+export declare function gotoOptions(timeoutMs: number | undefined): {
+    waitUntil: 'domcontentloaded';
+    timeout?: number;
+};
 /** A Launcher that boots a real headless Chromium and adapts it to the pool's interface. */
 export declare function playwrightLauncher(opts?: {
     headless?: boolean;

package/dist/pool/playwright-launcher.js

@@ -8,6 +8,25 @@
 import { BrowserLaunchKind } from '@reticlehq/core';
 import { getSessionMetrics } from '../telemetry/session-metrics.js';
 import { classifyConnectFailure } from '../telemetry/connect-failure.js';
+/**
+ * How a leased tab navigates. Pure, and exported, because the decision in it is worth a test while
+ * the rest of this file needs a real Chromium.
+ *
+ * `waitUntil: 'domcontentloaded'` — NOT Playwright's default of `load`. `load` waits for every
+ * subresource, so an app with one that never finishes burns the whole nav budget and the lease then
+ * reports "is the app running?" about an app that is running. Measured on the sveltekit fixture:
+ * 30,501ms and a false diagnosis. The SDK connect is a module script and runs before
+ * DOMContentLoaded, and the pool separately waits for the session to register, so the load event was
+ * never what proved the page was usable.
+ */
+export function gotoOptions(timeoutMs) {
+    return {
+        waitUntil: 'domcontentloaded',
+        // Absent, not zero: zero means "no timeout" to Playwright, which would turn a slow page into a
+        // lease that never returns.
+        ...(timeoutMs === undefined ? {} : { timeout: timeoutMs }),
+    };
+}
 function wrapBrowser(browser) {
     return {
         isConnected: () => browser.isConnected(),
@@ -17,7 +36,7 @@ function wrapBrowser(browser) {
                 newPage: async () => {
                     const page = await context.newPage();
                     return {
-                        goto: (url, opts) => page.goto(url, opts?.timeoutMs === undefined ? undefined : { timeout: opts.timeoutMs }),
+                        goto: (url, opts) => page.goto(url, gotoOptions(opts?.timeoutMs)),
                         close: () => page.close(),
                         onCrash: (handler) => page.on('crash', handler),
                     };
@@ -30,7 +49,7 @@ function wrapBrowser(browser) {
     };
 }
 /** The fix for the most common first-run failure: Chromium isn't installed for Playwright. */
-export const CHROMIUM_MISSING_HINT = 'Chromium is not installed for Playwright. Run: npx playwright install chromium';
+const CHROMIUM_MISSING_HINT = 'Chromium is not installed for Playwright. Run: npx playwright install chromium';
 /** A Launcher that boots a real headless Chromium and adapts it to the pool's interface. */
 export function playwrightLauncher(opts = {}) {
     const headless = opts.headless ?? true;

package/dist/project/fs-port.js

@@ -48,6 +48,6 @@ export function createNodeFileSystem() {
             const s = await stat(path);
             return { mtimeMs: s.mtimeMs };
         },
-        isNotFound: (error) => error?.code === 'ENOENT',
+        isNotFound: (error) => 'ENOENT' === error?.code,
     };
 }

package/dist/project/project-tools.js

@@ -36,7 +36,7 @@ function numericDelta(before, after) {
  */
 async function cloudRegression(deps, sessionId) {
     const config = resolveCloudConfig(process.env);
-    if (config === null)
+    if (null === config)
         return undefined;
     let projectId;
     try {
@@ -173,7 +173,7 @@ export const PROJECT_TOOLS = [
             const kindArg = args['kind'];
             const summary = asString(args['summary']);
             await deps.project.recordRun({
-                kind: typeof kindArg === 'string' ? kindArg : RunKind.MANUAL,
+                kind: 'string' === typeof kindArg ? kindArg : RunKind.MANUAL,
                 name,
                 status,
                 ...(summary !== undefined ? { summary } : {}),

package/dist/runs/build-verification-run.js

@@ -46,7 +46,7 @@ export function computeVerdict(input) {
         status = VerdictStatus.PASS;
     const ran = input.flows.length + input.checks.length;
     let confidence;
-    if (ran === 0)
+    if (0 === ran)
         confidence = RunConfidence.LOW;
     else if (input.flows.some((f) => f.oracle !== undefined) || input.checks.length > 0)
         confidence = RunConfidence.HIGH;

package/dist/runs/repair-prompt.d.ts

@@ -5,12 +5,6 @@
  * RepairPacket shape. This is the OEM self-heal value — a verdict that also says how to fix.
  */
 import { type FlowReplayResult, type RepairPacket } from '@reticlehq/core';
-/**
- * Build a repair packet for a failed replay, or undefined when the flow passed. The actual cause is
- * the decision's whatChanged, falling back to the replay error or a generic message.
- */
-/** The deviation report's headline when it flagged something — narrows the replay's `unknown` deviation. */
-export declare function deviationHeadline(deviation: unknown): string | undefined;
 export declare function buildRepairPacket(replay: FlowReplayResult): RepairPacket | undefined;
 /** Build the repair packets for a set of replays (failed ones only). */
 export declare function buildRepairPackets(replays: ReadonlyArray<FlowReplayResult>): RepairPacket[];

package/dist/runs/repair-prompt.js

@@ -36,11 +36,11 @@ function suggestedPrompt(name, actual, where, nextAction) {
  * the decision's whatChanged, falling back to the replay error or a generic message.
  */
 /** The deviation report's headline when it flagged something — narrows the replay's `unknown` deviation. */
-export function deviationHeadline(deviation) {
-    if (typeof deviation !== 'object' || deviation === null)
+function deviationHeadline(deviation) {
+    if (typeof deviation !== 'object' || null === deviation)
         return undefined;
     const d = deviation;
-    if (Array.isArray(d.deviations) && d.deviations.length > 0 && typeof d.headline === 'string') {
+    if (Array.isArray(d.deviations) && d.deviations.length > 0 && 'string' === typeof d.headline) {
         return d.headline;
     }
     return undefined;

package/dist/runs/risk-classify.js

@@ -62,7 +62,7 @@ export function buildRisks(changedFiles, policy = {}) {
     const risks = [];
     for (const { surface } of RISK_PATTERNS) {
         const files = filesBySurface.get(surface);
-        if (files === undefined || files.length === 0)
+        if (files === undefined || 0 === files.length)
             continue;
         risks.push({
             surface,

package/dist/runs/run-diff.d.ts

@@ -22,8 +22,6 @@ export interface RunDiff {
     };
     headline: string;
 }
-/** Below this percent, a duration change is noise (machine jitter), not a regression. */
-export declare const DEFAULT_NOISE_FLOOR_PCT = 10;
 /**
  * Compare two verification runs — the concrete answer to "what changed between run A and B". Flow
  * durations are diffed with a noise floor (jitter below it is ignored); status changes and new/removed

package/dist/runs/run-diff.js

@@ -1,5 +1,5 @@
 /** Below this percent, a duration change is noise (machine jitter), not a regression. */
-export const DEFAULT_NOISE_FLOOR_PCT = 10;
+const DEFAULT_NOISE_FLOOR_PCT = 10;
 function pct(before, delta) {
     return before > 0 ? Math.round((delta / before) * 100) : 0;
 }
@@ -11,7 +11,7 @@ function headlineFor(diff) {
     const regressions = diff.flows.filter((f) => f.regressed);
     if (regressions.length > 0) {
         const worst = regressions[0];
-        parts.push(`${String(regressions.length)} regression${regressions.length === 1 ? '' : 's'} (worst: ${worst?.name ?? ''} ${String(worst?.durationDeltaPct ?? 0)}%)`);
+        parts.push(`${String(regressions.length)} regression${1 === regressions.length ? '' : 's'} (worst: ${worst?.name ?? ''} ${String(worst?.durationDeltaPct ?? 0)}%)`);
     }
     if (diff.newFlows.length > 0)
         parts.push(`+${String(diff.newFlows.length)} flow`);
@@ -20,7 +20,7 @@ function headlineFor(diff) {
     if (diff.verdictChange !== undefined) {
         parts.push(`verdict ${diff.verdictChange.from}→${diff.verdictChange.to}`);
     }
-    return parts.length === 0 ? 'no significant change between runs' : parts.join(', ');
+    return 0 === parts.length ? 'no significant change between runs' : parts.join(', ');
 }
 /**
  * Compare two verification runs — the concrete answer to "what changed between run A and B". Flow

package/dist/runs/run-tools.js

@@ -38,7 +38,7 @@ export const RUN_TOOLS = [
         handler: async (deps, args) => {
             const store = new RunStore(deps.fs, deps.reticleRoot);
             // format:"diff" is a whole-history operation (two most-recent runs), not a single-run read.
-            if (asString(args['format']) === 'diff') {
+            if ('diff' === asString(args['format'])) {
                 const pair = await store.latestTwo();
                 if (pair === undefined) {
                     return {
@@ -75,7 +75,7 @@ export const RUN_TOOLS = [
                 }
                 run = latest;
             }
-            return asString(args['format']) === 'report' ? { report: renderRunReport(run) } : { run };
+            return 'report' === asString(args['format']) ? { report: renderRunReport(run) } : { run };
         },
     },
 ];

package/dist/runs/verification-sync.js

@@ -41,7 +41,7 @@ function assembleRun(deps, timed, projectId) {
  * unaffected. Returns the runId (for logging/tests); undefined if nothing was produced (empty suite).
  */
 export async function persistAndSyncVerificationRun(deps, timed, projectId) {
-    if (timed.length === 0)
+    if (0 === timed.length)
         return undefined;
     let run;
     try {
@@ -56,7 +56,7 @@ export async function persistAndSyncVerificationRun(deps, timed, projectId) {
     }
     // Per-project cloud: only push when THIS project has cloud attached AND its policy allows runs.
     const cloud = await resolveProjectCloud(deps.fs, deps.reticleRoot, homedir(), process.env);
-    if (cloud.config === null || !cloud.policy.runs)
+    if (null === cloud.config || !cloud.policy.runs)
         return run.runId; // not attached / runs disabled → local only
     const result = await syncRunToCloud(run, cloud.config, (url, init) => fetch(url, init));
     if (result.outcome !== SyncOutcome.SYNCED) {

package/dist/runs/verify-http.js

@@ -67,7 +67,7 @@ function toVerifyOptions(body) {
 }
 /** Constant-time token check. Empty expected token ⇒ open (localhost-only deployments). */
 export function tokenOk(provided, expected) {
-    if (expected.length === 0)
+    if (0 === expected.length)
         return true;
     if (provided === undefined)
         return false;

package/dist/runs/verify-server.js

@@ -91,7 +91,7 @@ export function startVerifyServer(opts, port) {
     return new Promise((resolve) => {
         server.listen(port, LOCALHOST, () => {
             const address = server.address();
-            const boundPort = typeof address === 'object' && address !== null ? address.port : port;
+            const boundPort = 'object' === typeof address && address !== null ? address.port : port;
             resolve({ server, port: boundPort });
         });
     });

package/dist/session/attachment-history.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Whether a session was attached for the whole window an agent is about to reason about.
+ *
+ * `reticle_sessions` answers "which tabs are connected RIGHT NOW", and **a tab that dropped for four
+ * seconds and came back looks identical to one that never dropped** (#117). That is the difference
+ * between a verdict you can trust and one that describes what you happened to see — the same problem
+ * `honesty.integrity` solves for a single action, applied to the session.
+ *
+ * Measured HERE rather than reported by the SDK. The browser transport does track
+ * `#disconnectedSince` (`transport.ts:95`), and reading it would need a wire change and a new thing
+ * for every SDK version to remember to send. The daemon already sees both halves — `remove()` when
+ * the socket drops, `add()` when it returns — so the gap is computable with no protocol change at
+ * all, and it cannot drift out of sync with what the daemon actually observed.
+ *
+ * The clock is injected, per the repo rule: this is arithmetic over timestamps, and a test that
+ * needs to wait four seconds to check a four-second gap is a test nobody runs.
+ */
+/** What an agent needs to know about the continuity of one session. */
+export interface Attachment {
+    /** How long THIS attachment has lasted. Resets on reconnect — it is not the session's lifetime. */
+    connectedSinceMs: number;
+    /** How many times this session dropped and came back. Zero means it never left. */
+    outages: number;
+    /** The most recent gap, when there has been one. */
+    lastOutage?: {
+        startedMs: number;
+        durationMs: number;
+    };
+}
+export declare class AttachmentHistory {
+    #private;
+    constructor(now?: () => number);
+    /** A session connected, or reconnected. A reconnect closes the open gap and counts an outage. */
+    attached(sessionId: string): void;
+    /** A session dropped. The gap stays open until it comes back, or the record is forgotten. */
+    detached(sessionId: string): void;
+    /** Drop a session's history. A long-lived daemon must not accumulate one record per tab forever. */
+    forget(sessionId: string): void;
+    /**
+     * The continuity of one session, or `undefined` when it has never been seen.
+     *
+     * Undefined rather than a zeroed record on purpose: `outages: 0` reads as "it never dropped", which
+     * is a confident claim about a session this has no knowledge of.
+     */
+    of(sessionId: string): Attachment | undefined;
+}

package/dist/session/attachment-history.js

@@ -0,0 +1,65 @@
+/**
+ * Whether a session was attached for the whole window an agent is about to reason about.
+ *
+ * `reticle_sessions` answers "which tabs are connected RIGHT NOW", and **a tab that dropped for four
+ * seconds and came back looks identical to one that never dropped** (#117). That is the difference
+ * between a verdict you can trust and one that describes what you happened to see — the same problem
+ * `honesty.integrity` solves for a single action, applied to the session.
+ *
+ * Measured HERE rather than reported by the SDK. The browser transport does track
+ * `#disconnectedSince` (`transport.ts:95`), and reading it would need a wire change and a new thing
+ * for every SDK version to remember to send. The daemon already sees both halves — `remove()` when
+ * the socket drops, `add()` when it returns — so the gap is computable with no protocol change at
+ * all, and it cannot drift out of sync with what the daemon actually observed.
+ *
+ * The clock is injected, per the repo rule: this is arithmetic over timestamps, and a test that
+ * needs to wait four seconds to check a four-second gap is a test nobody runs.
+ */
+export class AttachmentHistory {
+    #now;
+    #records = new Map();
+    constructor(now = Date.now) {
+        this.#now = now;
+    }
+    /** A session connected, or reconnected. A reconnect closes the open gap and counts an outage. */
+    attached(sessionId) {
+        const at = this.#now();
+        const prior = this.#records.get(sessionId);
+        if (prior?.detachedAt === undefined) {
+            this.#records.set(sessionId, { attachedAt: at, outages: prior?.outages ?? 0 });
+            return;
+        }
+        this.#records.set(sessionId, {
+            attachedAt: at,
+            outages: prior.outages + 1,
+            lastOutage: { startedMs: prior.detachedAt, durationMs: at - prior.detachedAt },
+        });
+    }
+    /** A session dropped. The gap stays open until it comes back, or the record is forgotten. */
+    detached(sessionId) {
+        const prior = this.#records.get(sessionId);
+        if (prior === undefined)
+            return;
+        this.#records.set(sessionId, { ...prior, detachedAt: this.#now() });
+    }
+    /** Drop a session's history. A long-lived daemon must not accumulate one record per tab forever. */
+    forget(sessionId) {
+        this.#records.delete(sessionId);
+    }
+    /**
+     * The continuity of one session, or `undefined` when it has never been seen.
+     *
+     * Undefined rather than a zeroed record on purpose: `outages: 0` reads as "it never dropped", which
+     * is a confident claim about a session this has no knowledge of.
+     */
+    of(sessionId) {
+        const record = this.#records.get(sessionId);
+        if (record === undefined)
+            return undefined;
+        return {
+            connectedSinceMs: this.#now() - record.attachedAt,
+            outages: record.outages,
+            ...(record.lastOutage === undefined ? {} : { lastOutage: record.lastOutage }),
+        };
+    }
+}

package/dist/session/command-timeout.d.ts

@@ -1,3 +1,4 @@
+import { AppRuntime } from '@reticlehq/core';
 /**
  * Turn a bare command timeout into something the reader can act on.
  *
@@ -21,9 +22,15 @@
  * The advice is ADDED, never substituted — the original fact still leads — and only for a runtime
  * that can actually suffer it, since misdirecting an Electron user costs them the same hour.
  */
-/** What the page told us about its shell, via PAGE_HEALTH. Undefined before the first report. */
-export type PageRuntime = 'electron' | 'tauri' | 'web';
-export interface TimeoutContext {
+/**
+ * What the page told us about its shell, via PAGE_HEALTH. Undefined before the first report.
+ *
+ * An alias of core's AppRuntime rather than a second list of the same three strings: the SDK reports
+ * this value, so it is a wire value, and two independent spellings of it is how one side gains a
+ * runtime the other silently refuses to recognise.
+ */
+export type PageRuntime = AppRuntime;
+interface TimeoutContext {
     url: string;
     /** The page's own last visibility report. */
     hidden: boolean;
@@ -33,3 +40,4 @@ export interface TimeoutContext {
     lastSeenMs?: number;
 }
 export declare function commandTimeoutMessage(name: string, timeoutMs: number, context: TimeoutContext): string;
+export {};