@reticlehq/server 3.5.0 → 3.7.0

package/dist/telemetry/argument-shape.d.ts

@@ -19,6 +19,13 @@
  * never quietly start forwarding free text.
  */
 export declare const OTHER_VALUE = "other";
+/**
+ * Add values WE define to a parameter's allow-list. The merged tools call this for their `action`
+ * values (`reticle_look`'s `page` / `find` / ...): those are keys of a plan in this repository, not
+ * input, and without them every grouped call reported `action:other`. Only for a parameter already
+ * listed above, so this can widen an enum and never start forwarding a free-text parameter.
+ */
+export declare function allowParamValues(name: string, values: Iterable<string>): void;
 /**
  * The reportable form of one parameter: `name` on its own, or `name:value` when the parameter is a
  * known enum. Never the raw value of anything else.

package/dist/telemetry/argument-shape.js

@@ -41,6 +41,19 @@ const SAFE_ENUM_PARAMS = new Map([
     ['level', new Set(['error', 'warn', 'info', 'log', 'debug'])],
 ]);
 export const OTHER_VALUE = 'other';
+/**
+ * Add values WE define to a parameter's allow-list. The merged tools call this for their `action`
+ * values (`reticle_look`'s `page` / `find` / ...): those are keys of a plan in this repository, not
+ * input, and without them every grouped call reported `action:other`. Only for a parameter already
+ * listed above, so this can widen an enum and never start forwarding a free-text parameter.
+ */
+export function allowParamValues(name, values) {
+    const allowed = SAFE_ENUM_PARAMS.get(name);
+    if (allowed === undefined)
+        return;
+    for (const value of values)
+        allowed.add(value);
+}
 /**
  * The reportable form of one parameter: `name` on its own, or `name:value` when the parameter is a
  * known enum. Never the raw value of anything else.
@@ -82,11 +95,83 @@ export function describeToolParams(args) {
 export function describeCliFlags(argv) {
     const flags = new Set();
     for (const arg of argv) {
+        // A bare `--` ends the options: everything after it is passed through to something else.
+        if (END_OF_OPTIONS === arg)
+            break;
         if (!arg.startsWith('--'))
             continue;
         // `--port=9000` — split so the NAME is reported and the value is discarded with everything else.
         const name = arg.split('=')[0] ?? arg;
-        flags.add(name);
+        flags.add(KNOWN_CLI_FLAGS.has(name) ? name : OTHER_VALUE);
     }
     return [...flags].sort();
 }
+const END_OF_OPTIONS = '--';
+/**
+ * The flags the CLI defines. Anything else is reported as `other`: a flag NAME the user typed can
+ * carry their own word as easily as a value can. Hand-listed because the CLI parses its flags in
+ * many places with no shared table; a flag missing here reports `other`, which loses a count and
+ * leaks nothing.
+ */
+const KNOWN_CLI_FLAGS = new Set([
+    '--accept-coverage',
+    '--agent',
+    '--app',
+    '--bug',
+    '--capture-bodies',
+    '--confirm-dangerous',
+    '--dir',
+    '--drive',
+    '--drive-model',
+    '--dry-run',
+    '--email',
+    '--env',
+    '--expect',
+    '--expect-file',
+    '--explore',
+    '--files-only',
+    '--fix',
+    '--flow',
+    '--force',
+    '--headed',
+    '--headless',
+    '--help',
+    '--hook',
+    '--hooks',
+    '--http',
+    '--http-port',
+    '--http-token',
+    '--install-secs',
+    '--json',
+    '--kind',
+    '--license',
+    '--move-history',
+    '--no-agents',
+    '--no-drive',
+    '--no-first-run',
+    '--no-install',
+    '--no-mcp',
+    '--no-open',
+    '--persona',
+    '--porcelain',
+    '--port',
+    '--project',
+    '--quiet',
+    '--rating',
+    '--relaunch',
+    '--results-json',
+    '--runtime-secs',
+    '--select',
+    '--session',
+    '--session-id',
+    '--since',
+    '--start',
+    '--storage-state',
+    '--subject',
+    '--timeout',
+    '--url',
+    '--version',
+    '--watch',
+    '--workspace',
+    '--yes',
+]);

package/dist/telemetry/automation-hint.d.ts

