@reticlehq/server 2.14.0 → 3.2.0

package/dist/capsule/causal-summary.js

@@ -1,172 +0,0 @@
-import { EventType, PerfMetric, isDevToolingUrl } from '@reticlehq/core';
-import { routeOfEvent } from '../events/predicate-route.js';
-/**
- * THE INVARIANT: every field of this summary has a bounded size that does not depend on how much the
- * app did. A verdict travels in the same payload as its evidence, so an unbounded evidence field is
- * an unbounded chance that the verdict is the part a client truncates — and an agent that cannot read
- * the verdict has run the verification and got nothing, which is indistinguishable from not running
- * it. Measured: one click on a page with a registered TanStack Query store returned ~363KB, because
- * `capValue` bounded each diff and nothing bounded the COUNT of them.
- *
- * 20 keeps the signal that is actually read — the first paths to move, and the settle window over all
- * of them — while the full names of everything that changed stay one `reticle_state` call away.
- */
-export const MAX_SUMMARY_ENTRIES = 20;
-/** Trim one list to the cap and report the loss. Order is arrival order, so the head is the earliest. */
-function cap(list, name, elided) {
-    if (list.length <= MAX_SUMMARY_ENTRIES)
-        return list;
-    elided[name] = list.length - MAX_SUMMARY_ENTRIES;
-    return list.slice(0, MAX_SUMMARY_ENTRIES);
-}
-function pushUnique(list, value) {
-    if ('string' === typeof value && value.length > 0 && !list.includes(value))
-        list.push(value);
-}
-/** Keep a diff value bounded so the per-act summary never bloats: primitives capped to a short string. */
-const MAX_DIFF_LEN = 140;
-/** Truncate to at most MAX_DIFF_LEN chars total, including the ellipsis marker. */
-function truncate(text) {
-    return text.length > MAX_DIFF_LEN ? `${text.slice(0, MAX_DIFF_LEN - 1)}…` : text;
-}
-function capValue(value) {
-    if (value === undefined || null === value)
-        return value;
-    if ('string' === typeof value)
-        return truncate(value);
-    if ('number' === typeof value || 'boolean' === typeof value)
-        return value;
-    // Objects/arrays: a shallow, length-capped JSON repr (never a deep dump on the hot path).
-    try {
-        return truncate(JSON.stringify(value));
-    }
-    catch {
-        return '[unserializable]';
-    }
-}
-/**
- * The span over which the store was still moving — and therefore possibly self-inconsistent.
- *
- * Omitted for 0 or 1 diffs (no interval) and for a spread of 0 (everything landed in one tick), so a
- * store that updates atomically pays nothing and the field's PRESENCE is what carries the meaning.
- */
-function stateSettle(diffs) {
-    if (diffs.length < 2)
-        return {};
-    const times = diffs.map((d) => d.atMs);
-    const spread = Math.max(...times) - Math.min(...times);
-    return spread > 0 ? { stateSettleMs: spread } : {};
-}
-export function causalSummary(events, context = {}) {
-    let netTotal = 0;
-    let netErrors = 0;
-    let ignoredDevTooling = 0;
-    let headline;
-    let consoleErrors = 0;
-    const statePathsChanged = [];
-    const storageKeysChanged = [];
-    const stateDiffs = [];
-    const storageDiffs = [];
-    let route;
-    const signals = [];
-    let layoutShift;
-    let longTasks = 0;
-    for (const event of events) {
-        const data = event.data;
-        switch (event.type) {
-            case EventType.NET_REQUEST: {
-                if (isDevToolingUrl('string' === typeof data['url'] ? data['url'] : undefined)) {
-                    ignoredDevTooling += 1;
-                    break;
-                }
-                netTotal += 1;
-                const status = data['status'];
-                const failed = false === data['ok'] || ('number' === typeof status && status >= 400);
-                if (failed) {
-                    netErrors += 1;
-                    // Headline is the first failing request — the thing most worth the agent's eye.
-                    headline ??= `${String(data['method'])} ${String(data['url'])} ${String(status)}`;
-                }
-                break;
-            }
-            case EventType.CONSOLE_ERROR:
-            case EventType.ERROR_UNCAUGHT:
-                consoleErrors += 1;
-                break;
-            case EventType.STATE_CHANGE: {
-                pushUnique(statePathsChanged, data['name']);
-                // The subscribed-store observer emits { name, path, value, old } — `value` is the AFTER side
-                // (`new` is accepted too for any producer that uses it). Presence of either makes it a real
-                // before→after diff rather than a bare reading.
-                const path = 'string' === typeof data['path'] ? data['path'] : data['name'];
-                const hasAfter = 'value' in data || 'new' in data;
-                if ('string' === typeof path && path.length > 0 && ('old' in data || hasAfter)) {
-                    const after = 'value' in data ? data['value'] : data['new'];
-                    stateDiffs.push({
-                        path,
-                        from: capValue(data['old']),
-                        to: capValue(after),
-                        atMs: event.t,
-                    });
-                }
-                break;
-            }
-            case EventType.STORAGE_CHANGE: {
-                pushUnique(storageKeysChanged, data['key']);
-                const key = data['key'];
-                if ('string' === typeof key && key.length > 0) {
-                    storageDiffs.push({ key, from: capValue(data['old']), to: capValue(data['new']) });
-                }
-                break;
-            }
-            case EventType.ROUTE_CHANGE: {
-                // The ROUTER's path. Reporting the document pathname left `route: "/"` on every action of a
-                // hash-routed app — the same reading that made a route predicate unsatisfiable there, and an
-                // agent reasoning off this field would conclude the route never changed. See routeOfEvent.
-                const routed = routeOfEvent(data);
-                if (routed !== undefined)
-                    route = routed.routePath;
-                break;
-            }
-            case EventType.SIGNAL:
-                pushUnique(signals, data['name']);
-                break;
-            case EventType.PERF:
-                if (data['metric'] === PerfMetric.CLS && 'number' === typeof data['value']) {
-                    layoutShift = Math.max(layoutShift ?? 0, data['value']);
-                }
-                else if (data['metric'] === PerfMetric.LONGTASK) {
-                    longTasks += 1;
-                }
-                break;
-            default:
-                break;
-        }
-    }
-    const elided = {};
-    // `stateSettleMs` is computed over EVERY diff, before the cap: the interval is a fact about the
-    // store, and shrinking it because the evidence was trimmed would make the transient window read as
-    // narrower than it was — the one number here that must survive the trim intact.
-    const settle = stateSettle(stateDiffs);
-    return {
-        net: {
-            total: netTotal,
-            errors: netErrors,
-            ...(0 === ignoredDevTooling ? {} : { ignoredDevTooling }),
-            ...(headline === undefined ? {} : { headline }),
-        },
-        consoleErrors,
-        statePathsChanged: cap(statePathsChanged, 'statePathsChanged', elided),
-        storageKeysChanged: cap(storageKeysChanged, 'storageKeysChanged', elided),
-        stateDiffs: cap(stateDiffs, 'stateDiffs', elided),
-        ...settle,
-        storageDiffs: cap(storageDiffs, 'storageDiffs', elided),
-        ...(route === undefined ? {} : { route }),
-        signals: cap(signals, 'signals', elided),
-        ...(0 === Object.keys(elided).length ? {} : { elided }),
-        ...(layoutShift === undefined ? {} : { layoutShift }),
-        longTasks,
-        ...(true === context.stateUnwatched ? { stateUnwatched: true } : {}),
-        ...(true === context.truncated ? { truncated: true } : {}),
-    };
-}

