@reticlehq/server 2.3.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reticlehq/server",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Reticle bridge + MCP server. Hosts the browser WS endpoint and exposes MCP tools to the coding agent.",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "@modelcontextprotocol/sdk": "^1.13.0",
     "ws": "^8.18.0",
     "zod": "^3.24.1",
-    "@reticlehq/core": "2.3.0"
+    "@reticlehq/core": "2.5.0"
   },
   "devDependencies": {
     "@types/pngjs": "^6.0.5",
@@ -45,7 +45,9 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE-ENTERPRISE"
+    "LICENSE-ENTERPRISE",
+    "SKILL.md",
+    "docs"
   ],
   "keywords": [
     "mcp",
@@ -54,7 +56,7 @@
     "cli"
   ],
   "reticle": {
-    "changelog": "Smart MCP proxy with auto-start daemon, auto-update, and rollback support. Agents can call reticle_version_info, reticle_apply_update, and reticle_rollback.",
+    "changelog": "An MCP server that stays up when the daemon dies, one tool surface instead of five profiles (`RETICLE_TOOL_PROFILE` retired for `RETICLE_ADVERTISE_ALL_TOOLS`), and tools that refuse instead of answering wrongly.",
     "breakingChanges": []
   },
   "publishConfig": {
@@ -68,6 +70,7 @@
     "dev": "tsc -b --watch",
     "typecheck": "tsc -b",
     "lint": "eslint src",
-    "test:unit": "vitest run src --passWithNoTests"
+    "test:unit": "vitest run src --passWithNoTests",
+    "test:coverage": "vitest run src --passWithNoTests --coverage.enabled --coverage.provider=v8 --coverage.reporter=text-summary --coverage.include='src/**/*.ts' --coverage.exclude='src/**/*.test.ts'"
   }
 }

package/dist/cli-launch.js