@@ -2,13 +2,12 @@ import { AutomationHint } from '@reticlehq/core/telemetry';
 interface AutomationInput {
     env: NodeJS.ProcessEnv;
     fileExists: (path: string) => boolean;
-    hasTty: boolean;
 }
 /**
  * The most specific signal that fires, or undefined.
  *
- * Ordered most specific first: a container inside a Codespace with no terminal is one fact about the
- * run, and sending the weakest of the three would waste the field. Omitted rather than sent as a
+ * Ordered most specific first: an agent sandbox runs in a container, and a container inside a
+ * Codespace is one fact about the run; sending the weaker signal would waste the field. Omitted rather than sent as a
  * "none" value, so its presence is itself the signal — the convention every other advisory field
  * here follows.
  */

package/dist/telemetry/automation-hint.js

@@ -23,6 +23,8 @@
  *  - `npm_config_user_agent`. Says which package manager ran us, which every route shares.
  *  - An absent `$DISPLAY`. Every Linux server, every ssh session, and a large share of genuine
  *    developer machines trip it; it separates nothing.
+ *  - No terminal on stdin/stdout. It was the third signal here, and every MCP stdio server has no
+ *    terminal, so it fired on nearly every daemon a person's agent started and separated nothing.
  */
 import { existsSync } from 'node:fs';
 import { AutomationHint } from '@reticlehq/core/telemetry';
@@ -35,21 +37,47 @@ const HOSTED_WORKSPACE_ENV = [
     'CLOUD_SHELL',
     'REMOTE_CONTAINERS',
 ];
+/**
+ * CI vendors' own variables, for the runners and self-hosted agents that do not set `CI`. Each is
+ * set by the runner itself; a person's shell does not carry them.
+ */
+const CI_VENDOR_ENV = [
+    'GITHUB_ACTIONS',
+    'GITLAB_CI',
+    'BUILDKITE',
+    'CIRCLECI',
+    'JENKINS_URL',
+    'TF_BUILD',
+    'TEAMCITY_VERSION',
+    'BITBUCKET_BUILD_NUMBER',
+    'CODEBUILD_BUILD_ID',
+    'DRONE',
+    'TRAVIS',
+];
+/**
+ * Hosted coding-agent sandboxes that declare themselves to what they spawn. Only markers the agent
+ * sets on purpose for a REMOTE session: a local agent's own marker (`CLAUDECODE`) is a person at a
+ * laptop and belongs to `client`, not here.
+ */
+const AGENT_SANDBOX_ENV = ['CLAUDE_CODE_REMOTE'];
+const declared = (env, keys) => keys.some((k) => (env[k] ?? '') !== '' && 'false' !== env[k]);
 /**
  * The most specific signal that fires, or undefined.
  *
- * Ordered most specific first: a container inside a Codespace with no terminal is one fact about the
- * run, and sending the weakest of the three would waste the field. Omitted rather than sent as a
+ * Ordered most specific first: an agent sandbox runs in a container, and a container inside a
+ * Codespace is one fact about the run; sending the weaker signal would waste the field. Omitted rather than sent as a
  * "none" value, so its presence is itself the signal — the convention every other advisory field
  * here follows.
  */
 export function resolveAutomationHint(input) {
+    if (declared(input.env, AGENT_SANDBOX_ENV))
+        return AutomationHint.AGENT_SANDBOX;
+    if (declared(input.env, CI_VENDOR_ENV))
+        return AutomationHint.CI_RUNNER;
     if (CONTAINER_MARKERS.some((m) => input.fileExists(m)))
         return AutomationHint.CONTAINER;
-    if (HOSTED_WORKSPACE_ENV.some((k) => (input.env[k] ?? '') !== ''))
+    if (declared(input.env, HOSTED_WORKSPACE_ENV))
         return AutomationHint.HOSTED_WORKSPACE;
-    if (!input.hasTty)
-        return AutomationHint.NO_TTY;
     return undefined;
 }
 /** The real reading, taken once per process. */
@@ -64,8 +92,5 @@ export function currentAutomationHint(env) {
                 return false; // an unreadable root is not evidence of anything
             }
         },
-        // Both ends, because a piped stdout alone is how `reticle status | jq` looks, and that is a
-        // person typing.
-        hasTty: true === process.stdout.isTTY || true === process.stdin.isTTY,
     });
 }

package/dist/telemetry/cli-telemetry.js