package/dist/capsule/divergence.d.ts

@@ -1,35 +0,0 @@
-import { ConsequenceKind, type ReticleEvent } from '@reticlehq/core';
-/**
- * First-divergence — the brain of the divergence capsule (Tier 2). Given the chain the flow DECLARED
- * should happen (its mustHold, as ordered expected links) and what was OBSERVED, walk the declaration and
- * report the FIRST link where expected ≠ observed, values side by side. That single link is where the
- * fault lives — the agent fixes it without re-exploring. Pure; the acceptance bar is that for every
- * hidden-500 / hung-request fixture it names the correct link.
- */
-/**
- * The links a capsule can walk. Exactly core's ConsequenceKind — a link is a thing the app provably
- * DID, which is the same set signal/net/state names everywhere else. Spelled through the shared
- * constant so the two can never drift apart.
- */
-export type ExpectedLink = {
-    kind: typeof ConsequenceKind.SIGNAL;
-    name: string;
-} | {
-    kind: typeof ConsequenceKind.NET;
-    urlContains: string;
-    status?: number;
-} | {
-    kind: typeof ConsequenceKind.STATE;
-    name: string;
-};
-export interface Divergence {
-    /** The declared link that did not hold. */
-    expected: ExpectedLink;
-    /** Human description of what was observed instead (the closest attempt, or "nothing"). */
-    observed: string;
-}
-/**
- * Walk the declared chain in order; return the first link not satisfied by the observed events (with a
- * side-by-side of what happened instead), or null when the whole chain held.
- */
-export declare function firstDivergence(expected: readonly ExpectedLink[], observed: readonly ReticleEvent[], truncated?: boolean): Divergence | null;

