@reticlehq/server 2.14.0 → 3.2.0

package/dist/update/updater.d.ts

@@ -1,54 +0,0 @@
-/** Which way the installed version moved. A rollback means a release hurt someone enough to retreat. */
-declare const VersionChangeDirection: {
-    readonly UPDATE: "update";
-    readonly ROLLBACK: "rollback";
-};
-type VersionChangeDirection = (typeof VersionChangeDirection)[keyof typeof VersionChangeDirection];
-/**
- * Report a completed version move. Never throws — an install that worked must still be reported done.
- *
- * Exported so the emit path can be exercised directly: `applyUpdate`/`rollback` both run a real npm
- * install and then `process.exit`, so there is no way to reach this through them in a test without
- * mocking the package manager and the process itself.
- */
-export declare function reportVersionChange(from: string, to: string, direction: VersionChangeDirection): Promise<void>;
-/** How this reticle process was launched — determines which npm strategy to use for updates. */
-declare const ExecutionKind: {
-    /** Launched via `npx @reticlehq/server` — npm re-resolves the package on restart. */
-    readonly NPX: "npx";
-    /** Installed globally via `npm install -g`. */
-    readonly GLOBAL: "global";
-    /** Installed as a local project dependency. */
-    readonly LOCAL: "local";
-};
-type ExecutionKind = (typeof ExecutionKind)[keyof typeof ExecutionKind];
-/**
- * Classify a launch from the entry script path. Pure so it's testable. Global installs ALSO live under
- * a `node_modules`, but under the npm global prefix — a `lib/node_modules` (unix: /usr/local, Homebrew,
- * nvm) or AppData\npm (Windows). Match those FIRST, otherwise a global install is misread as local and
- * `apply_update` npm-installs into the user's own project (polluting their package.json).
- */
-export declare function classifyExecutionKind(script: string): ExecutionKind;
-interface NpmInstall {
-    args: string[];
-    cwd?: string;
-}
-/**
- * The npm argv (and optional cwd) that installs `version` for the given launch kind, or null for
- * npx (which re-resolves the package on the next restart — no install needed). Installs
- * `@reticlehq/server` — the package that actually carries the `reticle` bin — never
- * `@reticlehq/core`, which is schema-only and has no executable.
- */
-export declare function installArgs(version: string, kind: ExecutionKind, localRoot: string | null): NpmInstall | null;
-/**
- * Install targetVersion using the appropriate strategy for the detected execution kind,
- * then exit so Claude Code restarts with the new binary. Saves the current version
- * first so rollback can restore it.
- */
-export declare function applyUpdate(targetVersion: string): Promise<void>;
-/**
- * Reinstall the previousVersion saved in the update manifest using the appropriate
- * strategy, then exit so Claude Code restarts with the restored binary.
- */
-export declare function rollback(): Promise<void>;
-export {};

package/dist/update/updater.js