@@ -1,112 +0,0 @@
-import * as http from 'node:http';
-import { spawn } from 'node:child_process';
-import { isOpaqueOrigin, LOOPBACK_HOST, STATUS_PATH } from '@reticlehq/core';
-/**
- * Reduce the daemon's /status JSON to the compact view `reticle status` prints. Pure: narrows the
- * untrusted wire payload (never `any`) and tolerates a missing/partial body so a malformed response
- * degrades to "running, 0 sessions" instead of throwing.
- */
-export function summarizeStatus(payload) {
-    if (typeof payload !== 'object' || payload === null)
-        return { sessionCount: 0, sessions: [] };
-    const obj = payload;
-    const raw = Array.isArray(obj['sessions']) ? obj['sessions'] : [];
-    const sessions = raw
-        .map((s) => {
-        if (typeof s !== 'object' || s === null)
-            return null;
-        const r = s;
-        const sessionId = typeof r['sessionId'] === 'string' ? r['sessionId'] : '';
-        if (sessionId === '')
-            return null;
-        return {
-            sessionId,
-            url: typeof r['url'] === 'string' ? r['url'] : '',
-            throttled: r['throttled'] === true,
-            stale: r['stale'] === true,
-            pendingMarks: typeof r['pendingMarks'] === 'number' ? r['pendingMarks'] : 0,
-        };
-    })
-        .filter((s) => s !== null);
-    const sessionCount = typeof obj['sessionCount'] === 'number' ? obj['sessionCount'] : sessions.length;
-    return { sessionCount, sessions };
-}
-/** How long the daemon /status probe waits before giving up — a local loopback call is near-instant. */
-const STATUS_PROBE_TIMEOUT_MS = 1000;
-/** GET the daemon's /status JSON. Resolves to the parsed body, or undefined on any failure. */
-export function fetchStatus(port) {
-    return new Promise((resolve) => {
-        const req = http.get({ host: LOOPBACK_HOST, port, path: STATUS_PATH, timeout: STATUS_PROBE_TIMEOUT_MS }, (res) => {
-            let body = '';
-            res.setEncoding('utf8');
-            res.on('data', (chunk) => (body += chunk));
-            res.on('end', () => {
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch {
-                    resolve(undefined);
-                }
-            });
-        });
-        req.on('error', () => resolve(undefined));
-        req.on('timeout', () => {
-            req.destroy();
-            resolve(undefined);
-        });
-    });
-}
-function sameOrigin(a, b) {
-    try {
-        const origin = new URL(a).origin;
-        // Two opaque origins (desktop webviews, file:// docs) BOTH stringify to "null", so comparing them
-        // would call every desktop app the same app and reuse the wrong session. Never match on opaque.
-        if (isOpaqueOrigin(origin))
-            return false;
-        return origin === new URL(b).origin;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Decide what `reticle open [url]` does, given the currently-connected tabs. Pure.
- * - no url + a tab connected → reuse it (the app is already open; don't spawn a duplicate).
- * - no url + nothing connected → ask for one.
- * - url + a tab already on that origin → reuse it (idempotent — re-running never piles up tabs).
- * - url + no matching tab → open it.
- */
-export function decideOpen(sessions, url) {
-    if (url === undefined) {
-        const first = sessions[0];
-        return first !== undefined ? { action: 'reuse', url: first.url } : { action: 'need-url' };
-    }
-    const match = sessions.find((s) => s.url === url || sameOrigin(s.url, url));
-    return match !== undefined ? { action: 'reuse', url: match.url } : { action: 'open', url };
-}
-/**
- * Percent-encode the cmd.exe metacharacters that `start` re-parses so a URL can't break out into
- * command execution on Windows (`?next=x&calc` → command chaining). `%` is left untouched so an
- * already-encoded URL isn't double-encoded; the browser decodes the escapes back to the real URL.
- */
-function encodeForWindowsStart(url) {
-    return url.replace(/[&^|<>()"'!]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`);
-}
-/** The OS command that opens a URL in the default browser, per platform. Pure — unit-tested. */
-export function openCommand(url, platform) {
-    if (platform === 'darwin')
-        return { cmd: 'open', args: [url] };
-    if (platform === 'win32') {
-        return { cmd: 'cmd', args: ['/c', 'start', '', encodeForWindowsStart(url)] };
-    }
-    return { cmd: 'xdg-open', args: [url] };
-}
-/** Launch the default browser at `url` (detached). The spawn is injected so tests stay hermetic. */
-export function openInBrowser(url, platform = process.platform, run = defaultRun) {
-    const { cmd, args } = openCommand(url, platform);
-    run(cmd, args);
-}
-function defaultRun(cmd, args) {
-    const child = spawn(cmd, args, { detached: true, stdio: 'ignore' });
-    child.unref();
-}

package/dist/cli-parse.d.ts

@@ -1,140 +0,0 @@
-/**
- * Pure CLI argument parsing — the command/flag grammar, the CliResult union, and parseCliArgs.
- * Split out of cli.ts (which keeps the side-effecting handlers + dispatch) to stay under the
- * file-size cap and keep the parser pure + unit-testable. Re-exported from cli.ts so existing
- * imports are unchanged.
- */
-export declare const CLI_USAGE = "usage:\n  reticle init  [--dry-run] [--port N] [--no-mcp] [--no-install]  (wire Reticle into the project in this directory)\n  reticle serve [--port N] [--drive <url>] [--headed] [--http] [--http-port N] [--http-token T]\n  reticle stop  [--port N] [--quiet]\n  reticle status [--port N]\n  reticle doctor [--port N]                            (diagnose setup: Chromium, daemon, port \u2014 one command)\n  reticle open  [url] [--port N]                        (show the app: reuse the connected tab, else open one)\n  reticle verify <url> [--headed] [--timeout N] [--storage-state <file>]  (one-shot: drive the URL, verify saved flows, exit 0=pass)\n  reticle affected [--since <ref>] [file...]           (which saved flows must re-verify for the changed files)\n  reticle gate [--since <ref>] [file...]               (exit non-zero unless passing artifacts cover the affected flows)\n  reticle watch [url]                                  (on save, report which saved flows must re-verify)\n  reticle drive <url> [--headed]                       (foreground mode \u2014 for debugging)\n  reticle mcp   [--port N] [--drive <url>] [--headed]  (MCP stdio proxy \u2014 auto-starts daemon if needed)\n  reticle update                                       (install the latest server version and restart)\n  reticle rollback                                     (restore the previous server version and restart)\n  reticle license                                      (show enterprise license status: active | eval | missing)\n  reticle telemetry [status|enable|disable]            (anonymous usage metrics \u2014 status shows what's sent + the policy)\n  reticle feedback [--rating 1-5] [--bug] \"message\"    (tell us what worked and what didn't \u2014 prints exactly what it sends)\n  reticle identify --context company|side_project|open_source|learning [--company N] [--email E] [--forget]\n                                                       (OPT-IN: tell us who you are, e.g. for support or an enterprise trial)\n\nCloud (link this project to Reticle Cloud \u2014 runs/flows recorded on the dashboard):\n  reticle login --email <e> [--code <c>] [--org <n>]   (sign in: mails a code, then exchanges it)\n  reticle link  [--project <name|id>]                  (bind this repo: mints a scoped key, writes .reticle/cloud.json)\n  reticle whoami                                        (who am I signed in as, and is this repo attached?)\n  reticle project <ls|create <name>>                   (list or create cloud projects)\n  reticle config [--runs on|off] [--memory on|off] [--flows on|off] [--verify local|server]\n  reticle push                                          (send local run artifacts to the dashboard)\n  reticle runs | regression | share <runId>            (read cloud state; regression exits 3 if any flow broke)";
-export declare const COMPANY_FLAG = "--company";
-export declare const EMAIL_FLAG = "--email";
-export declare const CONTEXT_FLAG = "--context";
-export declare const FORGET_FLAG = "--forget";
-/** `reticle feedback --rating 4 "the words"` — the human half of the channel. */
-export declare const RATING_FLAG = "--rating";
-export declare const BUG_FLAG = "--bug";
-/** The `reticle telemetry` sub-actions. Bare `reticle telemetry` means `status`. */
-export declare const TelemetryAction: {
-    readonly STATUS: "status";
-    readonly ENABLE: "enable";
-    readonly DISABLE: "disable";
-};
-export type TelemetryAction = (typeof TelemetryAction)[keyof typeof TelemetryAction];
-export declare const DAEMON_INNER_COMMAND = "_daemon";
-/**
- * Every subcommand a person can type, as one closed vocabulary. Telemetry reports which one ran, and
- * this is what keeps that property low-cardinality and non-identifying: an argument we do not
- * recognize reports as `unknown` rather than being echoed, so a typo — which may be a path, a URL, or
- * a flow name — can never reach the wire just because someone misspelled `status`.
- *
- * Lives here rather than in the telemetry module because this is where the command names are already
- * defined; a second list somewhere else would drift the first time a command is added.
- */
-export declare const UNKNOWN_COMMAND = "unknown";
-/** The subcommand name if we recognize it, else `unknown`. Bare `reticle` reports `help`. */
-export declare function knownCommand(arg: string | undefined): string;
-export declare const HEADED_FLAG = "--headed";
-export declare const PORT_FLAG = "--port";
-export declare const DRIVE_FLAG = "--drive";
-export declare const HTTP_FLAG = "--http";
-export declare const HTTP_PORT_FLAG = "--http-port";
-export declare const HTTP_TOKEN_FLAG = "--http-token";
-export type CliResult = {
-    kind: 'init';
-    port: number | undefined;
-    mcp: boolean;
-    dryRun: boolean;
-    install: boolean;
-} | {
-    kind: 'serve';
-    port: number;
-    driveUrl?: string;
-    headless: boolean;
-    http: boolean;
-    httpPort?: number;
-    httpToken?: string;
-} | {
-    kind: 'stop';
-    port: number;
-    quiet: boolean;
-} | {
-    kind: 'status';
-    port: number;
-} | {
-    kind: 'license';
-} | {
-    kind: 'telemetry';
-    action: TelemetryAction;
-} | {
-    kind: 'feedback';
-    text: string;
-    rating?: number;
-    bug: boolean;
-} | {
-    kind: 'identify';
-    context?: string;
-    company?: string;
-    email?: string;
-    forget: boolean;
-} | {
-    kind: 'version';
-} | {
-    kind: 'help';
-} | {
-    kind: 'doctor';
-    port: number;
-} | {
-    kind: 'open';
-    port: number;
-    url?: string;
-} | {
-    kind: '_daemon';
-    port: number;
-    driveUrl?: string;
-    headless: boolean;
-    http: boolean;
-    httpPort?: number;
-    httpToken?: string;
-} | {
-    kind: 'drive';
-    port: number;
-    driveUrl: string;
-    headless: boolean;
-} | {
-    kind: 'verify';
-    url: string;
-    headless: boolean;
-    timeoutMs?: number;
-    storageState?: string;
-} | {
-    kind: 'affected';
-    files: string[];
-    since?: string;
-} | {
-    kind: 'hunt';
-    dir: string;
-} | {
-    kind: 'capsules';
-} | {
-    kind: 'gate';
-    files: string[];
-    since?: string;
-} | {
-    kind: 'watch';
-    url?: string;
-} | {
-    kind: 'update';
-} | {
-    kind: 'rollback';
-} | {
-    kind: 'mcp';
-    port: number;
-    driveUrl?: string;
-    headless: boolean;
-    http: boolean;
-    httpPort?: number;
-    httpToken?: string;
-} | {
-    kind: 'error';
-    message: string;
-};
-export declare function parseCliArgs(argv: string[], defaultPort: number): CliResult;

package/dist/daemon-resilience.d.ts

@@ -1,22 +0,0 @@
-/**
- * Process-level resilience for the long-running daemon. The daemon serves many agents at once, so a
- * single stray error must not take the whole fleet down:
- *
- * - unhandledRejection (a fire-and-forget promise nobody awaited — the common case in async WS/pool
- * code) → LOG and keep running. One agent's async slip-up can't crash the daemon for everyone.
- * - uncaughtException (a synchronous throw escaped all try/catch) → the process state is undefined
- * per Node's guidance, so LOG a clear reason and exit cleanly; the next `reticle mcp` respawns a fresh
- * daemon, which beats crashing silently or limping along corrupt.
- */
-export interface ProcessLike {
-    on(event: string, listener: (arg: unknown) => void): unknown;
-}
-type LogFn = (event: string, data: Record<string, unknown>) => void;
-/** The two ways a failure reaches the top of the process. Named so the analytics can tell them apart. */
-export declare const CrashKind: {
-    readonly UNHANDLED_REJECTION: "unhandled_rejection";
-    readonly UNCAUGHT_EXCEPTION: "uncaught_exception";
-};
-export type CrashKind = (typeof CrashKind)[keyof typeof CrashKind];
-export declare function installDaemonResilience(proc: ProcessLike, log: LogFn, onFatal: () => void): void;
-export {};

package/dist/daemon-resilience.js

@@ -1,85 +0,0 @@
-/**
- * Process-level resilience for the long-running daemon. The daemon serves many agents at once, so a
- * single stray error must not take the whole fleet down:
- *
- * - unhandledRejection (a fire-and-forget promise nobody awaited — the common case in async WS/pool
- * code) → LOG and keep running. One agent's async slip-up can't crash the daemon for everyone.
- * - uncaughtException (a synchronous throw escaped all try/catch) → the process state is undefined
- * per Node's guidance, so LOG a clear reason and exit cleanly; the next `reticle mcp` respawns a fresh
- * daemon, which beats crashing silently or limping along corrupt.
- */
-import { TelemetryActor, TelemetryEventKind } from '@reticlehq/core';
-import { errorSkeleton, errorTypeOf, fingerprintCrash, MAX_REPORTED_FRAMES, reticleFrames, } from './telemetry/error-fingerprint.js';
-import { getSessionMetrics } from './telemetry/session-metrics.js';
-import { machineSnapshot } from './telemetry/machine-snapshot.js';
-import { getTelemetry } from './telemetry/telemetry.js';
-function describe(value) {
-    return value instanceof Error ? value.message : String(value);
-}
-/** The two ways a failure reaches the top of the process. Named so the analytics can tell them apart. */
-export const CrashKind = {
-    UNHANDLED_REJECTION: 'unhandled_rejection',
-    UNCAUGHT_EXCEPTION: 'uncaught_exception',
-};
-/**
- * Report a crash with enough detail to actually diagnose it.
- *
- * This is the only place in the product that learns about a crash at all. An uncaught exception in a
- * long-running daemon takes down every agent attached to it, and the only other record is a line in a
- * local log nobody sends us.
- *
- * The first version sent a hash and nothing else, which made crashes rankable and undiagnosable — you
- * could see that forty machines hit `a3f2c1d8e9b0` and had no way to learn what that was. So it now
- * carries the four things an RCA needs: WHERE (our own frames, with function names and line numbers),
- * WHAT (the message with every variable part stripped), WHEN (the tool in flight), and WHY-ish (the
- * agent's approach run before it). All of it is our code and our vocabulary; the user's stack frames,
- * their paths, and the contents of their message are removed before any of it is built.
- *
- * Best-effort and wrapped: reporting a crash must never be the reason a crash gets worse.
- */
-function reportCrash(kind, value) {
-    try {
-        const errorType = errorTypeOf(value);
-        const stack = value instanceof Error ? (value.stack ?? '') : '';
-        const message = describe(value);
-        const { breadcrumb, inFlight } = getSessionMetrics().trail;
-        const machine = machineSnapshot();
-        void getTelemetry().emit(TelemetryEventKind.RUNTIME_CRASHED, {
-            // A crash is ALWAYS reached through something the agent asked for — the daemon does nothing on
-            // its own — so attributing it to the agent is accurate rather than a guess.
-            actor: TelemetryActor.AGENT,
-            crash: {
-                kind,
-                errorType,
-                fingerprint: fingerprintCrash(errorType, stack, message),
-                // The skeleton, not the message: every quoted string, path, URL, id and number is replaced
-                // by `*` first. This is what makes the fingerprint mean something to a human reading a chart.
-                message: errorSkeleton(message).slice(0, 300),
-                // Our own frames, our own published code. The file, the line, and the function — which is the
-                // whole of "where did it break". Frames from the user's app never survive this.
-                frames: reticleFrames(stack).slice(0, MAX_REPORTED_FRAMES),
-                ...(inFlight !== undefined ? { tool: inFlight } : {}),
-                ...(breadcrumb.length > 0 ? { breadcrumb } : {}),
-                // Crashes cluster hard by runtime version and architecture, and we were recording neither.
-                nodeVersion: process.versions.node,
-                arch: process.arch,
-                // "Out of memory" and "our bug" look identical in a stack trace. This is what tells them apart.
-                ...(machine !== undefined ? { machine } : {}),
-            },
-        });
-    }
-    catch {
-        /* a crash report must never be the reason a crash gets worse */
-    }
-}
-export function installDaemonResilience(proc, log, onFatal) {
-    proc.on('unhandledRejection', (reason) => {
-        log('reticle_daemon_unhandled_rejection', { reason: describe(reason) });
-        reportCrash(CrashKind.UNHANDLED_REJECTION, reason);
-    });
-    proc.on('uncaughtException', (err) => {
-        log('reticle_daemon_uncaught_exception', { error: describe(err) });
-        reportCrash(CrashKind.UNCAUGHT_EXCEPTION, err);
-        onFatal();
-    });
-}

package/dist/mcp-proxy.d.ts

@@ -1,35 +0,0 @@
-/** One parsed Server-Sent-Events frame: the event name (defaulted to "message") and its data. */
-export interface SseFrame {
-    event: string;
-    data: string;
-}
-/**
- * Incremental SSE frame parser for the MCP front door.
- *
- * A single SSE field can split across TCP reads (`da` in one chunk, `ta: {...}` in the next), and a
- * server may send CRLF or bare CR line endings — so the framing is stateful and edge-case-prone, yet it
- * carried every MCP message the agent sends and was only ever exercised end-to-end. Pulled out of the
- * socket handler as a pure, chunk-fed parser so those boundaries are unit-testable: feed raw chunks,
- * get back each complete frame (a blank line terminates a frame; `event:` names it, `data:` lines
- * accumulate newline-joined; `id:`/`retry:`/comments are ignored — not needed for the bridge).
- */
-export declare class SseFrameParser {
-    #private;
-    push(chunk: string): SseFrame[];
-}
-/**
- * Returns true if something is already listening on the reticle port.
- * Uses a plain TCP probe so we don't create a side-effectful SSE session
- * inside the daemon just to check reachability.
- */
-export declare function probeDaemon(port: number): Promise<boolean>;
-/** Poll until the daemon's HTTP port accepts connections or the deadline is reached. */
-export declare function waitForDaemon(port: number): Promise<void>;
-export declare function buildSessionUrl(rawData: string, port: number): string;
-/**
- * Bridge stdio ↔ SSE: connects to the running daemon's MCP endpoint and forwards
- * Claude Code's stdin/stdout JSON-RPC through it. Never resolves — runs until
- * stdin closes or the SSE stream ends (at which point the process exits so
- * Claude Code restarts the proxy fresh).
- */
-export declare function startMcpProxy(port: number): Promise<never>;

package/dist/mcp-proxy.js

@@ -1,190 +0,0 @@
-import * as http from 'node:http';
-import * as net from 'node:net';
-import { LOOPBACK_HOST, MCP_SSE_PATH } from '@reticlehq/core';
-import { log } from './log.js';
-const DEFAULT_DAEMON_READY_TIMEOUT_MS = 10_000;
-/**
- * How long to wait for the spawned daemon's port to accept connections before giving up. The default
- * suits a normal machine; a slow CI/VM (heavy headless-browser launch) can raise it via the
- * RETICLE_DAEMON_READY_TIMEOUT_MS env var. Invalid/absent values fall back to the default.
- */
-const envDaemonReadyTimeoutMs = Number(process.env['RETICLE_DAEMON_READY_TIMEOUT_MS']);
-const DAEMON_READY_TIMEOUT_MS = Number.isFinite(envDaemonReadyTimeoutMs) && envDaemonReadyTimeoutMs > 0
-    ? envDaemonReadyTimeoutMs
-    : DEFAULT_DAEMON_READY_TIMEOUT_MS;
-const DAEMON_POLL_INTERVAL_MS = 100;
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Incremental SSE frame parser for the MCP front door.
- *
- * A single SSE field can split across TCP reads (`da` in one chunk, `ta: {...}` in the next), and a
- * server may send CRLF or bare CR line endings — so the framing is stateful and edge-case-prone, yet it
- * carried every MCP message the agent sends and was only ever exercised end-to-end. Pulled out of the
- * socket handler as a pure, chunk-fed parser so those boundaries are unit-testable: feed raw chunks,
- * get back each complete frame (a blank line terminates a frame; `event:` names it, `data:` lines
- * accumulate newline-joined; `id:`/`retry:`/comments are ignored — not needed for the bridge).
- */
-export class SseFrameParser {
-    #buffer = '';
-    #event = '';
-    #data = '';
-    push(chunk) {
-        this.#buffer += chunk;
-        // Normalise CRLF/CR so the splitter only handles \n, then hold the trailing partial line for the
-        // next chunk (it may complete later).
-        const normalised = this.#buffer.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-        const lines = normalised.split('\n');
-        this.#buffer = lines.pop() ?? '';
-        const frames = [];
-        for (const line of lines) {
-            if (line === '') {
-                if (this.#data !== '') {
-                    frames.push({ event: this.#event !== '' ? this.#event : 'message', data: this.#data });
-                }
-                this.#event = '';
-                this.#data = '';
-            }
-            else if (line.startsWith('event:')) {
-                this.#event = line.slice(6).trim();
-            }
-            else if (line.startsWith('data:')) {
-                const val = line.slice(5).trim();
-                this.#data = this.#data !== '' ? `${this.#data}\n${val}` : val;
-            }
-        }
-        return frames;
-    }
-}
-/**
- * Returns true if something is already listening on the reticle port.
- * Uses a plain TCP probe so we don't create a side-effectful SSE session
- * inside the daemon just to check reachability.
- */
-export function probeDaemon(port) {
-    return new Promise((resolve) => {
-        const socket = new net.Socket();
-        socket.setTimeout(500);
-        socket.on('connect', () => {
-            socket.destroy();
-            resolve(true);
-        });
-        socket.on('error', () => resolve(false));
-        socket.on('timeout', () => {
-            socket.destroy();
-            resolve(false);
-        });
-        socket.connect(port, LOOPBACK_HOST);
-    });
-}
-/** Poll until the daemon's HTTP port accepts connections or the deadline is reached. */
-export async function waitForDaemon(port) {
-    const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        const reachable = await probeDaemon(port);
-        if (reachable)
-            return;
-        await delay(DAEMON_POLL_INTERVAL_MS);
-    }
-    throw new Error(`reticle daemon did not become ready on port ${port} within ${DAEMON_READY_TIMEOUT_MS}ms`);
-}
-function postToSession(url, body) {
-    return new Promise((resolve) => {
-        const parsed = new URL(url);
-        const bodyBuf = Buffer.from(body, 'utf8');
-        const options = {
-            host: parsed.hostname,
-            port: parsed.port !== '' ? parseInt(parsed.port, 10) : 80,
-            path: `${parsed.pathname}${parsed.search}`,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Content-Length': bodyBuf.byteLength,
-            },
-        };
-        const req = http.request(options, (res) => {
-            const status = res.statusCode ?? 0;
-            if (status < 200 || status >= 300) {
-                // A non-2xx from the daemon MCP endpoint used to be swallowed, hanging the JSON-RPC call
-                // client-side with no diagnostic. Surface it (the forward is still fire-and-forget).
-                log('reticle_mcp_proxy_post_non2xx', { status, path: options.path });
-            }
-            res.resume(); // drain so the socket is reused
-            resolve();
-        });
-        req.on('error', (err) => {
-            log('reticle_mcp_proxy_post_error', { error: err.message });
-            resolve();
-        });
-        req.write(bodyBuf);
-        req.end();
-    });
-}
-export function buildSessionUrl(rawData, port) {
-    return rawData.startsWith('/') ? `http://${LOOPBACK_HOST}:${port}${rawData}` : rawData;
-}
-/**
- * Bridge stdio ↔ SSE: connects to the running daemon's MCP endpoint and forwards
- * Claude Code's stdin/stdout JSON-RPC through it. Never resolves — runs until
- * stdin closes or the SSE stream ends (at which point the process exits so
- * Claude Code restarts the proxy fresh).
- */
-export function startMcpProxy(port) {
-    return new Promise((_resolve, reject) => {
-        let postUrl = null;
-        const stdinQueue = [];
-        // ── SSE reader ──────────────────────────────────────────────────────────
-        const req = http.get({ host: LOOPBACK_HOST, port, path: MCP_SSE_PATH }, (res) => {
-            res.setEncoding('utf8');
-            const sse = new SseFrameParser();
-            res.on('data', (chunk) => {
-                for (const frame of sse.push(chunk))
-                    onSseEvent(frame.event, frame.data, port);
-            });
-            res.on('end', () => {
-                log('reticle_mcp_proxy_sse_ended', { port });
-                process.exit(0);
-            });
-            res.on('error', (err) => {
-                log('reticle_mcp_proxy_sse_error', { error: err.message });
-                process.exit(1);
-            });
-        });
-        req.on('error', (err) => reject(err));
-        function onSseEvent(event, data, p) {
-            if (event === 'endpoint') {
-                const url = buildSessionUrl(data, p);
-                postUrl = url;
-                // Flush messages that arrived before the session URL was known
-                for (const queued of stdinQueue.splice(0)) {
-                    void postToSession(url, queued);
-                }
-                return;
-            }
-            if (event === 'message') {
-                process.stdout.write(`${data}\n`);
-            }
-        }
-        // ── stdin reader ─────────────────────────────────────────────────────────
-        process.stdin.setEncoding('utf8');
-        let stdinBuffer = '';
-        process.stdin.on('data', (chunk) => {
-            stdinBuffer += chunk;
-            const lines = stdinBuffer.split('\n');
-            stdinBuffer = lines.pop() ?? '';
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (trimmed === '')
-                    continue;
-                if (postUrl === null) {
-                    stdinQueue.push(trimmed);
-                }
-                else {
-                    void postToSession(postUrl, trimmed);
-                }
-            }
-        });
-        process.stdin.on('end', () => process.exit(0));
-    });
-}

package/dist/tools/profiles.d.ts

@@ -1,37 +0,0 @@
-import type { ToolDef } from './tools.js';
-/**
- * Which MCP tool surface to expose. The advertised tool DEFINITIONS are re-sent to the model on
- * every turn, so a smaller surface is a per-turn token saving that compounds across a loop. Fewer
- * tools also makes the model wander less (fewer turns, higher accuracy). See bench/agent-loop-and-replay.md.
- *
- * MEASURED surface sizes (assert them with profile-reachability.test.ts rather than trusting prose —
- * every count previously written here was wrong, and the token figures below derive from those counts):
- *   core 15 · standard 32 · hybrid 15 · full 43 · dynamic 2
- * core and hybrid are both 14 because a trimmed profile now also advertises the two meta-tools, which
- * is what keeps an un-advertised tool reachable through reticle_run.
- *
- * core — the verify loop a coding agent actually needs: navigate→look→act→observe→assert,
- * WITH direct network + console + state observability (the highest-signal checks).
- * The recommended profile for agent-driven verification.
- * standard — core + common extras (inspect, sequences, animations, flows, session lifecycle,
- * scroll, baselines, …). For agents that need more than the bare loop.
- * hybrid — THE DEFAULT: core verify+oracle tools advertised directly + 2 meta-tools for on-demand
- * reach to everything else. Core accuracy/detection at ~64% less schema tax than full.
- * full — all tools advertised directly. Opt in via RETICLE_TOOL_PROFILE=full for hard-call scripts.
- */
-export declare const TOOL_PROFILE: {
-    /** dynamic — advertise only 2 meta-tools (reticle_tools + reticle_run); load real tools on demand.
-     * Fixed ~hundreds of tokens/turn regardless of how many tools exist. See dynamic-tools.ts. */
-    readonly DYNAMIC: "dynamic";
-    /** hybrid — the core verify tools advertised directly (so the agent acts reliably) PLUS the 2
-     * meta-tools for on-demand reach to every other tool. Core accuracy + full reach at ~core cost. */
-    readonly HYBRID: "hybrid";
-    readonly CORE: "core";
-    readonly STANDARD: "standard";
-    readonly FULL: "full";
-};
-export type ToolProfile = (typeof TOOL_PROFILE)[keyof typeof TOOL_PROFILE];
-export declare const TOOL_PROFILE_ENV = "RETICLE_TOOL_PROFILE";
-export declare const CORE_TOOL_NAMES: ReadonlySet<string>;
-export declare function resolveToolProfile(explicit?: string): ToolProfile;
-export declare function filterTools(tools: ToolDef[], profile: ToolProfile): ToolDef[];