package/dist/capsule/predicate-to-links.d.ts

@@ -1,8 +0,0 @@
-import type { Predicate } from '../events/predicate.js';
-import type { ExpectedLink } from './divergence.js';
-/**
- * Convert a mustHold predicate into the ordered ExpectedLinks the divergence capsule walks. Only the
- * consequence kinds (signal/net/state) become links — a presence check (element/text) can't diverge in a
- * dataflow sense. allOf/anyOf flatten in order; other kinds are skipped. Pure; feeds the capsule on red.
- */
-export declare function predicateToExpectedLinks(predicate: Predicate): ExpectedLink[];

package/dist/capsule/predicate-to-links.js

@@ -1,33 +0,0 @@
-import { ConsequenceKind, PredicateKind } from '@reticlehq/core';
-/**
- * Convert a mustHold predicate into the ordered ExpectedLinks the divergence capsule walks. Only the
- * consequence kinds (signal/net/state) become links — a presence check (element/text) can't diverge in a
- * dataflow sense. allOf/anyOf flatten in order; other kinds are skipped. Pure; feeds the capsule on red.
- */
-export function predicateToExpectedLinks(predicate) {
-    switch (predicate.kind) {
-        case PredicateKind.SIGNAL:
-            return predicate.name === undefined
-                ? []
-                : [{ kind: ConsequenceKind.SIGNAL, name: predicate.name }];
-        case PredicateKind.NET:
-            return predicate.urlContains === undefined
-                ? []
-                : [
-                    {
-                        kind: ConsequenceKind.NET,
-                        urlContains: predicate.urlContains,
-                        ...(predicate.status === undefined ? {} : { status: predicate.status }),
-                    },
-                ];
-        case PredicateKind.STATE: {
-            const name = predicate.store ?? predicate.path;
-            return [{ kind: ConsequenceKind.STATE, name }];
-        }
-        case PredicateKind.ALL_OF:
-        case PredicateKind.ANY_OF:
-            return predicate.predicates.flatMap(predicateToExpectedLinks);
-        default:
-            return [];
-    }
-}

package/dist/cli/adhoc-verdict.d.ts

@@ -1,58 +0,0 @@
-/**
- * A verdict from the CLI, against the daemon that is already running.
- *
- * THE DEAD END THIS REMOVES. The largest single cluster in the field feedback is not a defect in any
- * tool — it is that the tools were not loaded in the client, and there was no supported way to reach
- * a verdict from that state. The shape was always the same: the app is instrumented, the daemon is
- * healthy, `doctor` shows a live connected page, and the client (Codex, Cursor Cloud, Antigravity,
- * Gemini CLI, or a Claude Code session whose MCP link dropped) exposes no `reticle_*` tools, because
- * they load only at client startup. The documented CLI fallback then refused, because the daemon
- * already owned the port — precisely the state a successful install leaves you in. The other CLI
- * verdict paths need saved flows, and a first-install project has none. And our own guidance says
- * never to stop the daemon, because that kills the agent's MCP link.
- *
- * So an agent held a live, correctly-wired app and no path to a verdict short of a human restarting
- * their editor. Several reporters fell back to Playwright or to their own client and said honestly
- * that Reticle could not produce a verdict.
- *
- * HOW, AND WHY IT ADDS NO NEW SURFACE. One reporter found the answer themselves: they drove the full
- * tool surface over the daemon's HTTP/SSE transport with a hand-written client, and it worked. That
- * transport is not opt-in — `start()` calls `attachMcp` unconditionally, so every daemon has it. So
- * this asks the running daemon the same questions an agent would, over the same transport, using the
- * MCP client the SDK already ships. Nothing new is exposed and nothing is bound: the daemon keeps
- * the port, the agent keeps its link, and there is nothing to stop.
- *
- * It is deliberately the CLI equivalent of ONE `act_and_wait`: navigate, then assert. A CLI that
- * grew its own scripting language would be a second way to express a journey, competing with flows
- * and drifting from them.
- */
-/** What a one-shot verdict reports back to the caller. */
-export interface AdhocVerdict {
-    /** Process exit code: 0 only when the predicate was PROVED. */
-    code: number;
-    /** Lines to print, in order. */
-    lines: string[];
-}
-export interface AdhocVerdictOptions {
-    port: number;
-    /** Navigated to first when given; omitted to assert against wherever the session already is. */
-    url?: string;
-    /** The predicate, already parsed from the caller's JSON. */
-    predicate: unknown;
-    token?: string;
-    /** Injected so a test does not need a live daemon. */
-    connect?: (endpoint: URL) => Promise<ToolCaller>;
-}
-/** The narrow slice of an MCP client this needs — one call, then close. */
-export interface ToolCaller {
-    call(name: string, args: Record<string, unknown>): Promise<unknown>;
-    close(): Promise<void>;
-}
-/**
- * Navigate (optionally) and assert, against the daemon already on this port.
- *
- * Exit code 0 ONLY for `verified: "yes"`. `unknown` exits non-zero on purpose: it means Reticle could
- * not tell what happened, and a CI step that treats "could not tell" as success is the false green
- * this whole product exists to prevent.
- */
-export declare function runAdhocVerdict(options: AdhocVerdictOptions): Promise<AdhocVerdict>;