@@ -1,190 +0,0 @@
-import { execFile } from 'node:child_process';
-import { NodePlatform } from '../platform.js';
-import { existsSync } from 'node:fs';
-import { platform } from 'node:os';
-import { dirname, join } from 'node:path';
-import { loadManifest, saveManifest } from './update-checker.js';
-import { RETICLE_NPM_PACKAGE, SERVER_VERSION } from '../version/server-version.js';
-import { log } from '../log.js';
-import { TelemetryEventKind } from '@reticlehq/core/telemetry';
-import { getTelemetry } from '../telemetry/telemetry.js';
-import { wasNudged } from './nudge-credit.js';
-/** Which way the installed version moved. A rollback means a release hurt someone enough to retreat. */
-const VersionChangeDirection = {
-    UPDATE: 'update',
-    ROLLBACK: 'rollback',
-};
-/**
- * Report a completed version move. Never throws — an install that worked must still be reported done.
- *
- * Exported so the emit path can be exercised directly: `applyUpdate`/`rollback` both run a real npm
- * install and then `process.exit`, so there is no way to reach this through them in a test without
- * mocking the package manager and the process itself.
- */
-export async function reportVersionChange(from, to, direction) {
-    try {
-        const nudged = wasNudged(to);
-        await getTelemetry().emit(TelemetryEventKind.VERSION_CHANGED, {
-            // Only when true: an absent flag reads as "we do not know", which is honest for a machine that
-            // updated from a shell script or a package bump with no agent involved at all.
-            versionChange: { from, to, direction, ...(nudged ? { nudged } : {}) },
-        });
-    }
-    catch {
-        /* best-effort, like every other send */
-    }
-}
-const NPM_BIN = NodePlatform.WINDOWS === platform() ? 'npm.cmd' : 'npm';
-const NPM_TIMEOUT_MS = 120_000;
-/** How this reticle process was launched — determines which npm strategy to use for updates. */
-const ExecutionKind = {
-    /** Launched via `npx @reticlehq/server` — npm re-resolves the package on restart. */
-    NPX: 'npx',
-    /** Installed globally via `npm install -g`. */
-    GLOBAL: 'global',
-    /** Installed as a local project dependency. */
-    LOCAL: 'local',
-};
-/**
- * Infer how reticle was launched from process.argv[1].
- *
- * npm's npx cache stores packages under a path containing `_npx`, which is the
- * most reliable cross-platform signal. Local installs always live inside a
- * `node_modules` directory. Everything else is treated as a global install.
- */
-function detectExecutionKind() {
-    return classifyExecutionKind(process.argv[1] ?? '');
-}
-/**
- * Classify a launch from the entry script path. Pure so it's testable. Global installs ALSO live under
- * a `node_modules`, but under the npm global prefix — a `lib/node_modules` (unix: /usr/local, Homebrew,
- * nvm) or AppData\npm (Windows). Match those FIRST, otherwise a global install is misread as local and
- * `apply_update` npm-installs into the user's own project (polluting their package.json).
- */
-export function classifyExecutionKind(script) {
-    if (script.includes('/_npx/') || script.includes('\\_npx\\'))
-        return ExecutionKind.NPX;
-    const globalSignals = [
-        '/lib/node_modules/',
-        '\\npm\\node_modules\\',
-        '/.nvm/',
-        '/homebrew/',
-        '/usr/local/',
-        '/usr/lib/',
-    ];
-    if (globalSignals.some((s) => script.includes(s)))
-        return ExecutionKind.GLOBAL;
-    if (script.includes('/node_modules/') || script.includes('\\node_modules\\')) {
-        return ExecutionKind.LOCAL;
-    }
-    return ExecutionKind.GLOBAL;
-}
-/** Walk up from cwd until a directory containing package.json is found. */
-function findLocalProjectRoot() {
-    let dir = process.cwd();
-    for (;;) {
-        if (existsSync(join(dir, 'package.json')))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return null; // reached filesystem root
-        dir = parent;
-    }
-}
-function runNpm(args, opts = {}) {
-    return new Promise((resolve, reject) => {
-        execFile(NPM_BIN, args, { timeout: NPM_TIMEOUT_MS, ...(opts.cwd !== undefined ? { cwd: opts.cwd } : {}) }, (err, _stdout, stderr) => {
-            if (err !== null) {
-                reject(new Error(`npm ${args.join(' ')} failed: ${stderr !== '' ? stderr : err.message}`));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-/**
- * The npm argv (and optional cwd) that installs `version` for the given launch kind, or null for
- * npx (which re-resolves the package on the next restart — no install needed). Installs
- * `@reticlehq/server` — the package that actually carries the `reticle` bin — never
- * `@reticlehq/core`, which is schema-only and has no executable.
- */
-export function installArgs(version, kind, localRoot) {
-    if (kind === ExecutionKind.NPX)
-        return null;
-    const pkg = `${RETICLE_NPM_PACKAGE}@${version}`;
-    if (kind === ExecutionKind.LOCAL && localRoot !== null) {
-        return { args: ['install', pkg], cwd: localRoot };
-    }
-    return { args: ['install', '-g', pkg] };
-}
-async function installVersion(version, kind) {
-    const localRoot = kind === ExecutionKind.LOCAL ? findLocalProjectRoot() : null;
-    const plan = installArgs(version, kind, localRoot);
-    if (null === plan) {
-        // npx re-resolves the package from npm on the next Claude Code restart — no npm
-        // install needed. The restart itself is what triggers the update.
-        log('reticle_update_npx_strategy', {
-            note: 'Running via npx — exiting so Claude Code restarts and npx fetches the new version',
-        });
-        return;
-    }
-    if (kind === ExecutionKind.LOCAL && null === localRoot) {
-        // Could not find a project root — fell back to a global install as a safe default.
-        log('reticle_update_local_no_root', { fallback: 'global' });
-    }
-    await runNpm(plan.args, plan.cwd !== undefined ? { cwd: plan.cwd } : {});
-}
-async function installVersionRollback(version, kind) {
-    if (kind === ExecutionKind.NPX) {
-        log('reticle_rollback_npx_strategy', {
-            note: 'Running via npx — update your .mcp.json args to pin the version you want to restore',
-        });
-        return;
-    }
-    await installVersion(version, kind);
-}
-/**
- * Install targetVersion using the appropriate strategy for the detected execution kind,
- * then exit so Claude Code restarts with the new binary. Saves the current version
- * first so rollback can restore it.
- */
-export async function applyUpdate(targetVersion) {
-    const manifest = loadManifest();
-    if (manifest !== null) {
-        saveManifest({ ...manifest, previousVersion: manifest.currentVersion });
-    }
-    const kind = detectExecutionKind();
-    log('reticle_update_applying', { version: targetVersion, executionKind: kind });
-    await installVersion(targetVersion, kind);
-    log('reticle_update_applied', { version: targetVersion, executionKind: kind });
-    // Emitted AFTER the install succeeded, so the metric counts versions that actually landed rather
-    // than attempts. Awaited, unlike every other send in the product: `process.exit(0)` on the next
-    // line would kill an in-flight fire-and-forget POST, and this event is rare enough that the wait
-    // costs nothing. A failed send still cannot block the exit — `emit` swallows its own errors.
-    await reportVersionChange(SERVER_VERSION, targetVersion, VersionChangeDirection.UPDATE);
-    process.exit(0);
-}
-/**
- * Reinstall the previousVersion saved in the update manifest using the appropriate
- * strategy, then exit so Claude Code restarts with the restored binary.
- */
-export async function rollback() {
-    const manifest = loadManifest();
-    if (null === manifest || manifest.previousVersion === undefined) {
-        throw new Error('No previous version available for rollback');
-    }
-    const prev = manifest.previousVersion;
-    const kind = detectExecutionKind();
-    log('reticle_rollback_applying', { version: prev, executionKind: kind });
-    await installVersionRollback(prev, kind);
-    log('reticle_rollback_applied', { version: prev, executionKind: kind });
-    // A rollback is a release-quality alarm — someone shipped something that broke a real user badly
-    // enough for them to go backwards. Worth knowing about within the hour, not at the next retro.
-    await reportVersionChange(SERVER_VERSION, prev, VersionChangeDirection.ROLLBACK);
-    // For npx, exiting would let the next restart re-resolve @latest — rolling FORWARD, the opposite
-    // of rollback. installVersionRollback already told the user to pin the version in.mcp.json, so
-    // stay running rather than trigger that. Other kinds installed the old version and must restart.
-    if (kind !== ExecutionKind.NPX)
-        process.exit(0);
-}

package/dist/version/peer-announce.js

@@ -1,32 +0,0 @@
-/**
- * How another Reticle PROCESS announces itself to the daemon.
- *
- * The SDK announces in HELLO and the CLI reads /status, but the MCP server an agent spawns had no
- * announcement at all — and it is the piece the user actually hits: `npx @reticlehq/server mcp`
- * resolves from a cache, so an agent can be running a months-old MCP package against a current
- * daemon with nothing anywhere saying so.
- *
- * It rides the SSE connect the proxy already makes, as two query params. Query params rather than a
- * new message because the connection happens before any protocol exchange, and because an older
- * proxy that sends neither is handled correctly by describeSkew (absent contract + differing version
- * = a build that predates the field).
- */
-import { CONTRACT_FINGERPRINT } from '@reticlehq/core';
-import { SERVER_VERSION } from './server-version.js';
-import { daemonFix, describeSkew, SkewPair } from './version-skew.js';
-import { noteVersionSkew } from './version-nudge.js';
-export const PEER_VERSION_PARAM = 'peerVersion';
-export const PEER_CONTRACT_PARAM = 'peerContract';
-/** Compare an attaching agent process against this daemon, and queue the nudge when they disagree. */
-export function noteAgentPeer(version, contract) {
-    const skew = describeSkew({
-        what: "the agent's MCP server",
-        version: version ?? undefined,
-        contract: contract ?? undefined,
-        // Inverted from cli-launch: here THIS process is the daemon and the peer is the agent's
-        // MCP server, so the daemon is the newer half whenever the announcing agent is behind.
-        fix: daemonFix(SERVER_VERSION, version ?? undefined),
-    }, { version: SERVER_VERSION, contract: CONTRACT_FINGERPRINT });
-    if (skew !== undefined)
-        noteVersionSkew(SkewPair.DAEMON, skew);
-}

package/dist/version/sdk-fix.js

@@ -1,127 +0,0 @@
-/**
- * The project-aware SDK remedy for version skew (#618).
- *
- * `sdkFix` in version-skew.ts is the no-project fallback: it names `@reticlehq/browser` and npm,
- * because those answers are never actively wrong. When a project directory IS in hand, name the
- * packages actually in package.json and the manager the lockfile implies.
- *
- * Does not import `init/`. The library path must never reach the installer
- * (`library-path-boundary.test.ts`); `reticleDepsOf` lives in `update/` for that reason, and the
- * lockfile → manager map is the same evidence `detectPackageManager` reads, kept here so a HELLO
- * does not load the install plan.
- */
-import { join } from 'node:path';
-import { readFileSync } from 'node:fs';
-import { reticleDepsOf } from '../update/reticle-deps.js';
-/** Lockfile / marker → manager, same evidence `init/detect.ts` uses. */
-export const PackageManagerName = {
-    PNPM: 'pnpm',
-    YARN: 'yarn',
-    BUN: 'bun',
-    NPM: 'npm',
-};
-/** Same package a Vue/Nuxt install gets — never the React kit. */
-const FRAMEWORK_NEUTRAL_SDK = '@reticlehq/browser';
-const PACKAGE_JSON = 'package.json';
-const NODE_MODULES = 'node_modules';
-const LOCKFILE_NAMES = ['pnpm-lock.yaml', 'yarn.lock', 'bun.lockb', 'bun.lock'];
-/** Markers each manager leaves inside `node_modules` — stronger than an uncommitted lockfile. */
-const NODE_MODULES_MARKERS = [
-    ['.modules.yaml', PackageManagerName.PNPM],
-    ['.yarn-state.yml', PackageManagerName.YARN],
-    ['.package-lock.json', PackageManagerName.NPM],
-];
-const INSTALL_FLAGS = {
-    [PackageManagerName.PNPM]: ['add', '-D'],
-    [PackageManagerName.YARN]: ['add', '-D'],
-    [PackageManagerName.BUN]: ['add', '-d'],
-    [PackageManagerName.NPM]: ['i', '-D'],
-};
-function packagesFor(ctx) {
-    if (ctx?.packages !== undefined && 0 !== ctx.packages.length)
-        return ctx.packages;
-    return [FRAMEWORK_NEUTRAL_SDK];
-}
-function managerOf(lockfiles, nodeModulesMarkers) {
-    if (lockfiles.has('pnpm-lock.yaml'))
-        return PackageManagerName.PNPM;
-    if (lockfiles.has('yarn.lock'))
-        return PackageManagerName.YARN;
-    if (lockfiles.has('bun.lockb') || lockfiles.has('bun.lock'))
-        return PackageManagerName.BUN;
-    for (const [name, pm] of NODE_MODULES_MARKERS) {
-        if (nodeModulesMarkers.has(name))
-            return pm;
-    }
-    return PackageManagerName.NPM;
-}
-function installLine(pm, pkgs) {
-    return `${pm} ${[...INSTALL_FLAGS[pm], ...pkgs].join(' ')}`;
-}
-function restartClause() {
-    return ('or run `reticle update`, then restart their dev server so the page reloads with it. The ' +
-        'restart is not optional: a bundler keeps serving the pre-bundled copy it already has, so an ' +
-        'upgrade can look applied — matching versions in `npm ls` — while the page runs the old module.');
-}
-/**
- * The one sentence telling the human how to bring the page's SDK in line with this daemon.
- *
- * No context → the framework-neutral sensor and npm, never the React kit. Packages from
- * package.json win when present. When the project has none of ours yet, the sensor is named
- * rather than `@reticlehq/react` — that is the Vue/Nuxt failure.
- */
-export function resolveSdkFix(daemonVersion, ctx) {
-    const pm = ctx?.packageManager ?? PackageManagerName.NPM;
-    const pinned = packagesFor(ctx).map((name) => `${name}@${daemonVersion}`);
-    return `Tell the human to install the matching SDK (\`${installLine(pm, pinned)}\`) ${restartClause()}`;
-}
-/**
- * Read the context `resolveSdkFix` needs off a parsed manifest and the lockfiles/markers present.
- *
- * Undefined when there is no manifest to interpret — the caller then uses the no-project fallback.
- * Pure: no filesystem.
- */
-export function sdkFixContextOf(pkgJson, lockfiles, nodeModulesMarkers = new Set()) {
-    if ('object' !== typeof pkgJson || null === pkgJson)
-        return undefined;
-    return {
-        packages: reticleDepsOf(pkgJson),
-        packageManager: managerOf(lockfiles, nodeModulesMarkers),
-    };
-}
-/** Reads a file, or undefined if it is not there / not readable. */
-function readTextFile(path) {
-    try {
-        return readFileSync(path, 'utf8');
-    }
-    catch {
-        return undefined;
-    }
-}
-function parseJson(raw) {
-    if (raw === undefined)
-        return undefined;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
-function present(directory, names, read, extra = '') {
-    const found = new Set();
-    for (const name of names) {
-        if (read(join(directory, extra, name)) !== undefined)
-            found.add(name);
-    }
-    return found;
-}
-/**
- * The remedy for the project in `directory`, or the no-project fallback when it cannot be read.
- *
- * `read` is injected so the decision is testable without a filesystem; the daemon uses the default.
- */
-export function sdkFixForDirectory(daemonVersion, directory, read = readTextFile) {
-    const ctx = sdkFixContextOf(parseJson(read(join(directory, PACKAGE_JSON))), present(directory, LOCKFILE_NAMES, read), present(directory, NODE_MODULES_MARKERS.map(([name]) => name), read, NODE_MODULES));
-    return resolveSdkFix(daemonVersion, ctx);
-}

package/dist/version/server-version.js

@@ -1,13 +0,0 @@
-import { createRequire } from 'node:module';
-// NOTE: a RUNTIME path, not an import — `tsc` does not check it and a file move will not rewrite
-// it. Two levels up because this file sits in `version/`: from `src/version/` and from
-// `dist/version/` alike, `../../package.json` is the package manifest. Moving this file again means
-// changing this line by hand; nothing else will tell you.
-const _pkg = createRequire(import.meta.url)('../../package.json');
-/** The Reticle server version, read from package.json at startup. */
-export const SERVER_VERSION = _pkg.version;
-/**
- * The published npm package that carries the `reticle` bin — read from package.json so it can never
- * drift. Self-update installs THIS (never `@reticlehq/core`, which is schema-only and has no bin).
- */
-export const RETICLE_NPM_PACKAGE = _pkg.name;

package/dist/version/version-nudge.js

@@ -1,61 +0,0 @@
-/**
- * Getting skew in front of the AGENT, on whatever tool it happens to be calling.
- *
- * Every check built before this reported into a place nobody looks: SDK skew landed in
- * `reticle_sessions.versionSkew`, which an agent driving a flow never calls, and daemon skew went to
- * a CLI log line no agent reads. So an agent could work an entire session against a mismatched pair,
- * watch tools behave oddly, and never be told the one fact that explains it.
- *
- * This is the delivery channel — the same one the update nudge uses, for the same reason: an
- * out-of-date install is worth mentioning whatever the agent is doing. It rides out on the next tool
- * result, then goes quiet until the skew CHANGES. Told, not nagged: a banner on every call is one an
- * agent learns to skip, and it would cost those tokens on every call for the rest of the session.
- */
-import { EnvelopeKey } from '../tools/tool-kit.js';
-/** Pending per pair — the SDK and the daemon are different upgrades and each is worth saying once. */
-const pending = new Map();
-/** The last message delivered for each pair, so the same skew is never repeated. */
-const delivered = new Map();
-/**
- * Record a skew for delivery. Re-arms only when the message DIFFERS from the one already delivered:
- * a second tab on a third version is news; the same tab reconnecting is not.
- */
-export function noteVersionSkew(pair, action) {
-    if (delivered.get(pair) === action)
-        return;
-    pending.set(pair, action);
-}
-/** The next undelivered skew, once. */
-export function takeVersionSkew() {
-    for (const [pair, action] of pending) {
-        pending.delete(pair);
-        delivered.set(pair, action);
-        return { pair, action };
-    }
-    return undefined;
-}
-/**
- * Splice pending skew onto a tool-error payload.
- *
- * Successful calls already carry `version_skew` via `runTool`. Thrown errors never reached that
- * splice — they became a Playwright string plus `FEEDBACK_ASK`, so a caller debugs a CDP timeout
- * instead of the mismatched pair that caused it (#618). When the error was unrecognized, the
- * feedback ask is replaced: the skew IS the next move, and inviting a bug report about it is
- * backwards. A recognized recovery is kept; the envelope still rides along.
- */
-export function takeVersionSkewOnto(payload) {
-    const skew = takeVersionSkew();
-    if (skew === undefined)
-        return payload;
-    const { feedback, ...rest } = payload;
-    return {
-        ...rest,
-        ...(feedback !== undefined && rest.recovery === undefined ? { recovery: skew.action } : {}),
-        [EnvelopeKey.VERSION_SKEW]: skew,
-    };
-}
-/** Tests only — drop the module state so each case starts clean. */
-export function resetVersionSkew() {
-    pending.clear();
-    delivered.clear();
-}

package/dist/version/version-skew.d.ts

@@ -1,93 +0,0 @@
-/**
- * Does this peer speak our contract? The daemon is the only thing that asks.
- *
- * Reticle is three separately-installed pieces — the SDK in the page, this daemon, and the MCP
- * server the agent spawns — upgraded independently and therefore drifting constantly. Each pair
- * fails the same silent way: `protocolVersion` still matches, the connection succeeds, and only
- * BEHAVIOUR disagrees. A user hit exactly that with a 2.2.1 SDK against a 2.3.0 daemon and saw a
- * bare `-32000` with nothing on either side naming a version.
- *
- * Two decisions shape this file.
- *
- * The daemon is the SINGLE judge. Every piece announces itself at a connect it already makes — the
- * SDK in HELLO, the CLI and the MCP server over /status — and comparing happens here, once. Three
- * independent pairwise checks would be three copies to keep in step and three separate complaints
- * about one upgrade; a table in one place can say what is actually true: which pieces disagree, and
- * which one is behind.
- *
- * The signal is the CONTRACT FINGERPRINT, not the version. Version equality is wrong in both
- * directions: it fires on 2.4.0-vs-2.4.1 where nothing changed — so every patch release makes every
- * un-upgraded app cry wolf, and the warning becomes noise — and it cannot fire at all for two
- * different BUILDS of one version number, which is exactly what a stale daemon and a cached npx
- * install are. The fingerprint is derived from core's wire vocabulary, so it moves when a name on
- * the wire changes and stays put when internals do. Versions still ride along, because they are what
- * a human acts on.
- */
-/** Which pair disagreed. Named so the nudge can report each independently. */
-export declare const SkewPair: {
-    /** The SDK in the page vs this daemon. */
-    readonly SDK: "sdk";
-    /** Another Reticle process — a CLI, or the MCP server an agent spawned — vs this daemon. */
-    readonly DAEMON: "daemon";
-};
-export type SkewPair = (typeof SkewPair)[keyof typeof SkewPair];
-/** What a piece says about itself when it connects. */
-export interface PeerIdentity {
-    /** Human-readable subject for the message: "the page", "the daemon on this port". */
-    what: string;
-    /** Package version, when the peer supplied one. Undefined on a hand-wired connect. */
-    version: string | undefined;
-    /** Contract fingerprint. Undefined means the peer predates the field — itself evidence of age. */
-    contract: string | undefined;
-    /** What the human runs to bring this piece into line. */
-    fix: string;
-}
-/** Everything a build knows about itself. */
-interface SelfIdentity {
-    version: string;
-    contract: string;
-}
-/**
- * The one sentence to tell the agent, or undefined when the pair agrees.
- *
- * Silent when the fingerprints MATCH, whatever the versions say — that is the point: a patch bump
- * that changed no wire name is not skew, and warning about it is how a real warning gets ignored.
- *
- * A peer with no fingerprint is treated as skewed ONLY when its version also differs from ours: the
- * field is absent exactly on builds that predate it, so "no fingerprint AND a different version" is
- * a build provably older than this daemon. With neither signal there is nothing to go on, and
- * inventing a warning would be as dishonest as staying silent about a real one.
- */
-export declare function describeSkew(peer: PeerIdentity, self: SelfIdentity): string | undefined;
-/**
- * The fix line for a page whose SDK disagrees with this daemon, with no project to read.
- *
- * Names the framework-neutral sensor and plain npm, because those are the answers that are never
- * actively wrong. When a project directory IS available, `resolveSdkFix` / `sdkFixForDirectory`
- * in sdk-fix.ts read the real packages and package manager — this used to hardcode
- * `@reticlehq/react` and told Vue projects to install a React package (#618).
- */
-export declare function sdkFix(daemonVersion: string): string;
-/**
- * The fix line for another Reticle process that disagrees with the daemon it attached to.
- *
- * Branches on DIRECTION, which the old unconditional `reticle stop` did not (#618). Restarting the
- * daemon converges the pair only when the daemon is the OLDER half. When the daemon is newer — the
- * common case, because the MCP registration is deliberately unpinned and so resolves fresh while a
- * long-lived daemon does not — `reticle stop` starts another newer daemon and leaves the same two
- * contract hashes with the roles unchanged. Nothing the agent can do converges that, so say so and
- * ask for the one thing that does, exactly as the SDK branch already does when the page is stale.
- *
- * Both versions are named by ROLE, not by which side is calling: this is read from both ends — a
- * CLI judging the daemon it attached to, and the daemon judging an agent that announced itself —
- * and the advice depends on which piece is behind, not on who noticed.
- */
-export declare function daemonFix(daemonVersion: string | undefined, agentVersion: string | undefined): string;
-/** True when `error` is Playwright's closed-target class — not proof the tab is gone. */
-export declare function isPlaywrightClosedError(error: unknown): boolean;
-/**
- * Replace a closed-target throw with the session's skew sentence when we already know the pair is
- * mismatched. Undefined when there is no skew to name, or the throw is something else.
- */
-export declare function rewriteClosedAsSkew(error: unknown, skew: string | undefined): Error | undefined;
-export {};