@reticlehq/server 2.9.0 → 2.10.0

package/dist/honesty/verified.js

@@ -133,7 +133,23 @@ export function decideVerified(inputs) {
     // A vacuous green: nothing was actually proved. Grade NONE means no signal, no request, no state
     // change and no element was pinned — the assertion could not have failed, which makes passing it
     // evidence of nothing.
+    // Two different facts used to share this answer. Everything above has already ruled out a failure,
+    // a contradiction, a dirty capture, a pending write and an unread one — so when the window ALSO
+    // settled, the engine did not fail to see: it saw the whole window, ran every oracle, and found
+    // nothing wrong. That is `no-fault`, and telling it apart from "I could not see" is the difference
+    // between "assert something" and "look again with better coverage".
+    //
+    // Gated on `true === settled` rather than on a caller's say-so. A call that returned before the app
+    // stopped moving has not earned this, whatever it declared — which is what stops `no-fault` from
+    // becoming the green-forever button an always-available "nothing was wrong" would be.
     if (honesty.grade === HonestyGrade.NONE) {
+        if (true === settled) {
+            return {
+                verified: Verified.NO_FAULT,
+                verifiedReason: VerifiedReason.NOTHING_DECLARED,
+                because: 'the page settled and no channel reported a problem, but nothing was declared to prove — this is not verification. Assert a consequence the action CHANGES (a signal, a request, a route, or store state) to get one',
+            };
+        }
         return {
             verified: Verified.UNKNOWN,
             verifiedReason: VerifiedReason.VACUOUS_GRADE,

package/dist/index.d.ts

@@ -28,6 +28,24 @@ export { VisualStore } from './visual/visual-store.js';
 export { diffPng } from './visual/visual-diff.js';
 export type { VisualDiffResult, VisualRect, DiffOptions } from './visual/visual-diff.js';
 export { crawl } from './crawl/crawl.js';
+/**
+ * The contradiction pass, and the seam a consumer adds its own rules through.
+ *
+ * Exported because a service embedding this engine grades a recording the same way the tools do, and
+ * without these it would have to re-implement the fold — a second implementation of the one thing
+ * this product is judged on, and the one nobody dogfoods is the one that rots.
+ */
+export { findContradictions } from './events/contradictions.js';
+/**
+ * The MCP server factory, so a consumer can serve the tool surface it composed.
+ *
+ * Without this the composition seam is unreachable from outside the package: a consumer can build the
+ * list and has nothing to hand it to.
+ */
+export { createMcpServer } from './mcp/mcp.js';
+export type { Contradiction, ContradictionOptions } from './events/contradictions.js';
+export { registerContradictionFold, registeredContradictionFolds, } from './events/contradiction-folds.js';
+export type { ContradictionFold } from './events/contradiction-folds.js';
 export { MCP_SSE_PATH, MCP_MESSAGE_PATH } from '@reticlehq/core';
 export { BrowserPool, DEFAULT_LEASE_TTL_MS } from './pool/browser-pool.js';
 export type { Lease, Launcher, PooledBrowser } from './pool/browser-pool.js';

package/dist/index.js

@@ -72,6 +72,22 @@ export { ProjectStore } from './project/project-store.js';
 export { VisualStore } from './visual/visual-store.js';
 export { diffPng } from './visual/visual-diff.js';
 export { crawl } from './crawl/crawl.js';
+/**
+ * The contradiction pass, and the seam a consumer adds its own rules through.
+ *
+ * Exported because a service embedding this engine grades a recording the same way the tools do, and
+ * without these it would have to re-implement the fold — a second implementation of the one thing
+ * this product is judged on, and the one nobody dogfoods is the one that rots.
+ */
+export { findContradictions } from './events/contradictions.js';
+/**
+ * The MCP server factory, so a consumer can serve the tool surface it composed.
+ *
+ * Without this the composition seam is unreachable from outside the package: a consumer can build the
+ * list and has nothing to hand it to.
+ */
+export { createMcpServer } from './mcp/mcp.js';
+export { registerContradictionFold, registeredContradictionFolds, } from './events/contradiction-folds.js';
 export { MCP_SSE_PATH, MCP_MESSAGE_PATH } from '@reticlehq/core';
 export { BrowserPool, DEFAULT_LEASE_TTL_MS } from './pool/browser-pool.js';
 export { playwrightLauncher, resolveMaxContexts } from './pool/playwright-launcher.js';

package/dist/init/mcp.d.ts

@@ -11,7 +11,7 @@
  * project's `.reticle.json` in its CWD (see cli-port.ts). The port belongs to the project, not the
  * global agent config.
  */
-export declare const MCP_SERVER_NAME = "reticle";
+export { MCP_SERVER_NAME } from '@reticlehq/core';
 /**
  * The registered command is STILL bare `npx` on every platform, deliberately.
  *
@@ -76,4 +76,3 @@ export declare function claudeAvailableProbe(): {
 };
 /** Printed when the `claude` CLI isn't available — register Reticle globally once, by hand. */
 export declare function mcpManual(): string;
-export {};

package/dist/init/mcp.js

@@ -12,7 +12,10 @@
  * global agent config.
  */
 import { RETICLE_NPM_PACKAGE } from '../version/server-version.js';
-export const MCP_SERVER_NAME = 'reticle';
+// The name is a wire identity and lives in the contract; re-exported here so the registration writers
+// below (and their tests) keep reading it from the module that USES it.
+export { MCP_SERVER_NAME } from '@reticlehq/core';
+import { MCP_SERVER_NAME } from '@reticlehq/core';
 /**
  * The registered command is STILL bare `npx` on every platform, deliberately.
  *

package/dist/license/license.d.ts

@@ -12,6 +12,7 @@
  */
 import { type KeyObject } from 'node:crypto';
 import { z } from 'zod';
+import { LicenseActivation } from '@reticlehq/core';
 /** Outcome of verifying a license key. */
 export declare const LicenseStatus: {
     readonly VALID: "valid";
@@ -21,18 +22,31 @@ export declare const LicenseStatus: {
     readonly EXPIRED: "expired";
 };
 export type LicenseStatus = (typeof LicenseStatus)[keyof typeof LicenseStatus];
-/** The signed claims inside a key. `exp` is epoch ms; `features` (optional) scopes which ee features unlock. */
+/**
+ * The signed claims inside a key. `exp` is epoch ms; `features` (optional) scopes which ee features
+ * unlock.
+ *
+ * `lid` is the STABLE LICENSE ID and the only safe join key for per-customer usage: `org` is a display
+ * name a human typed at signing time, so two customers called "Acme" merge into one and a customer who
+ * renames splits into two. Every key carries one (minted by the issuer, `scripts/issue-license.mjs`),
+ * which is why it is required rather than optional — an optional id is one that goes missing on exactly
+ * the keys somebody later needs to attribute, and a key without it should be re-issued, not silently
+ * counted as nobody.
+ */
 declare const LicensePayloadSchema: z.ZodObject<{
+    lid: z.ZodString;
     org: z.ZodString;
     plan: z.ZodString;
     exp: z.ZodNumber;
     features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
+    lid: string;
     org: string;
     plan: string;
     exp: number;
     features?: string[] | undefined;
 }, {
+    lid: string;
     org: string;
     plan: string;
     exp: number;
@@ -42,13 +56,44 @@ export type LicensePayload = z.infer<typeof LicensePayloadSchema>;
 type LicenseCheck = {
     status: typeof LicenseStatus.VALID;
     payload: LicensePayload;
+}
+/**
+ * EXPIRED carries the payload; the other failures cannot. The line is the SIGNATURE, not the
+ * clock: an expired key was genuinely issued by us and its claims are exactly as trustworthy as
+ * they were yesterday, so the licence id is safe to use. A malformed or wrongly-signed key has no
+ * verified claims at all, and naming a customer from one would mean trusting whatever was pasted.
+ */
+ | {
+    status: typeof LicenseStatus.EXPIRED;
+    payload: LicensePayload;
 } | {
-    status: Exclude<LicenseStatus, typeof LicenseStatus.VALID>;
+    status: Exclude<LicenseStatus, typeof LicenseStatus.VALID | typeof LicenseStatus.EXPIRED>;
 };
 /** Sign a payload into a license key — the ISSUER side (Reticle's private key). Exposed for the issuer tool + tests. */
 export declare function signLicenseKey(payload: LicensePayload, privateKey: KeyObject): string;
 /** Verify a key against the issuer public key. Never throws — returns a structured status. */
 export declare function verifyLicenseKey(key: string | undefined, publicKey: KeyObject, now: number): LicenseCheck;
+/**
+ * Where to get a key. A named constant because it appears in the gate's error AND in what
+ * `reticle license` prints, and a contact address that drifts between the two is a support request
+ * that reaches nobody.
+ */
+export declare const LICENSE_CONTACT = "hey@reticle.sh";
+/**
+ * The features a licence gates in THIS build. The single source: `assertEnterprise` callers name a
+ * member rather than a string literal, and `reticle license` reports the list, so what the CLI claims
+ * is gated is derived from what is actually gated rather than a second list somebody maintains.
+ *
+ * It is deliberately short. Reticle's roadmap for enterprise is longer (SSO, SCIM, RBAC, multi-org,
+ * policy gates), and none of it is here yet — printing a roadmap as though it were shipped is how a
+ * buyer discovers on day two that the thing they paid for does not exist. What is listed is what the
+ * running build will actually refuse without a key.
+ */
+export declare const EnterpriseFeature: {
+    /** Recording an audit event. */
+    readonly AUDIT_LOG: "audit-log";
+};
+export type EnterpriseFeature = (typeof EnterpriseFeature)[keyof typeof EnterpriseFeature];
 /** Thrown when a production-mode enterprise feature is used without a valid license. */
 export declare class EnterpriseLicenseError extends Error {
     readonly feature: string;
@@ -71,8 +116,28 @@ export declare function assertEnterprise(feature: string, ctx: GateContext): voi
 export declare const LICENSE_KEY_ENV = "RETICLE_LICENSE_KEY";
 export declare const LICENSE_PUBLIC_KEY_ENV = "RETICLE_LICENSE_PUBLIC_KEY";
 /** The human-facing state of enterprise activation on this machine (what `reticle license status` shows). */
-interface LicenseReport {
-    status: 'active' | 'missing' | 'invalid' | 'expired' | 'eval';
+export interface LicenseReport {
+    /**
+     * Typed against core's closed list rather than re-listing the strings here: this status is reported
+     * on every telemetry event, so a member added in one place and not the other is a silently
+     * miscounted column (telemetry contract, rule 4).
+     */
+    status: LicenseActivation;
+    /** The stable license id — what usage is attributed to. Present only when `status` is `active`. */
+    licenseId?: string;
+    /**
+     * What a licence unlocks in THIS build, and where to get one. Always reported, including on an
+     * unlicensed install: `reticle license` was the one command that talks about licensing and it named
+     * neither, so it told an interested reader to set a variable without saying what it would unlock or
+     * how to obtain it. A dead end at exactly the moment somebody is asking.
+     */
+    gated: readonly string[];
+    contact: string;
+    /**
+     * The key is valid, and scoped to features this build does not gate, so it unlocks nothing here.
+     * Present only when true: a `false` on every healthy licence is noise on the common case.
+     */
+    coversNothingHere?: boolean;
     org?: string;
     plan?: string;
     expiresAt?: number;

package/dist/license/license.js

@@ -12,6 +12,7 @@
  */
 import { createPublicKey, sign as edSign, verify as edVerify } from 'node:crypto';
 import { z } from 'zod';
+import { LicenseActivation } from '@reticlehq/core';
 /** Outcome of verifying a license key. */
 export const LicenseStatus = {
     VALID: 'valid',
@@ -20,8 +21,19 @@ export const LicenseStatus = {
     BAD_SIGNATURE: 'bad-signature',
     EXPIRED: 'expired',
 };
-/** The signed claims inside a key. `exp` is epoch ms; `features` (optional) scopes which ee features unlock. */
+/**
+ * The signed claims inside a key. `exp` is epoch ms; `features` (optional) scopes which ee features
+ * unlock.
+ *
+ * `lid` is the STABLE LICENSE ID and the only safe join key for per-customer usage: `org` is a display
+ * name a human typed at signing time, so two customers called "Acme" merge into one and a customer who
+ * renames splits into two. Every key carries one (minted by the issuer, `scripts/issue-license.mjs`),
+ * which is why it is required rather than optional — an optional id is one that goes missing on exactly
+ * the keys somebody later needs to attribute, and a key without it should be re-issued, not silently
+ * counted as nobody.
+ */
 const LicensePayloadSchema = z.object({
+    lid: z.string().min(1),
     org: z.string(),
     plan: z.string(),
     exp: z.number(),
@@ -68,15 +80,35 @@ export function verifyLicenseKey(key, publicKey, now) {
     if (!signatureOk)
         return { status: LicenseStatus.BAD_SIGNATURE };
     if (payload.exp <= now)
-        return { status: LicenseStatus.EXPIRED };
+        return { status: LicenseStatus.EXPIRED, payload };
     return { status: LicenseStatus.VALID, payload };
 }
+/**
+ * Where to get a key. A named constant because it appears in the gate's error AND in what
+ * `reticle license` prints, and a contact address that drifts between the two is a support request
+ * that reaches nobody.
+ */
+export const LICENSE_CONTACT = 'hey@reticle.sh';
+/**
+ * The features a licence gates in THIS build. The single source: `assertEnterprise` callers name a
+ * member rather than a string literal, and `reticle license` reports the list, so what the CLI claims
+ * is gated is derived from what is actually gated rather than a second list somebody maintains.
+ *
+ * It is deliberately short. Reticle's roadmap for enterprise is longer (SSO, SCIM, RBAC, multi-org,
+ * policy gates), and none of it is here yet — printing a roadmap as though it were shipped is how a
+ * buyer discovers on day two that the thing they paid for does not exist. What is listed is what the
+ * running build will actually refuse without a key.
+ */
+export const EnterpriseFeature = {
+    /** Recording an audit event. */
+    AUDIT_LOG: 'audit-log',
+};
 /** Thrown when a production-mode enterprise feature is used without a valid license. */
 export class EnterpriseLicenseError extends Error {
     feature;
     reason;
     constructor(feature, reason) {
-        super(`Reticle Enterprise feature "${feature}" requires a valid license (${reason}). Contact hey@reticle.sh.`);
+        super(`Reticle Enterprise feature "${feature}" requires a valid license (${reason}). Contact ${LICENSE_CONTACT}.`);
         this.name = 'EnterpriseLicenseError';
         this.feature = feature;
         this.reason = reason;
@@ -122,7 +154,7 @@ export const LICENSE_PUBLIC_KEY_ENV = 'RETICLE_LICENSE_PUBLIC_KEY';
  * never setting RETICLE_LICENSE_PUBLIC_KEY, because the baked key takes precedence. The public key is
  * safe to ship openly — it can only verify licenses, never mint them (that needs the private key).
  */
-const BAKED_ISSUER_PUBLIC_KEY_PEM = '';
+const BAKED_ISSUER_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAcg+u61Fs5pwDHcYxFGhaxVaQoUbAdyl+RUdSViZyxDY=\n-----END PUBLIC KEY-----";
 /**
  * Resolve the issuer public-key PEM enforcement uses: the baked-in release key wins, so it can't be
  * turned off from the environment. Only when nothing is baked (dev/repo) does the env var apply — that
@@ -134,6 +166,15 @@ function resolveIssuerPublicKeyPem(env, baked = BAKED_ISSUER_PUBLIC_KEY_PEM) {
     const envPem = env[LICENSE_PUBLIC_KEY_ENV];
     return envPem !== undefined && envPem.length > 0 ? envPem : undefined;
 }
+/**
+ * The two fields every report carries, spread into each branch. One object rather than a field on each
+ * return, because the value that must never go missing is the one on the branch nobody was thinking
+ * about — and the branch an unlicensed reader lands on is exactly that branch.
+ */
+const LICENSE_OFFER = {
+    gated: Object.values(EnterpriseFeature),
+    contact: LICENSE_CONTACT,
+};
 function loadPublicKey(pem) {
     if (pem === undefined || 0 === pem.length)
         return undefined;
@@ -156,42 +197,70 @@ export function describeLicense(now, env = process.env, baked = BAKED_ISSUER_PUB
         // is off, and assertEnterpriseFromEnv now denies rather than unlocking. Say so loudly here too.
         return isProductionEnv(env)
             ? {
-                status: 'invalid',
+                ...LICENSE_OFFER,
+                status: LicenseActivation.INVALID,
                 detail: 'MISCONFIGURED — running in production with no issuer key baked; enterprise features are DENIED (rebuild with BAKED_ISSUER_PUBLIC_KEY_PEM stamped in)',
             }
             : {
-                status: 'eval',
+                ...LICENSE_OFFER,
+                status: LicenseActivation.EVAL,
                 detail: 'evaluation mode: enterprise features run free (no issuer key configured)',
             };
     }
     const publicKey = loadPublicKey(pem);
     if (publicKey === undefined)
-        return { status: 'invalid', detail: `${LICENSE_PUBLIC_KEY_ENV} is not a valid public key` };
+        return {
+            ...LICENSE_OFFER,
+            status: LicenseActivation.INVALID,
+            detail: `${LICENSE_PUBLIC_KEY_ENV} is not a valid public key`,
+        };
     const check = verifyLicenseKey(env[LICENSE_KEY_ENV], publicKey, now);
     if (check.status === LicenseStatus.VALID) {
-        const { org, plan, exp, features } = check.payload;
+        const { lid, org, plan, exp, features } = check.payload;
+        // A key scoped to features this build does not gate is `active` and unlocks nothing. Both halves
+        // were already on screen (`features` against `gated`) and nothing joined them, so the one word a
+        // customer actually reads told them they were fine while every gated call refused them.
+        const coversNothingHere = features !== undefined && !features.some((f) => LICENSE_OFFER.gated.includes(f));
+        const detail = coversNothingHere
+            ? `licensed to ${org} (${plan}), expires ${new Date(exp).toISOString()}. This key covers ${features?.join(', ')}, and nothing this build gates (${LICENSE_OFFER.gated.join(', ')}) is included. Contact ${LICENSE_CONTACT}`
+            : `licensed to ${org} (${plan}), expires ${new Date(exp).toISOString()}`;
         return {
-            status: 'active',
+            ...LICENSE_OFFER,
+            status: LicenseActivation.ACTIVE,
+            licenseId: lid,
             org,
             plan,
             expiresAt: exp,
             ...(features !== undefined ? { features } : {}),
-            detail: `licensed to ${org} (${plan}), expires ${new Date(exp).toISOString()}`,
+            ...(coversNothingHere ? { coversNothingHere } : {}),
+            detail,
         };
     }
     if (check.status === LicenseStatus.MISSING) {
         return {
-            status: 'missing',
-            detail: `set ${LICENSE_KEY_ENV} to activate enterprise features in production`,
+            ...LICENSE_OFFER,
+            status: LicenseActivation.MISSING,
+            detail: `set ${LICENSE_KEY_ENV} to activate enterprise features in production. ` +
+                `Request a key from ${LICENSE_CONTACT}`,
         };
     }
     if (check.status === LicenseStatus.EXPIRED) {
+        // The id rides an expired key so a lapse can be attributed to a CUSTOMER. Without it, telemetry
+        // reports that somebody's licence ran out and cannot say whose, which is not a renewal signal.
         return {
-            status: 'expired',
-            detail: 'license expired — renew to keep using enterprise features',
+            ...LICENSE_OFFER,
+            status: LicenseActivation.EXPIRED,
+            licenseId: check.payload.lid,
+            org: check.payload.org,
+            expiresAt: check.payload.exp,
+            detail: `license expired. Renew with ${LICENSE_CONTACT} to keep using enterprise features`,
         };
     }
-    return { status: 'invalid', detail: `license key rejected (${check.status})` };
+    return {
+        ...LICENSE_OFFER,
+        status: LicenseActivation.INVALID,
+        detail: `license key rejected (${check.status}). ${LICENSE_CONTACT} can re-issue it`,
+    };
 }
 /** True in a production runtime (NODE_ENV=production) — where a missing issuer key is a mis-built
  *  release, not an eval session, so the gate must fail CLOSED rather than run features free. */

package/dist/mcp/mcp-proxy.d.ts

@@ -1,3 +1,5 @@
+export { SseFrameParser, type SseFrame } from './sse-frame-parser.js';
+export { probeDaemon, waitForDaemon } from './proxy-daemon-probe.js';
 /**
  * Re-exported so every existing caller (and every spec) keeps importing the proxy's log from the
  * proxy. Where the code lives is a file-size decision; where it is imported from is an API.
@@ -92,33 +94,6 @@ export declare class HandshakeReplay {
     /** True when this inbound daemon line is the echo of our replayed handshake and must not be forwarded. */
     shouldSuppressInbound(line: string): boolean;
 }
-/** One parsed Server-Sent-Events frame: the event name (defaulted to "message") and its data. */
-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>;
 /**
  * Turn an `endpoint` frame's data into a POST target, or null when there is nothing usable in it.
  *

package/dist/mcp/mcp-proxy.js

@@ -2,8 +2,11 @@ import * as http from 'node:http';
 import { localInitializeResponse, isHandshakeLine, drainLines, MAX_STDIN_LINE_BYTES, } from './proxy-handshake.js';
 import { ToolCatalogCache } from './tool-catalog-cache.js';
 import { toolsChangedNotification } from './proxy-handshake.js';
-import * as net from 'node:net';
 import { LOOPBACK_HOST, MCP_SSE_PATH, MCP_SHUTDOWN_EVENT, ReticleEnv, CONTRACT_FINGERPRINT, } from '@reticlehq/core';
+import { SseFrameParser } from './sse-frame-parser.js';
+export { SseFrameParser } from './sse-frame-parser.js';
+export { probeDaemon, waitForDaemon } from './proxy-daemon-probe.js';
+import { probeDaemon } from './proxy-daemon-probe.js';
 import { SERVER_VERSION } from '../version/server-version.js';
 import { buildServerInstructions } from './server-instructions.js';
 import { hasProjectConnectedBefore } from '../session/connection-memory.js';
@@ -26,20 +29,6 @@ export { accountProxyLogWrite, proxyLog, proxyLogPath, PROXY_LOG_CHECK_BYTES, re
 import { proxyLog } from './proxy-log.js';
 import { log } from '../log.js';
 import { OutageReason, OutageStage, reportMcpOutage } from './mcp-outage.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));
-}
 /** Reconnect backoff: linear, capped, so a briefly-restarting daemon is picked up fast. */
 const RECONNECT_BASE_MS = 250;
 const RECONNECT_CAP_MS = 5_000;
@@ -264,79 +253,6 @@ export class HandshakeReplay {
         return true;
     }
 }
-/**
- * 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`);
-}
 /**
  * POST one JSON-RPC line into the daemon's session. Resolves null on success, or a short reason
  * when the request never reached a server that will answer it.

package/dist/mcp/mcp.d.ts

@@ -35,7 +35,14 @@ export declare function encodeResult(result: unknown, encoding: string): string;
  * "Call reticle_tools { names: [...] } for its parameters" — leaving it out made our own advice a
  * dead end on the one surface that advertises everything.
  */
-export declare function advertisedTools(surface: ToolSurface): ToolDef[];
+export declare function advertisedTools(surface: ToolSurface, 
+/**
+ * The full table to advertise from. Defaults to what this package ships.
+ *
+ * A consumer embedding the engine passes its own composition — ours plus its own — so its tools
+ * reach the wire without editing the shipped array.
+ */
+tools?: readonly ToolDef[]): ToolDef[];
 /**
  * Exactly what gets advertised for one tool under a profile: trimmed description, lean input shape,
  * and (non-lean only) the output schema.
@@ -59,4 +66,13 @@ export declare function createMcpServer(deps: ToolDeps, profile?: ToolSurface,
  * told to instrument a project that is already wired loses a paragraph, while an agent not told
  * loses the entire install — and the second is what the field overwhelmingly shows.
  */
-previouslyConnected?: boolean): McpServer;
+previouslyConnected?: boolean, 
+/**
+ * The full tool table this server serves. Defaults to what this package ships.
+ *
+ * Threaded rather than read from the module so a consumer can serve its own tools on one surface
+ * with ours. It reaches all three places that need the WHOLE table and not just the advertised
+ * slice: the profile filter, the `reticle_run` hatch, and the unadvertised-tool help — a consumer
+ * tool missing from either of the last two is a tool the agent is actively told does not exist.
+ */
+tools?: readonly ToolDef[]): McpServer;