package/dist/cli/adhoc-verdict.js

@@ -1,115 +0,0 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { LOOPBACK_HOST, MCP_SSE_PATH } from '@reticlehq/core';
-import { TOKEN_QUERY_PARAM } from '../bridge/token-auth.js';
-import { ReticleTool } from '../tools/tool-names.js';
-/** `verified` is the only field that decides the exit code. Everything else is for the reader. */
-const PROVED = 'yes';
-function endpointFor(port, token) {
-    const url = new URL(`http://${LOOPBACK_HOST}:${String(port)}${MCP_SSE_PATH}`);
-    if (token !== undefined && token.length > 0)
-        url.searchParams.set(TOKEN_QUERY_PARAM, token);
-    return url;
-}
-async function connectOverSse(endpoint) {
-    const client = new Client({ name: 'reticle-cli', version: '1' }, { capabilities: {} });
-    await client.connect(new SSEClientTransport(endpoint));
-    return {
-        call: async (name, args) => await client.callTool({ name, arguments: args }),
-        close: async () => {
-            await client.close();
-        },
-    };
-}
-/** The verdict object an MCP tool result carries, or undefined when the shape is not one. */
-function verdictOf(result) {
-    const structured = result?.structuredContent;
-    if ('object' === typeof structured && null !== structured) {
-        return structured;
-    }
-    return undefined;
-}
-/**
- * The tool's own words when it refused, rather than the envelope carrying them.
- *
- * A refusal from these tools is the most useful text they produce — it names the cause and the next
- * action — and printing the MCP result object around it buries that in JSON escaping. The reader is
- * at a terminal; give them the sentence.
- */
-function refusalText(result) {
-    const r = result;
-    if (true !== r?.isError || !Array.isArray(r.content))
-        return undefined;
-    const text = r.content
-        .map((part) => part.text)
-        .filter((t) => 'string' === typeof t)
-        .join('\n');
-    if (0 === text.length)
-        return undefined;
-    // The tools answer with a JSON envelope whose `error` is the sentence; unwrap when it is one.
-    try {
-        const parsed = JSON.parse(text);
-        const inner = parsed?.error;
-        return 'string' === typeof inner ? inner : text;
-    }
-    catch {
-        return text;
-    }
-}
-/**
- * Navigate (optionally) and assert, against the daemon already on this port.
- *
- * Exit code 0 ONLY for `verified: "yes"`. `unknown` exits non-zero on purpose: it means Reticle could
- * not tell what happened, and a CI step that treats "could not tell" as success is the false green
- * this whole product exists to prevent.
- */
-export async function runAdhocVerdict(options) {
-    const connect = options.connect ?? connectOverSse;
-    let caller;
-    try {
-        caller = await connect(endpointFor(options.port, options.token));
-    }
-    catch (error) {
-        return {
-            code: 1,
-            lines: [
-                `could not reach the daemon on port ${String(options.port)}: ${error instanceof Error ? error.message : String(error)}`,
-                'It answers `reticle status`; if that works and this does not, the daemon is older than this CLI.',
-            ],
-        };
-    }
-    try {
-        if (options.url !== undefined && options.url.length > 0) {
-            await caller.call(ReticleTool.NAVIGATE, { url: options.url });
-        }
-        const result = await caller.call(ReticleTool.ASSERT, { predicate: options.predicate });
-        const refusal = refusalText(result);
-        if (refusal !== undefined) {
-            return { code: 1, lines: [`verified: unknown`, refusal] };
-        }
-        const verdict = verdictOf(result);
-        // Narrowed rather than stringified: these arrive as `unknown` off a record, and a verdict field
-        // that is accidentally an object must not print as `[object Object]` in the one line a reader
-        // acts on.
-        const asText = (value) => 'string' === typeof value ? value : undefined;
-        const verified = asText(verdict?.['verified']);
-        const reason = asText(verdict?.['verifiedReason']) ?? asText(verdict?.['failureReason']);
-        const lines = [
-            `verified: ${verified ?? 'unknown'}`,
-            ...(reason === undefined ? [] : [`reason: ${reason}`]),
-            JSON.stringify(verdict ?? result, null, 2),
-        ];
-        return { code: PROVED === verified ? 0 : 1, lines };
-    }
-    catch (error) {
-        return {
-            code: 1,
-            lines: [
-                `the verdict could not be taken: ${error instanceof Error ? error.message : String(error)}`,
-            ],
-        };
-    }
-    finally {
-        await caller.close().catch(() => undefined);
-    }
-}

