@reticlehq/server 2.13.0 → 2.14.0

package/dist/input/network-detail.js

@@ -1,4 +1,4 @@
-import { EventType, REDACTED_VALUE, defaultIsSensitiveKey, scrubKnownSecrets, } from '@reticlehq/core';
+import { EventType, REDACTED_VALUE, URL_RAW, defaultIsSensitiveKey, netUrlFields, scrubKnownSecrets, urlForMatch, } from '@reticlehq/core';
 import { drivenRedactionPolicy } from './driven-redaction.js';
 /** Bound on a captured wire body — matches the in-page capture so the two are comparable. */
 const MAX_WIRE_BODY_CHARS = 8192;
@@ -30,8 +30,17 @@ function redactByKey(value, policy) {
     }
     return value;
 }
+/**
+ * Redact and bound a captured wire body, returning the value AND whether the bound was reached.
+ *
+ * The report is the point. This body is taken raw off the network stack, it is capped, and the cap is
+ * reached by ordinary payloads (a bulk save, a base64 attachment, a rich-text field). Returning the
+ * shortened string alone let a partial capture be read as a whole one, which is the shape the
+ * lossy-transform rule exists to forbid.
+ */
 function projectWireBody(raw, policy) {
-    const bounded = raw.length > MAX_WIRE_BODY_CHARS ? raw.slice(0, MAX_WIRE_BODY_CHARS) : raw;
+    const truncated = raw.length > MAX_WIRE_BODY_CHARS;
+    const bounded = truncated ? raw.slice(0, MAX_WIRE_BODY_CHARS) : raw;
     const byShape = scrubKnownSecrets(bounded);
     // Prefer a STRUCTURAL pass. A sensitive key must be redacted regardless of its value type — a
     // numeric PIN (`"password": 1234`), a token array, a nested credential object — and the old
@@ -39,16 +48,17 @@ function projectWireBody(raw, policy) {
     // straight to the agent's context and the on-disk journal. Parsing and walking redacts them by key
     // whatever the shape.
     try {
-        return JSON.stringify(redactByKey(JSON.parse(byShape), policy));
+        return { body: JSON.stringify(redactByKey(JSON.parse(byShape), policy)), truncated };
     }
     catch {
         // Not JSON (a truncated capture, or a form-encoded body — the shape a login form actually POSTs).
         // Two best-effort sweeps, because a password lives in both: the `"key":"string"` JSON fragment a
         // truncated body still contains, and the `key=value` pair of `application/x-www-form-urlencoded`,
         // which neither the JSON path nor the old regex ever touched — so `password=hunter2` leaked.
-        return byShape
+        const body = byShape
             .replace(/"([^"]+)"\s*:\s*"([^"]*)"/g, (whole, key) => policy.isSensitiveKey(key) ? `"${key}":"${REDACTED_VALUE}"` : whole)
             .replace(/([^&?=\s]+)=([^&\s]*)/g, (whole, key) => policy.isSensitiveKey(key) ? `${key}=${REDACTED_VALUE}` : whole);
+        return { body, truncated };
     }
 }
 /**
@@ -76,22 +86,36 @@ function projectHeaders(headers, policy) {
  * about the function's inputs.
  */
 export function buildNetworkDetail(raw, policy = DEFAULT_POLICY) {
+    const wireBody = raw.requestBody === undefined || 0 === raw.requestBody.length
+        ? undefined
+        : projectWireBody(raw.requestBody, policy);
     return {
-        url: raw.url,
+        ...netUrlFields(raw.url, policy.isSensitiveKey),
         ...(raw.method === undefined ? {} : { method: raw.method }),
         status: raw.status,
         headers: projectHeaders(raw.headers, policy),
         ...(raw.resourceType === undefined ? {} : { resourceType: raw.resourceType }),
-        ...(raw.requestBody === undefined || 0 === raw.requestBody.length
+        ...(wireBody === undefined
             ? {}
-            : { requestBody: projectWireBody(raw.requestBody, policy) }),
+            : {
+                requestBody: wireBody.body,
+                ...(wireBody.truncated ? { requestBodyTruncated: true } : {}),
+            }),
         ...(raw.pageUrl === undefined || 0 === raw.pageUrl.length ? {} : { pageUrl: raw.pageUrl }),
     };
 }
-function keyOf(url, method) {
+/**
+ * The merge key: method plus the RAW url when the observation kept one, else the displayed url.
+ *
+ * Never the displayed url alone. The two sides redact independently, the SDK under the page's own
+ * policy and this module under the daemon's, so the one field they were being compared on is the one
+ * field redaction is allowed to rewrite. Keying on `urlForMatch` compares what was actually
+ * requested, which is identical on both sides by construction.
+ */
+function keyOf(data) {
+    const method = data['method'];
     const m = 'string' === typeof method ? method.toUpperCase() : '';
-    const u = 'string' === typeof url ? url : '';
-    return `${m} ${u}`;
+    return `${m} ${urlForMatch(data)}`;
 }
 /**
  * Fold each NET_DETAIL onto the matching in-page NET_REQUEST (by method+url), enriching it with the
@@ -103,13 +127,13 @@ export function mergeNetworkDetail(events) {
     const requestByKey = new Map();
     for (const e of events) {
         if (e.type === EventType.NET_REQUEST)
-            requestByKey.set(keyOf(e.data['url'], e.data['method']), e);
+            requestByKey.set(keyOf(e.data), e);
     }
     const out = [];
     const enriched = new Map();
     for (const e of events) {
         if (e.type === EventType.NET_DETAIL) {
-            const match = requestByKey.get(keyOf(e.data['url'], e.data['method']));
+            const match = requestByKey.get(keyOf(e.data));
             if (match === undefined) {
                 out.push(e); // unmatched detail survives on its own
                 continue;
@@ -133,6 +157,14 @@ export function mergeNetworkDetail(events) {
                     data['requestBodyDivergedFromPage'] = true;
                 }
                 data['requestBody'] = wireBody;
+                // The caveat belongs to the body it describes, and this is the one field that REPLACES
+                // rather than fills a gap. Carried over when the wire body was cut, deleted when it was not:
+                // a stale `true` from the page capture would caveat a body that is now whole, and a missing
+                // one would let a cut body read as complete.
+                if (true === e.data['requestBodyTruncated'])
+                    data['requestBodyTruncated'] = true;
+                else
+                    delete data['requestBodyTruncated'];
             }
             enriched.set(match, { ...base, data });
             continue; // the detail is absorbed into the request

package/dist/input/network-mock-tools.js

@@ -73,10 +73,11 @@ export function toRules(value) {
 export const NETWORK_MOCK_TOOLS = [
     {
         name: ReticleTool.NETWORK_MOCK,
-        description: 'Stub or intercept network requests on the DRIVEN page (needs `reticle drive`): return a 500, ' +
-            'force offline (abort), or delay a response — so you can deterministically test error and edge ' +
-            'states without touching the backend ("verify the app handles a failed payment"). Pass `mocks` ' +
-            '(first matching rule wins); pass an empty array or `clear: true` to turn mocking off.',
+        description: 'Stub or intercept network requests on a driven page (`reticle drive` / RETICLE_CDP_URL) or a ' +
+            'leased Playwright tab (`reticle_lease acquire`): return a 500, force offline (abort), or delay ' +
+            'a response — so you can deterministically test error and edge states without touching the ' +
+            'backend ("verify the app handles a failed payment"). Pass `mocks` (first matching rule wins); ' +
+            'pass an empty array or `clear: true` to turn mocking off.',
         inputSchema: {
             // The rule fields each carry their own `.describe()` on `ruleShape`, but the params
             // view reads only the top-level description of each entry, so those are flattened
@@ -97,21 +98,27 @@ export const NETWORK_MOCK_TOOLS = [
             recommendation: z.string().optional(),
         },
         handler: async (deps, args) => {
-            const provider = mockProvider(deps);
-            if (provider === undefined) {
-                // Mocking needs a browser Reticle drives; a synthetic in-page session can't intercept the network.
-                return {
-                    applied: false,
-                    count: 0,
-                    ok: false,
-                    reason: CDP_NO_PROVIDER_REASON,
-                    recommendation: CDP_NO_PROVIDER_RECOMMENDATION,
-                };
-            }
             const session = deps.sessions.resolve(asString(args['sessionId']));
             const rules = true === args['clear'] ? [] : toRules(args['mocks']);
-            const applied = await provider.setMocks(session.url, rules);
-            return { applied, count: applied ? rules.length : 0 };
+            const provider = mockProvider(deps);
+            if (provider !== undefined) {
+                const applied = await provider.setMocks(session.url, rules);
+                if (applied)
+                    return { applied: true, count: rules.length };
+            }
+            // A lease is a Playwright-owned page — CDP intercept was always there, this tool just had no
+            // route to it. Tried after the driven provider: when both exist, drive is the page the caller
+            // means, and a lease is the fallback rather than a competitor.
+            const leased = await deps.pool?.setMocksLease(session.id, rules);
+            if (true === leased)
+                return { applied: true, count: rules.length };
+            return {
+                applied: false,
+                count: 0,
+                ok: false,
+                reason: CDP_NO_PROVIDER_REASON,
+                recommendation: CDP_NO_PROVIDER_RECOMMENDATION,
+            };
         },
     },
 ];

package/dist/input/real-input.js

@@ -1,6 +1,6 @@
 import { chromiumLaunchOptions } from '../chromium-launch-options.js';
 import { gotoOptions } from '../pool/playwright-launcher.js';
-import { BrowserLaunchKind } from '@reticlehq/core';
+import { BrowserLaunchKind } from '@reticlehq/core/telemetry';
 import { getSessionMetrics } from '../telemetry/session-metrics.js';
 import { classifyConnectFailure } from '../telemetry/connect-failure.js';
 import { ActionType, DriveErrorCode, DRIVE_PLAYWRIGHT_MISSING_MSG } from '@reticlehq/core';

package/dist/input/viewport-tools.js

@@ -34,22 +34,34 @@ export const VIEWPORT_TOOLS = [
             recommendation: z.string().optional(),
         },
         handler: async (deps, args) => {
-            const provider = viewportProvider(deps);
-            if (provider === undefined) {
-                return {
-                    applied: false,
-                    width: 0,
-                    height: 0,
-                    ok: false,
-                    reason: CDP_NO_PROVIDER_REASON,
-                    recommendation: CDP_NO_PROVIDER_RECOMMENDATION,
-                };
-            }
             const width = clampDim(args['width']);
             const height = clampDim(args['height']);
             const session = deps.sessions.resolve(asString(args['sessionId']));
-            const applied = await provider.setViewport(session.url, { width, height });
-            return { applied, width, height };
+            const provider = viewportProvider(deps);
+            if (provider !== undefined) {
+                const applied = await provider.setViewport(session.url, { width, height });
+                if (applied)
+                    return { applied: true, width, height };
+            }
+            // A lease is a Playwright-owned page, so the resize was always possible — this tool just had
+            // no route to it. Tried after the driven provider, on the same rule reticle_network_mock
+            // follows: when both exist, drive is the page the caller means and a lease is the fallback.
+            //
+            // Without this, `reticle_viewport` refused on every SDK-only install, which is the DEFAULT
+            // install. Reported from the field: mobile-only UI — a `lg:hidden` hamburger, a drawer that
+            // only mounts under a breakpoint — could not be driven at a desktop viewport at all, and the
+            // recommendation printed alongside the refusal asked the reader to install a second browser.
+            const leased = await deps.pool?.setViewportLease(session.id, { width, height });
+            if (true === leased)
+                return { applied: true, width, height };
+            return {
+                applied: false,
+                width: 0,
+                height: 0,
+                ok: false,
+                reason: CDP_NO_PROVIDER_REASON,
+                recommendation: CDP_NO_PROVIDER_RECOMMENDATION,
+            };
         },
     },
 ];

package/dist/intent/inline-intent.d.ts

@@ -1,14 +1,4 @@
 import type { ToolDeps } from '../tools/tool-kit.js';
-/**
- * The ledger id a piece of inline prose is declared under.
- *
- * Derived from the statement rather than minted, so the same sentence declared on five verdicts is
- * one row rather than five, and a DIFFERENT sentence is a different row rather than a false
- * amendment of the first. The slug is there because the id is what an agent later types to reference
- * the intent, and a bare digest is unreadable; the digest is there because the slug is truncated and
- * two long statements sharing a prefix must not share a row.
- */
-export declare function inlineIntentId(statement: string): string;
 /** What `provenBy` records: which tool drew the verdict, and when. */
 export declare function inlineVerdictId(tool: string, at: number): string;
 export declare function surfaceForInlineIntent(url: string | undefined, flow: string | undefined, 

package/dist/intent/inline-intent.js

@@ -32,7 +32,7 @@ const SLUG_EDGES = /^-+|-+$/g;
  * the intent, and a bare digest is unreadable; the digest is there because the slug is truncated and
  * two long statements sharing a prefix must not share a row.
  */
-export function inlineIntentId(statement) {
+function inlineIntentId(statement) {
     const slug = statement
         .toLowerCase()
         .replace(NON_SLUG, SLUG_SEPARATOR)

package/dist/intent/intent-shard-store.d.ts

@@ -19,14 +19,14 @@
  * an older build still reading the flat file keeps working, because nothing removes it. Deleting it
  * is a separate decision somebody can take once they believe the migration.
  */
-import { type Intent } from '@reticlehq/core';
+import { type Intent } from '@reticlehq/core/artifacts';
 import type { FileSystemPort } from '../project/fs-port.js';
 import { IntentStatus, type IntentIndex, type IntentRecord } from './intent-shard.js';
 export interface Clock {
     now: () => number;
 }
 /** What a caller supplies to write an intent. Everything optional is genuinely optional. */
-export interface IntentInput {
+interface IntentInput {
     id: string;
     statement: string;
     subject?: string | undefined;
@@ -70,3 +70,4 @@ export declare class IntentShardStore {
         subjects: string[];
     }>;
 }
+export {};

package/dist/intent/intent-shard-store.js

@@ -19,7 +19,7 @@
  * an older build still reading the flat file keeps working, because nothing removes it. Deleting it
  * is a separate decision somebody can take once they believe the migration.
  */
-import { parseIntentFile } from '@reticlehq/core';
+import { parseIntentFile } from '@reticlehq/core/artifacts';
 import { reticleDirPaths } from '../project/reticle-dir.js';
 import { withFileLock } from '../project/file-lock.js';
 import { subjectFor } from './intent-subject.js';

package/dist/intent/intent-shard.d.ts

@@ -42,9 +42,8 @@
  * invent them, and a store that rejected incomplete records would simply not be written to.
  */
 import { z } from 'zod';
-import { type Intent } from '@reticlehq/core';
+import { type Intent } from '@reticlehq/core/artifacts';
 import type { FileSystemPort } from '../project/fs-port.js';
-export declare const INTENT_SHARD_VERSION = 1;
 /**
  * How settled a record is.
  *
@@ -64,7 +63,7 @@ export declare const IntentStatus: {
     readonly STALE: "stale";
 };
 export type IntentStatus = (typeof IntentStatus)[keyof typeof IntentStatus];
-export declare const IntentRecordSchema: z.ZodObject<{
+declare const IntentRecordSchema: z.ZodObject<{
     id: z.ZodString;
     statement: z.ZodString;
     state: z.ZodEnum<["declared", "bound", "proved"]>;
@@ -75,12 +74,12 @@ export declare const IntentRecordSchema: z.ZodObject<{
         flow: z.ZodOptional<z.ZodString>;
         files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
-        flow?: string | undefined;
         route?: string | undefined;
+        flow?: string | undefined;
         files?: string[] | undefined;
     }, {
-        flow?: string | undefined;
         route?: string | undefined;
+        flow?: string | undefined;
         files?: string[] | undefined;
     }>>;
     provenBy: z.ZodOptional<z.ZodObject<{
@@ -124,8 +123,8 @@ export declare const IntentRecordSchema: z.ZodObject<{
     statement: string;
     declaredAt: number;
     surface?: {
-        flow?: string | undefined;
         route?: string | undefined;
+        flow?: string | undefined;
         files?: string[] | undefined;
     } | undefined;
     source?: string | undefined;
@@ -149,8 +148,8 @@ export declare const IntentRecordSchema: z.ZodObject<{
     statement: string;
     declaredAt: number;
     surface?: {
-        flow?: string | undefined;
         route?: string | undefined;
+        flow?: string | undefined;
         files?: string[] | undefined;
     } | undefined;
     source?: string | undefined;
@@ -182,12 +181,12 @@ export declare const IntentShardSchema: z.ZodObject<{
             flow: z.ZodOptional<z.ZodString>;
             files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
-            flow?: string | undefined;
             route?: string | undefined;
+            flow?: string | undefined;
             files?: string[] | undefined;
         }, {
-            flow?: string | undefined;
             route?: string | undefined;
+            flow?: string | undefined;
             files?: string[] | undefined;
         }>>;
         provenBy: z.ZodOptional<z.ZodObject<{
@@ -231,8 +230,8 @@ export declare const IntentShardSchema: z.ZodObject<{
         statement: string;
         declaredAt: number;
         surface?: {
-            flow?: string | undefined;
             route?: string | undefined;
+            flow?: string | undefined;
             files?: string[] | undefined;
         } | undefined;
         source?: string | undefined;
@@ -256,8 +255,8 @@ export declare const IntentShardSchema: z.ZodObject<{
         statement: string;
         declaredAt: number;
         surface?: {
-            flow?: string | undefined;
             route?: string | undefined;
+            flow?: string | undefined;
             files?: string[] | undefined;
         } | undefined;
         source?: string | undefined;
@@ -284,8 +283,8 @@ export declare const IntentShardSchema: z.ZodObject<{
         statement: string;
         declaredAt: number;
         surface?: {
-            flow?: string | undefined;
             route?: string | undefined;
+            flow?: string | undefined;
             files?: string[] | undefined;
         } | undefined;
         source?: string | undefined;
@@ -313,8 +312,8 @@ export declare const IntentShardSchema: z.ZodObject<{
         statement: string;
         declaredAt: number;
         surface?: {
-            flow?: string | undefined;
             route?: string | undefined;
+            flow?: string | undefined;
             files?: string[] | undefined;
         } | undefined;
         source?: string | undefined;
@@ -336,7 +335,7 @@ export declare const IntentShardSchema: z.ZodObject<{
 export type IntentShard = z.infer<typeof IntentShardSchema>;
 export declare const summarise: (statement: string) => string;
 /** One line per intent: enough to decide whether to open the shard, and no more. */
-export declare const IntentIndexEntrySchema: z.ZodObject<{
+declare const IntentIndexEntrySchema: z.ZodObject<{
     id: z.ZodString;
     subject: z.ZodString;
     statement: z.ZodString;
@@ -409,3 +408,4 @@ export declare const shardsFrom: (records: readonly IntentRecord[]) => IntentSha
 export declare const serialise: (value: unknown) => string;
 /** Read + validate one JSON file, failing soft: a hand-merged file with a conflict marker is real. */
 export declare const readJsonFile: <T>(fs: FileSystemPort, path: string, parse: (raw: unknown) => T, fallback: T) => Promise<T>;
+export {};

package/dist/intent/intent-shard.js

@@ -42,9 +42,9 @@
  * invent them, and a store that rejected incomplete records would simply not be written to.
  */
 import { z } from 'zod';
-import { IntentSchema } from '@reticlehq/core';
+import { IntentSchema } from '@reticlehq/core/artifacts';
 import { subjectFor, UNSORTED_SUBJECT } from './intent-subject.js';
-export const INTENT_SHARD_VERSION = 1;
+const INTENT_SHARD_VERSION = 1;
 /** Byte-stable writes: an unchanged shard produces no diff, so the ones that DID change stand out. */
 const JSON_INDENT = 2;
 /**
@@ -65,7 +65,7 @@ export const IntentStatus = {
     /** Believed out of date — kept, because deleting the record loses the fact it was ever true. */
     STALE: 'stale',
 };
-export const IntentRecordSchema = IntentSchema.extend({
+const IntentRecordSchema = IntentSchema.extend({
     /** Which shard this lives in. Stored as well as implied, so a file read alone is self-describing. */
     subject: z.string().min(1),
     status: z.enum([
@@ -99,7 +99,7 @@ export const IntentShardSchema = z.object({
 const SUMMARY_MAX = 72;
 export const summarise = (statement) => statement.length <= SUMMARY_MAX ? statement : `${statement.slice(0, SUMMARY_MAX - 1).trimEnd()}…`;
 /** One line per intent: enough to decide whether to open the shard, and no more. */
-export const IntentIndexEntrySchema = z.object({
+const IntentIndexEntrySchema = z.object({
     id: z.string().min(1),
     subject: z.string().min(1),
     statement: z.string().min(1),

package/dist/intent/intent-store.d.ts

@@ -1,4 +1,4 @@
-import { type Intent, type IntentSurface } from '@reticlehq/core';
+import { type Intent, type IntentSurface } from '@reticlehq/core/artifacts';
 import type { FileSystemPort } from '../project/fs-port.js';
 export interface Clock {
     now: () => number;

package/dist/intent/intent-store.js

@@ -1,4 +1,4 @@
-import { bindIntent, declareIntent, dischargeIntent, emptyIntentFile, openIntents, parseIntentFile, upsertIntent, } from '@reticlehq/core';
+import { bindIntent, declareIntent, dischargeIntent, emptyIntentFile, openIntents, parseIntentFile, upsertIntent, } from '@reticlehq/core/artifacts';
 import { reticleDirPaths } from '../project/reticle-dir.js';
 import { withFileLock } from '../project/file-lock.js';
 /**

package/dist/intent/intent-subject.d.ts

@@ -25,7 +25,7 @@
 /** Where an intent goes when nothing about it says where it belongs. Deliberately obvious. */
 export declare const UNSORTED_SUBJECT = "unsorted";
 /** Shape enough of an intent to derive a subject, without importing the whole record. */
-export interface SubjectEvidence {
+interface SubjectEvidence {
     subject?: string | undefined;
     surface?: {
         route?: string | undefined;
@@ -43,3 +43,4 @@ export declare const slugifySubject: (raw: string) => string;
  * that loses records.
  */
 export declare const subjectFor: (evidence: SubjectEvidence) => string;
+export {};

package/dist/intent/open-intents.d.ts

@@ -1,4 +1,4 @@
-import type { Intent } from '@reticlehq/core';
+import type { Intent } from '@reticlehq/core/artifacts';
 import type { ToolDeps } from '../tools/tool-kit.js';
 /**
  * What this project still owes — the ledger's undischarged intents, for a tool that has `deps` and a
@@ -20,7 +20,7 @@ export declare function openSessionIntents(deps: ToolDeps, sessionId: string | u
  */
 export declare function allSessionIntents(deps: ToolDeps, sessionId: string | undefined): Promise<Intent[]>;
 /** What the ledger still owes once this verdict's own intent is discharged, and how old it is. */
-export interface IntentDebt {
+interface IntentDebt {
     openIntentCount: number;
     /**
      * Age of the OLDEST open intent, in ms. Absent when nothing is open.
@@ -40,3 +40,4 @@ export interface IntentDebt {
  * by one verdict, and the result still said "1 declared intent(s) are still unproved".
  */
 export declare function intentDebt(open: readonly Intent[], dischargedId: string | undefined, now: number): IntentDebt;
+export {};

package/dist/license/license.d.ts

@@ -12,7 +12,7 @@
  */
 import { type KeyObject } from 'node:crypto';
 import { z } from 'zod';
-import { LicenseActivation } from '@reticlehq/core';
+import { LicenseActivation } from '@reticlehq/core/telemetry';
 /** Outcome of verifying a license key. */
 export declare const LicenseStatus: {
     readonly VALID: "valid";
@@ -40,14 +40,14 @@ declare const LicensePayloadSchema: z.ZodObject<{
     exp: z.ZodNumber;
     features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-    lid: string;
     org: string;
+    lid: string;
     plan: string;
     exp: number;
     features?: string[] | undefined;
 }, {
-    lid: string;
     org: string;
+    lid: string;
     plan: string;
     exp: number;
     features?: string[] | undefined;
@@ -116,7 +116,7 @@ export declare function assertEnterprise(feature: string, ctx: GateContext, env?
 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). */
-export interface LicenseReport {
+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

package/dist/license/license.js

@@ -12,7 +12,7 @@
  */
 import { createPublicKey, sign as edSign, verify as edVerify } from 'node:crypto';
 import { z } from 'zod';
-import { LicenseActivation } from '@reticlehq/core';
+import { LicenseActivation } from '@reticlehq/core/telemetry';
 /** Outcome of verifying a license key. */
 export const LicenseStatus = {
     VALID: 'valid',

package/dist/mcp/attach-memory.d.ts

@@ -69,7 +69,7 @@ export declare function attachState(stateDir: string, port: number): AttachState
  */
 export declare function describeAttachState(state: AttachState): string | undefined;
 /** What `reticle status` reports about the client side of the install. */
-export interface AttachStatusFields {
+interface AttachStatusFields {
     mcpClient: AttachState;
     mcpClientAction?: string;
 }
@@ -81,3 +81,4 @@ export interface AttachStatusFields {
  * healthy client from a version too old to look. The advice rides along only when there is any.
  */
 export declare function attachStatusFields(stateDir: string, port: number): AttachStatusFields;
+export {};

package/dist/mcp/client-identity.d.ts

@@ -17,7 +17,7 @@
  * version; MCP has no concept of a model, so the transport genuinely cannot tell us. Anything
  * claiming to know it would be inventing it.
  */
-export interface McpClientIdentity {
+interface McpClientIdentity {
     name?: string;
     version?: string;
 }
@@ -29,3 +29,4 @@ export declare function clearMcpClientIdentityHook(): void;
  * introduced itself — a plain CLI run has no client, and reporting one would be a fabrication.
  */
 export declare function mcpClientIdentity(): McpClientIdentity;
+export {};

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

@@ -12,7 +12,7 @@
  * it was removed. What a dashboard needs is the SHARE OF SESSIONS that lose MCP at all (the first
  * outage) and the share where it never came back on its own (the budget being spent).
  */
-import { OutageReason, OutageStage } from '@reticlehq/core';
+import { OutageReason, OutageStage } from '@reticlehq/core/telemetry';
 /**
  * `OutageStage` and `OutageReason` are core's — this re-export only saves the proxy an import. They
  * cross the wire, so the vocabulary lives in the contract package and is never re-listed here.

package/dist/mcp/mcp-outage.js

@@ -12,7 +12,7 @@
  * it was removed. What a dashboard needs is the SHARE OF SESSIONS that lose MCP at all (the first
  * outage) and the share where it never came back on its own (the budget being spent).
  */
-import { OutageReason, OutageStage, TelemetryEventKind } from '@reticlehq/core';
+import { OutageReason, OutageStage, TelemetryEventKind } from '@reticlehq/core/telemetry';
 import { getTelemetry } from '../telemetry/telemetry.js';
 /**
  * `OutageStage` and `OutageReason` are core's — this re-export only saves the proxy an import. They

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

@@ -105,4 +105,6 @@ export declare function startMcpProxy(port: number,
  * budget ran out and then killed itself, taking the agent's whole Reticle surface with it — the
  * failure mode for a daemon that crashed, was stopped, or shut itself down as idle.
  */
-ensureDaemon?: () => Promise<void>): Promise<never>;
+ensureDaemon?: () => Promise<void>, 
+/** Observe the real shutdown boundary in transport tests without terminating their worker. */
+exitProcess?: (code: number) => void): Promise<never>;