@@ -13,7 +13,8 @@ import { join } from 'node:path';
 /** Where the installer left its breadcrumbs. Same directory the telemetry id and opt-out live in. */
 const RETICLE_STATE_DIR = process.env['RETICLE_STATE_DIR'] ?? join(homedir(), '.reticle');
 import { describeCliFlags } from './argument-shape.js';
-import { resolveInstallSource } from './install-source.js';
+import { rememberInstallSource, resolveInstallSource } from './install-source.js';
+import { installPlatformLinkTelemetry } from './platform-linked.js';
 /**
  * Report that a person ran a `reticle` subcommand.
  *
@@ -53,7 +54,11 @@ export function reportCliRun(argv) {
      * second invocation finds nothing. A flag would have to live somewhere, and somewhere is another
      * file that can disagree with this one.
      */
+    // Every process that may link a project, the daemon included, reports it.
+    installPlatformLinkTelemetry();
     drainInstallTrace(RETICLE_STATE_DIR);
+    // Before anything reads it: a channel declared on THIS command outlives it.
+    rememberInstallSource(process.env, RETICLE_STATE_DIR);
     if (firstArg === DAEMON_INNER_COMMAND)
         return;
     const command = knownCommand(firstArg);
@@ -67,7 +72,7 @@ export function reportCliRun(argv) {
             detach: true,
             // WHICH published route brought this machine in. Self-declared by the channel, never inferred
             // — see install-source.ts for which of the four routes can actually carry the marker.
-            installSource: resolveInstallSource(),
+            installSource: resolveInstallSource(process.env, RETICLE_STATE_DIR),
         });
     if (!isHumanCliCommand(command))
         return;

package/dist/telemetry/daemon-telemetry.js

@@ -15,6 +15,7 @@ import { reticleStateHome } from '../command/daemon/daemon.js';
 import { startUpdateCheck, updateNudgeState } from '../command/update/update-nudge.js';
 import { markDaemonStart } from './mcp-connection.js';
 import { markInstrumentationClock } from './app-instrumented.js';
+import { drainFeedbackOutbox } from './feedback.js';
 import { markStallClock, STALL_AFTER_MS, stallUptime } from '../portal/session/stall-clock.js';
 /**
  * Whether an app for this project has ever reached Reticle, read from the same durable memory the
@@ -91,6 +92,8 @@ export function installDaemonTelemetry(cwd, now = () => Date.now(),
 port) {
     const metrics = getSessionMetrics(now);
     void getTelemetry().emit(TelemetryEventKind.DAEMON_STARTED);
+    // Reports a past send could not deliver. Off the boot path, and never able to throw into it.
+    void drainFeedbackOutbox().catch(() => undefined);
     // Ask npm whether a newer Reticle exists, so the agent can tell the human. Nothing checked before
     // this, so a published fix was invisible until someone manually ran `reticle update`.
     startUpdateCheck(now);

package/dist/telemetry/error-fingerprint.d.ts

@@ -1,4 +1,13 @@
-/** The skeleton of a message: variable parts blanked, whitespace collapsed, length bounded. */
+/**
+ * What an error message may say on the wire, and it is ALLOW-listed: a sentence Reticle authors
+ * (sent as our own fixed label), else the bare Node error code or built-in class plus the
+ * fingerprint, else the fingerprint alone.
+ *
+ * It used to be the message with known-variable parts blanked, which is a deny-list, and a
+ * deny-list loses: a hostname after `getaddrinfo ENOTFOUND`, a Windows home directory with a space
+ * in it, a `~` path and a person's name in free text all reached the wire. Nothing written by
+ * anybody else survives this function, because it never echoes its input.
+ */
 export declare function errorSkeleton(message: string): string;
 /** A stable, opaque group key for an error message. Same defect ⇒ same key, on every machine. */
 export declare function fingerprintError(message: string): string;

package/dist/telemetry/error-fingerprint.js

@@ -40,8 +40,13 @@ const VARIABLE_PARTS = [
     // ── Then the grouping rules ──────────────────────────────────────────────────────────────────
     /"[^"]*"|'[^']*'|`[^`]*`/g, // quoted values — names, selectors, snippets
     /\b[a-z][a-z0-9+.-]*:\/\/\S+/gi, // URLs