package/dist/cli/cli-doctor.js

@@ -1,195 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { ReticleEnv } from '@reticlehq/core';
-import { readPid, reticleStateHome } from '../daemon/daemon.js';
-import { PortPresence, probePresence } from '../daemon/port-presence.js';
-import { probeDaemon } from '../mcp/mcp-proxy.js';
-import { fetchStatus } from './cli-launch.js';
-import { daemonLine } from './doctor-daemon-line.js';
-import { projectWiringLine } from './doctor-project-line.js';
-import { hasProjectConnectedBefore } from '../session/connection-memory.js';
-import { sessionsLine } from './doctor-sessions-line.js';
-import { captureLookup, describeForeignHolder, findPortHolder } from './port-holder.js';
-import { chromiumHint, probeChromium } from './chromium-hint.js';
-import { SERVER_VERSION } from '../version/server-version.js';
-import { CONTRACT_FINGERPRINT } from '@reticlehq/core';
-import { diagnoseDesktop, isDesktopProject, diagnoseWebCsp } from '@reticlehq/init';
-import { RETICLE_CONFIG_BASENAME, diagnosePortMismatch, readProjectId, readProjectPort, } from './cli-port.js';
-import { DoctorRow, doctorRow } from './doctor-rows.js';
-import { attachState, describeAttachState } from '../mcp/attach-memory.js';
-import { findOccupiedSiblings, siblingListenerNote } from './sibling-ports.js';
-import { daemonsServingProjectElsewhere, resolveDaemonForProject, splitBrainNote, wrongDaemonNote, } from '../daemon/daemon-resolve.js';
-import { isAlive } from '../daemon/daemon.js';
-/**
- * `reticle doctor` — collapse the ~6 independent first-run failure modes into one command. Checks the
- * Chromium install (the #1 silent failure), whether a daemon is up on the resolved bridge port, and
- * reminds the user which port the app must dial. Human-readable to stdout (not the JSON log).
- */
-/** Narrow the `/status` payload to the two fields the daemon line reads. */
-function asIdentity(payload) {
-    if (typeof payload !== 'object' || null === payload)
-        return {};
-    const record = payload;
-    const pick = (key) => {
-        const value = record[key];
-        return 'string' === typeof value && value.length > 0 ? value : undefined;
-    };
-    // Keys are OMITTED rather than set to undefined: `exactOptionalPropertyTypes` is on, and the
-    // distinction is the point — "this daemon did not say" is not the same as "this daemon said none".
-    const version = pick('version');
-    const contract = pick('contract');
-    return {
-        ...(version === undefined ? {} : { version }),
-        ...(contract === undefined ? {} : { contract }),
-    };
-}
-/**
- * One project, two daemons — asked from whichever end this command is standing on.
- *
- * Shares the rule with `reticle status` rather than restating it: the empty daemon can see that the
- * app connected somewhere else, the daemon holding the app can only see that this project owns
- * another one, and a second copy of either half would be a second opinion waiting to disagree.
- */
-function splitBrainLine(port, projectId) {
-    const home = reticleStateHome();
-    const elsewhere = splitBrainNote(port, daemonsServingProjectElsewhere(projectId, port, home, isAlive, (other) => hasProjectConnectedBefore(home, other, projectId)));
-    return elsewhere ?? wrongDaemonNote(port, resolveDaemonForProject(projectId, home, isAlive));
-}
-export async function handleDoctor(port) {
-    const line = (s) => {
-        process.stdout.write(`${s}\n`);
-    };
-    line('reticle doctor');
-    line(doctorRow(DoctorRow.NODE, process.version));
-    // Filled in only on the daemon branch — there is nothing to ask when no daemon is answering, and
-    // the branches below already say so in their own terms.
-    let sessions;
-    line(doctorRow(DoctorRow.CHROMIUM, chromiumHint(await probeChromium())));
-    // Ask the PORT, not just the pid file. "not running on :4400" has been printed about a port that
-    // was demonstrably occupied, which sends the reader to start a daemon that cannot bind. The three
-    // states are genuinely different problems with different fixes, so doctor names which one it is.
-    const pid = readPid(port);
-    const presence = await probePresence(port, { tcpOpen: probeDaemon, status: fetchStatus });
-    if (presence === PortPresence.DAEMON) {
-        // Name WHICH daemon. The /status payload already carries version + contract, and doctor was
-        // throwing both away — while skew is invisible everywhere else, reaching the agent as a bare
-        // -32000 naming no version. This is the command a human runs at exactly that moment.
-        const payload = await fetchStatus(port);
-        const status = asIdentity(payload);
-        const built = daemonLine(port, pid, status, {
-            version: SERVER_VERSION,
-            contract: CONTRACT_FINGERPRINT,
-        });
-        line(built.text);
-        if (built.skew !== undefined)
-            line(doctorRow(DoctorRow.VERSION, `✗ ${built.skew}`));
-        // The same payload already carries whether anything has CONNECTED, and doctor was reading
-        // `version` off it and dropping the rest. Without this the command is silent on the one step the
-        // funnel stalls on: wired correctly, daemon up, and no page has ever dialled in.
-        sessions = sessionsLine('object' === typeof payload && null !== payload ? payload : {});
-    }
-    else if (presence === PortPresence.FOREIGN) {
-        // Name the holder when we can. `doctor` exists for exactly this moment, and "another process"
-        // leaves the reader to find a shell command themselves — the obvious one being the `lsof -ti`
-        // pipeline that also kills the agent's own MCP proxy.
-        // `pid` is what our pid file recorded for this port. When it matches the process actually
-        // holding it, this is our OWN daemon wedged, not a stranger — and the fix is different.
-        line(doctorRow(DoctorRow.DAEMON, `✗ ${describeForeignHolder(port, findPortHolder(port, captureLookup), pid)}`));
-    }
-    else {
-        line(doctorRow(DoctorRow.DAEMON, `✗ not running on :${port} — your agent runs \`reticle mcp\` (or \`reticle serve\`)`));
-    }
-    if (sessions !== undefined)
-        line(sessions.text);
-    line(doctorRow(DoctorRow.BRIDGE_PORT, `${port}  (your app must dial THIS port, not your dev-server port)`));
-    const projectPort = readProjectPort(process.cwd());
-    const mismatch = diagnosePortMismatch(port, projectPort);
-    if (mismatch !== undefined)
-        line(doctorRow(DoctorRow.PORT_CHECK, `✗ ${mismatch}`));
-    const projectId = readProjectId(process.cwd());
-    // The hop between the agent and this daemon, stated as its own row rather than inferred from the
-    // ones above it. `sessions` says the BROWSER reached the daemon; nothing said whether the AGENT
-    // did, and those two are exactly the pair a user cannot tell apart when one of them is broken.
-    const attach = attachState(reticleStateHome(), port);
-    const attachAction = describeAttachState(attach);
-    // A SPLIT outranks the attach record, and this is the one place it can. Both records are per PORT,
-    // so on a machine whose daemons have split in two the attach row reports "nothing has ever
-    // attached here" and sends the reader to re-register a server that is registered and running —
-    // the confident wrong answer for a link that is not missing but misaimed.
-    const split = splitBrainLine(port, projectId);
-    line(doctorRow(DoctorRow.AGENT_LINK, split !== undefined
-        ? `✗ ${split}`
-        : attachAction === undefined
-            ? "✓ an MCP client has listed and called Reticle's tools on this port"
-            : `✗ ${attachAction}`));
-    // Remaining half of #261. The SDK dialling a port we are not on is invisible as a refused inbound,
-    // but a listener on a well-known Reticle port is visible. Report the observation; do not conclude
-    // it is the daemon this app wants — somebody else's daemon looks the same from here.
-    const occupiedSiblings = await findOccupiedSiblings(port, probeDaemon);
-    const siblingNote = siblingListenerNote(port, occupiedSiblings);
-    if (siblingNote !== undefined)
-        line(doctorRow(DoctorRow.SIBLING, siblingNote));
-    // The check this checklist was missing: is the APP wired, not just the tools. Everything above can
-    // be green in a project that has never been through `init`, and that combination is precisely the
-    // one `doctor` gets run to explain.
-    line(projectWiringLine({
-        projectId,
-        previouslyConnected: hasProjectConnectedBefore(reticleStateHome(), port, projectId),
-        // An absent config and a corrupt one both read back as "no id"; only this tells them apart,
-        // and telling somebody a file is missing while it sits in front of them is its own dead end.
-        configPresent: existsSync(join(process.cwd(), RETICLE_CONFIG_BASENAME)),
-    }));
-    // Where to LOOK when something is wrong. The daemon has always written a structured log here and
-    // nothing ever said so, so the first move in every investigation was reading source instead of
-    // reading the log. `RETICLE_TRACE=1` turns the same stream into a per-stage trace — see
-    // docs/debugging.md.
-    line(doctorRow(DoctorRow.DAEMON_LOG, join(reticleStateHome(), `daemon-${String(port)}.log`)));
-    line(doctorRow(DoctorRow.TRACING, `${ReticleEnv.TRACE}=1 on the daemon for per-stage timings in that log`));
-    // Below the checklist rather than inline: it is a paragraph, and a paragraph in the middle of a
-    // column of one-line checks buries the checks under it. This is the daemon's own no-session
-    // diagnosis, the same one an agent gets from an empty reticle_sessions.
-    if (sessions?.why !== undefined) {
-        line('');
-        line('  nothing has connected. What the daemon can tell from here:');
-        line(`    ${sessions.why}`);
-    }
-    // Desktop setup RCA. Every one of these fails SILENTLY — a Tauri app with the default CSP runs
-    // perfectly and never connects; an Electron app without the preload line reports zero network
-    // activity forever, which reads as "makes no backend calls" rather than "you are blind to them".
-    const readProjectFile = (relative) => {
-        try {
-            return readFileSync(join(process.cwd(), relative), 'utf8');
-        }
-        catch {
-            return undefined;
-        }
-    };
-    // The web sibling of the desktop findings below: a `connect-src` that excludes the bridge makes
-    // the browser refuse the WebSocket and report it in ITS console only, so every check above passes
-    // at an app that can never connect. Named, with the exact text to paste.
-    const csp = diagnoseWebCsp(readProjectFile, port);
-    if (csp.length > 0) {
-        line('');
-        line(`  csp          ✗ a Content-Security-Policy is blocking the Reticle bridge:`);
-        for (const finding of csp) {
-            line(`                 ${finding.file}`);
-            line(`                   ${finding.problem}`);
-            line(`                   fix: ${finding.fix}`);
-        }
-    }
-    const desktop = diagnoseDesktop(readProjectFile, port);
-    if (desktop.length > 0) {
-        line('');
-        line(doctorRow(DoctorRow.DESKTOP, `✗ ${String(desktop.length)} issue(s) — the app will look fine and not work:`));
-        for (const finding of desktop) {
-            line(`                 ${finding.file}`);
-            line(`                   ${finding.problem}`);
-            line(`                   fix: ${finding.fix}`);
-        }
-    }
-    else if (isDesktopProject(readProjectFile)) {
-        // Say so explicitly. Silence would read as "not checked", which is the same ambiguity the
-        // findings above exist to remove.
-        line(doctorRow(DoctorRow.DESKTOP, '✓ desktop wiring looks right'));
-    }
-}