+    // Windows paths run to the end of the message: a directory name may hold a space, and
+    // `C:\Users\Jane Doe\…` cut at the first space sent the surname.
+    /(?:\\\\\?\\)?[A-Za-z]:[\\/].*$/g,
+    /~[\\/]\S*/g, // home-relative paths
     /(?:\/[\w.-]+){2,}\/?/g, // POSIX-ish paths
-    /[A-Za-z]:\\[^\s]*/g, // Windows paths
+    /\b\d{1,3}(?:\.\d{1,3}){3}(?::\d+)?\b/g, // IPv4 (+ port)
+    /\b[\w-]+(?:\.[\w-]+)+\b/g, // hostnames and other dotted names
     /\b[0-9a-f]{8,}\b/gi, // hex ids, hashes, uuids-without-dashes
     /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, // uuids
     /\d+/g, // any remaining number — ports, counts, timeouts
@@ -71,16 +76,67 @@ const VARIABLE_PARTS = [
  * for a reason unrelated to this one.
  */
 const MAX_SKELETON_INPUT = 1024;
-/** The skeleton of a message: variable parts blanked, whitespace collapsed, length bounded. */
-export function errorSkeleton(message) {
+/** Variable parts blanked, whitespace collapsed, length bounded. The GROUPING basis; never sent. */
+function redactedShape(message) {
     let skeleton = message.slice(0, MAX_SKELETON_INPUT);
     for (const pattern of VARIABLE_PARTS)
         skeleton = skeleton.replace(pattern, '*');
     return skeleton.replace(/\s+/g, ' ').trim().slice(0, 200);
 }
+/**
+ * Sentences Reticle itself authors, and the fixed text sent for each. The OUTPUT is always the
+ * label, never the matched message, so text appended to one of ours cannot ride along.
+ */
+const RETICLE_MESSAGES = [
+    { match: /^no browser session connected\b/i, label: 'no browser session connected' },
+    { match: /^multiple sessions connected\b/i, label: 'multiple sessions connected' },
+    { match: /^no connected session with id\b/i, label: 'no connected session with id *' },
+    { match: /^no baseline named\b/i, label: 'no baseline named *' },
+    { match: /^no (?:active|compiled) recording named\b/i, label: 'no recording named *' },
+    { match: /no longer resolves to an element/i, label: 'ref * no longer resolves to an element' },
+    { match: /^session disconnected$/i, label: 'session disconnected' },
+    { match: /^command '[^']*' timed out after\b/i, label: 'command * timed out after *' },
+    {
+        match: /did not resolve in current page/i,
+        label: 'flow step * did not resolve in current page',
+    },
+    {
+        match: /potentially destructive (?:\w+ )*(?:action|tool) blocked/i,
+        label: 'potentially destructive action blocked',
+    },
+    { match: /^pairing token is required\b/i, label: 'pairing token is required' },
+    { match: /no <option> with value/i, label: 'no <option> with value *' },
+    { match: /cannot hover without a real pointer/i, label: 'cannot hover without a real pointer' },
+    { match: /browser pool (?:unavailable|is shut down)/i, label: 'browser pool unavailable' },
+    { match: /Chromium is not installed/i, label: 'Chromium is not installed' },
+    { match: /^act failed$/i, label: 'act failed' },
+];
+/** A Node error code (`ENOENT`, `ERR_INVALID_ARG_TYPE`): an identifier Node defines, never data. */
+const NODE_ERROR_CODE = /\b(?:E[A-Z]{2,}|ERR_[A-Z_]{2,})\b/;
+/** The built-in error classes. A custom class name is the app's own word, so it is not kept. */
+const BUILTIN_ERROR_CLASS = /^(?:Error|TypeError|RangeError|SyntaxError|ReferenceError|EvalError|URIError|AggregateError|AbortError|TimeoutError|DOMException|ZodError)\b/;
+/**
+ * What an error message may say on the wire, and it is ALLOW-listed: a sentence Reticle authors
+ * (sent as our own fixed label), else the bare Node error code or built-in class plus the
+ * fingerprint, else the fingerprint alone.
+ *
+ * It used to be the message with known-variable parts blanked, which is a deny-list, and a
+ * deny-list loses: a hostname after `getaddrinfo ENOTFOUND`, a Windows home directory with a space
+ * in it, a `~` path and a person's name in free text all reached the wire. Nothing written by
+ * anybody else survives this function, because it never echoes its input.
+ */
+export function errorSkeleton(message) {
+    const head = message.slice(0, MAX_SKELETON_INPUT).trim();
+    for (const { match, label } of RETICLE_MESSAGES)
+        if (match.test(head))
+            return label;
+    const fingerprint = `#${fingerprintError(message)}`;
+    const code = BUILTIN_ERROR_CLASS.exec(head)?.[0] ?? NODE_ERROR_CODE.exec(head)?.[0];
+    return code === undefined ? fingerprint : `${code} ${fingerprint}`;
+}
 /** A stable, opaque group key for an error message. Same defect ⇒ same key, on every machine. */
 export function fingerprintError(message) {
-    return createHash('sha256').update(errorSkeleton(message)).digest('hex').slice(0, 12);
+    return createHash('sha256').update(redactedShape(message)).digest('hex').slice(0, 12);
 }
 /**
  * Frames from a stack trace that belong to RETICLE, reduced to `basename:line`.
@@ -121,7 +177,7 @@ export function fingerprintCrash(errorType, stack, message) {
     const frames = reticleFrames(stack);
     const basis = frames.length > 0
         ? `${errorType}|${frames.join('|')}`
-        : `${errorType}|${errorSkeleton(message)}`;
+        : `${errorType}|${redactedShape(message)}`;
     return createHash('sha256').update(basis).digest('hex').slice(0, 12);
 }
 /** The error's constructor name (`TypeError`), or `Unknown` for a thrown non-Error. */

package/dist/telemetry/feedback-cli.d.ts

@@ -15,19 +15,6 @@ import { TelemetryAction } from '../command/cli/cli-parse.js';
  * show you the payload is asking for trust it has not earned.
  */
 export declare function handleFeedback(text: string, rating: number | undefined, bug: boolean, feedbackKind?: string, agent?: boolean): Promise<void>;
-/**
- * `reticle identify` — opt-in, and it shows the consent notice before it sends anything.
- *
- * Deliberately NOT interactive: a prompt that appears in the middle of someone's work is pressure,
- * and this is the one command where the user must be choosing freely. They type what they want to
- * share, or they never run it at all.
- */
-export declare function handleIdentify(parsed: {
-    context?: string;
-    company?: string;
-    email?: string;
-    forget: boolean;
-}): Promise<void>;
 /**
  * `reticle telemetry [status|enable|disable]` — the user-facing control for anonymous usage metrics.
  * `disable` persists a machine-wide opt-out (survives shells, unlike RETICLE_TELEMETRY=0); `status`

package/dist/telemetry/feedback-cli.js

@@ -3,7 +3,6 @@ import { AGENT_FLAG, BUG_FLAG, FEEDBACK_KINDS, KIND_FLAG, RATING_FLAG, } from '.
 import { describeFeedbackPayload, submitFeedback } from './feedback.js';
 import { describeTelemetry, setTelemetryEnabled } from './telemetry.js';
 import { TelemetryAction } from '../command/cli/cli-parse.js';
-import { clearIdentity, IDENTIFY_NOTICE, readIdentity, saveIdentity, submitIdentity, UsageContextKind, } from './identify.js';
 /**
  * `reticle feedback [--rating 1-5] [--bug] "what happened"` — the feedback channel as a command.
  *
@@ -49,82 +48,6 @@ export async function handleFeedback(text, rating, bug, feedbackKind, agent = fa
     line(receipt.sent
         ? 'thanks       your feedback is in. it genuinely changes what gets built next.'
         : `not sent     ${receipt.reason ?? 'unknown reason'}`);
-    for (const extra of identifyInvite(agent))
-        line(extra);
-}
-/**
- * Offer a HUMAN a way to be replied to — printed after the receipt, never as a prompt.
- *
- * Feedback is anonymous by design and stays that way: the report has already been sent by the time
- * this prints, so nothing here gates or delays it. This is an offer, not a question.
- *
- * It routes through `reticle identify`, which already does consented identity properly — it prints
- * what it will send, states that identifying links this machine's prior anonymous history to that
- * identity, and has `--forget`. Capturing an address inline on `feedback_submitted` instead would
- * put PII on the anonymous event stream and break what `docs/telemetry.md` promises in public:
- * "no domain sniffing, no email inference" and "no personal data is collected".
- *
- * Only for humans (an agent has no email), and only when nobody has identified yet — so somebody
- * who declined is never asked twice.
- */
-function identifyInvite(agent) {
-    if (agent)
-        return [];
-    try {
-        if (readIdentity() !== undefined)
-            return [];
-    }
-    catch {
-        return []; // unreadable identity file: say nothing rather than risk asking twice
-    }
-    return [
-        '',
-        'want a reply? `reticle identify --context <company|side_project|oss|learning> --email you@example.com`',
-        '             optional, and it tells you exactly what it sends before sending it.',
-    ];
-}
-/**
- * `reticle identify` — opt-in, and it shows the consent notice before it sends anything.
- *
- * Deliberately NOT interactive: a prompt that appears in the middle of someone's work is pressure,
- * and this is the one command where the user must be choosing freely. They type what they want to
- * share, or they never run it at all.
- */
-export async function handleIdentify(parsed) {
-    const line = (s) => {
-        process.stdout.write(`${s}\n`);
-    };
-    if (parsed.forget) {
-        clearIdentity();
-        line('forgotten    the local identity file is deleted; nothing further is sent.');
-        line('             to have what was already sent removed, email support@reticlehq.com');
-        return;
-    }
-    const context = Object.values(UsageContextKind).find((k) => k === parsed.context);
-    if (context === undefined) {
-        const existing = readIdentity();
-        if (existing !== undefined)
-            line(`current      ${JSON.stringify(existing)}`);
-        line(`usage: reticle identify --context <${Object.values(UsageContextKind).join('|')}>`);
-        line('       [--company "Acme"] [--email you@acme.com] [--forget]');
-        line('');
-        line(IDENTIFY_NOTICE);
-        process.exitCode = existing === undefined ? 1 : 0;
-        return;
-    }
-    const identity = {
-        context,
-        ...(parsed.company !== undefined ? { company: parsed.company } : {}),
-        ...(parsed.email !== undefined ? { email: parsed.email } : {}),
-    };
-    line(IDENTIFY_NOTICE);
-    line('');
-    line(`sending      ${JSON.stringify(identity)}`);
-    saveIdentity(identity);
-    const sent = await submitIdentity(identity);
-    line(sent
-        ? 'thanks       saved and sent. we may reach out; `reticle identify --forget` undoes this.'
-        : 'not sent     telemetry is disabled on this machine, so it was saved locally only.');
 }
 /**
  * `reticle telemetry [status|enable|disable]` — the user-facing control for anonymous usage metrics.

package/dist/telemetry/feedback.d.ts

@@ -22,6 +22,7 @@
  *      disables it too, since it rides the same emitter.
  */
 import { type Feedback } from '@reticlehq/core/telemetry';
+import { type Telemetry } from './telemetry.js';
 import { type SessionFacts } from './feedback-context.js';
 /** Kills the feedback channel ONLY — adoption counters keep flowing. */
 export declare const FEEDBACK_ENV = "RETICLE_FEEDBACK";
@@ -34,6 +35,12 @@ interface Redaction {
 }
 /** Strip credential/PII shapes and cap the length. Pure — the tests read like a spec of what leaks. */
 export declare function redactFeedbackText(input: string, max: number): Redaction;
+/**
+ * A trace reduced to Reticle's own words, in order: which tools were called and what verdict each
+ * gave. The raw trace is the call/response trail, and the responses carry the page's text and what
+ * was typed into it, which no redaction rule can tell from prose. So nothing else is kept.
+ */
+export declare function summarizeTrace(trace: string): string;
 /** True when the feedback channel is switched off on its own (the emitter's switches apply as well). */
 export declare function feedbackDisabled(env?: NodeJS.ProcessEnv): boolean;
 /** What the author supplies; the environment context is detected, never asked for. */
@@ -89,6 +96,12 @@ export declare function submitFeedback(input: FeedbackInput, opts?: {
      */
     background?: boolean;
 }): Promise<FeedbackReceipt>;
+/**
+ * Retry what the outbox holds: the receipt for an undelivered report promises "It will be retried",
+ * and until this ran on daemon start nothing ever read the outbox back. Bounded, sequential, and
+ * best-effort; a report the endpoint does not accept stays queued. Returns how many were delivered.
+ */
+export declare function drainFeedbackOutbox(telemetry?: Telemetry, home?: string): Promise<number>;
 /**
  * The receipt's context PLUS the fields the emitter stamps on every event regardless of kind — the
  * reticle version, the OS, and whether this is CI. They are the single most-asked question of any bug