@reticlehq/server 3.6.0 → 3.7.0

package/dist/surface/tools/tools.js

@@ -1,6 +1,6 @@
 import { TESTID_FOUND_UNDER_SCHEMA } from './query-hint-schema.js';
 import { z } from 'zod';
-import { EMPTY_SESSION_LIST_OUTPUT, emptySessionList } from './empty-session-list.js';
+import { EMPTY_SESSION_LIST_OUTPUT, emptySessionList, wireCallerBesideLiveSessions, } from './empty-session-list.js';
 import { AttrNamesSchema, EventType, QueryBy, ReticleCommand, SnapshotMode } from '@reticlehq/core';
 import { ReticleTool } from '@reticlehq/core';
 import { withSizeCost } from '../../portal/session/output-budget.js';
@@ -43,23 +43,25 @@ import { VIEWPORT_TOOLS } from '../../portal/input/viewport-tools.js';
 import { SESSION_TOOLS } from '../../portal/session/session-tools.js';
 import { ANNOTATE_TOOLS } from '../../language/flows/annotate-tools.js';
 import { LIVE_CONTROL_TOOLS } from '../../portal/session/live-control-tools.js';
-import { sessionIdShape, commandOrThrow } from './tool-kit.js';
+import { SCREENSHOT_DOC, sessionIdShape, commandOrThrow, withScreenshotDoc, } from './tool-kit.js';
 import { TOOL_SURFACE } from './tool-surface.js';
 import { mergeActWithSequence } from './act-merged.js';
 import { INSPECT_TOOL } from './inspect-tool.js';
 import { applyMerges } from './merge-tools.js';
 import { ACT_TOOLS } from './act-tools.js';
 import { ACT_SEQUENCE_TOOL } from './act-sequence-tool.js';
+import { withCompactEnvelope } from './agent/compact-envelope.js';
 import { OBSERVE_TOOLS } from './observe-tools.js';
 import { LINEAGE_TOOLS } from './lineage-tools.js';
 import { RECONCILE_TOOLS } from './reconcile-tools.js';
 import { READ_TOOLS } from './read-tools.js';
 import { LEASE_TOOLS } from './lease-tools.js';
 import { FEEDBACK_TOOLS } from './feedback-tools.js';
+import { ACCOUNT_TOOLS } from './account-tool.js';
 /** FALLBACK for `diff: true`; the real one is per MCP client on `deps.snapshots`, which says why. */
 const SNAPSHOT_CACHE = new SnapshotCache();
 /** Every handler, including tools retired from the advertised MCP surface. */
-export const RAW_TOOLS = [
+export const RAW_TOOLS = withCompactEnvelope([
     {
         name: ReticleTool.SESSIONS,
         description: 'List connected browser sessions (tab url/title, sessionId, last-seen, health: hidden/focused/throttled, and `realInputAvailable` — true when native CDP/launched real input is driving this tab), plus a `recommendation` naming the in-protocol escape hatch (`reticle_run { tool: "reticle_lease" }`, with `reticle drive` as the human-side equivalent) when a tab is hidden/throttled and may be un-scriptable from here.',
@@ -124,15 +126,20 @@ export const RAW_TOOLS = [
         handler: async (deps) => {
             const provider = deps.realInput;
             const leasedIds = new Set(deps.pool?.leasedSessionIds() ?? []);
-            const sessions = await Promise.all(deps.sessions.list().map(async (s) => ({
+            const list = () => Promise.all(deps.sessions.list().map(async (s) => ({
                 ...s,
                 realInputAvailable: provider !== undefined ? await provider.isAvailableFor(s.url) : false,
                 leased: leasedIds.has(s.sessionId),
             })));
+            const sessions = await list();
             // An empty list is a dead end on its own; see empty-session-list.ts for what it carries.
             if (0 === sessions.length)
                 return emptySessionList(deps, sessions);
-            return { sessions };
+            // Another project's tab is up. This caller's project may still never have been wired.
+            const wired = await wireCallerBesideLiveSessions(deps, sessions);
+            if (wired === undefined)
+                return { sessions };
+            return { sessions: await list(), wired };
         },
     },
     {
@@ -360,6 +367,10 @@ export const RAW_TOOLS = [
                     .passthrough()
                     .optional()
                     .describe("Present when a TEXT search missed but the string IS on the page, split across this container's children. Retry as { scope: <ref>, self: true } — no text query can match a string no single element owns."),
+                caseMiss: z
+                    .string()
+                    .optional()
+                    .describe('Present when a case-exact TEXT check missed and the page shows the text in another case: what it shows. Retry with ignoreCase: true if the case does not matter.'),
                 // Declared here for the same reason presentRegions had to be: the browser emits it, and an
                 // undeclared field is stripped from structuredContent without a word.
                 nameNearMiss: z
@@ -432,16 +443,14 @@ export const RAW_TOOLS = [
     // reachable through reticle_run. See affected-tools.ts.
     ...AFFECTED_TOOLS,
     // reticle_coverage — which controls were driven vs never touched. Unadvertised; via reticle_run.
-    // The table is passed as a thunk so the coverage tool can report which of it was called without
-    // importing it back — see buildCoverageTools. Called from the handler, long after TOOLS exists.
-    ...buildCoverageTools(() => TOOLS.map((t) => t.name)),
+    ...buildCoverageTools(),
     // reticle_verify_change — "did my change break anything" in one call. See verify-change-tools.ts.
     ...VERIFY_CHANGE_TOOLS,
     // Live-control: reticle_end_session / reticle_resume / reticle_messages. See live-control-tools.ts.
     ...LIVE_CONTROL_TOOLS,
     // reticle_navigate / reticle_refresh — browser navigation tools. See browser-tools.ts.
-    ...BROWSER_TOOLS,
-    ...ACT_TOOLS,
+    ...BROWSER_TOOLS.map(withScreenshotDoc),
+    ...ACT_TOOLS.map(withScreenshotDoc),
     ACT_SEQUENCE_TOOL,
     ...OBSERVE_TOOLS,
     ...LINEAGE_TOOLS,
@@ -449,7 +458,8 @@ export const RAW_TOOLS = [
     ...LEASE_TOOLS,
     // reticle_feedback — the agent reports that RETICLE failed (not that the app did). See feedback-tools.ts.
     ...FEEDBACK_TOOLS,
-];
+    ...ACCOUNT_TOOLS,
+]);
 /**
  * surface consolidation. Tool defs are re-sent EVERY turn, so the advertised count is a per-turn
  * tax multiplied by loop length. Sibling families collapse into one action-dispatched tool; the member
@@ -491,7 +501,7 @@ export const MERGE_PLANS = [
         // existed. The rule is: if a tool has an obligation, the obligation goes first.
         // The first sentence is all a lean surface shows (160 characters), so it carries the
         // obligation and the HUD control; the rest is the detail for a full one.
-        'By action: "yield" is MANDATORY before you stop driving; "tune" hides or moves the HUD, or sets the idle window. ' +
+        'By action: "yield" is MANDATORY before you stop driving; "tune" hides or moves the HUD, or sets the idle window; "account" says the plan, credits and Harness state. ' +
             'In full: "yield" hands control back to the human (mode: waiting|ask, between turns); "tune" takes `hud` (hidden, shown, removed until reload, or a corner) for when the HUD covers a control you must test, and `idleEndMs`; "end" terminates the session for good; "resume" clears a human pause; "messages" drains the human→agent inbox; "review" lists/resolves the mistakes a human pinned to elements; "narrate" states your intent on the presenter HUD.',
         members: {
             tune: ReticleTool.SESSION_TUNE,
@@ -501,6 +511,7 @@ export const MERGE_PLANS = [
             messages: ReticleTool.MESSAGES,
             review: ReticleTool.REVIEW,
             narrate: ReticleTool.NARRATE,
+            account: ReticleTool.ACCOUNT,
         },
         // The handback the lease block orders on every session — the one call an agent MUST make, so it
         // is the one that must not need a schema lookup first.
@@ -738,7 +749,8 @@ export const SURFACE_MERGE_PLANS = [
     },
     {
         name: ReticleTool.ASSERT,
-        description: 'Prove a consequence, by action: "now" evaluates a predicate against the window that already exists, "wait" waits for one to become true within a budget. Both return a verdict; only `verified:"yes"` is a pass.',
+        description: 'Prove a consequence, by action: "now" evaluates a predicate against the window that already exists, "wait" waits for one to become true within a budget. Both return a verdict; only `verified:"yes"` is a pass.' +
+            SCREENSHOT_DOC,
         members: { now: ReticleTool.ASSERT, wait: ReticleTool.WAIT_FOR },
         example: { action: 'now' },
         // Evaluate against the window that already exists. `wait` spends a budget, so it is asked for.

package/dist/telemetry/account-envelope.d.ts

@@ -0,0 +1,7 @@
+import { TelemetryAccountState } from '@reticlehq/core/telemetry';
+export interface AccountEnvelope {
+    accountState: TelemetryAccountState;
+    linked: boolean;
+    workspaceId?: string;
+}
+export declare function accountEnvelope(cwd: string, env: NodeJS.ProcessEnv, home: string): AccountEnvelope;

package/dist/telemetry/account-envelope.js

@@ -0,0 +1,61 @@
+/**
+ * Where this machine stands with the platform, for every telemetry event: signed out, signed in, or
+ * this project linked to a workspace, and that workspace's id.
+ *
+ * Read from what the CLI already wrote, never asked of the network: the session file (through
+ * `readAccountState`, which cannot carry the token) and the project's `.reticle/cloud.json`. Read per
+ * event, because a sign-in from the HUD changes the answer mid-session.
+ *
+ * The workspace id is the platform's `orgId`: pseudonymous here, and the key the platform joins its
+ * own records on. The workspace NAME and the signed-in email are never read into this.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ReticleDir } from '@reticlehq/core';
+import { TelemetryAccountState } from '@reticlehq/core/telemetry';
+import { readAccountState } from '../memory/cloud/account-state.js';
+import { linkDirectoryFrom } from '../memory/project/link-directory.js';
+const MAX_WORKSPACE_ID = 128;
+/** The link this project carries, if it is a real one (a project id and a host). */
+function readLink(dir) {
+    try {
+        const raw = JSON.parse(readFileSync(join(dir, ReticleDir.ROOT, ReticleDir.CLOUD_LINK_FILE), 'utf8'));
+        if ('object' !== typeof raw || null === raw)
+            return undefined;
+        const o = raw;
+        const projectId = o['projectId'];
+        const url = o['url'];
+        if ('string' !== typeof projectId || 0 === projectId.length)
+            return undefined;
+        if ('string' !== typeof url || 0 === url.length)
+            return undefined;
+        const orgId = o['orgId'];
+        return 'string' === typeof orgId && 0 < orgId.length && orgId.length <= MAX_WORKSPACE_ID
+            ? { orgId }
+            : {};
+    }
+    catch {
+        return undefined;
+    }
+}
+export function accountEnvelope(cwd, env, home) {
+    let link;
+    try {
+        link = readLink(linkDirectoryFrom(cwd)) ?? readLink(cwd);
+    }
+    catch {
+        link = undefined;
+    }
+    if (link !== undefined) {
+        return {
+            accountState: TelemetryAccountState.LINKED,
+            linked: true,
+            ...(link.orgId === undefined ? {} : { workspaceId: link.orgId }),
+        };
+    }
+    const signedIn = readAccountState(home, env).signedIn;
+    return {
+        accountState: signedIn ? TelemetryAccountState.SIGNED_IN : TelemetryAccountState.SIGNED_OUT,
+        linked: false,
+    };
+}

package/dist/telemetry/agent-client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Which coding agent an event came from, as a closed value — and how the running `reticle` was
+ * launched. Both are envelope fields, read per event (the client) or once per process (the launch).
+ *
+ * The client is the MCP handshake's `clientInfo.name` for the call in flight (or the only agent
+ * attached), normalised by `agentClientOf`. When no handshake has said anything — a one-shot CLI
+ * command, a proxy, a client that skipped `initialize` — the agent's own marker in the environment
+ * of what it spawned is the fallback. Only markers an agent sets on purpose are read.
+ */
+import { AgentClient, LaunchMethod } from '@reticlehq/core/telemetry';
+export declare function envAgentClient(env: NodeJS.ProcessEnv): AgentClient | undefined;
+/** The client for an event being built now. */
+export declare function currentAgentClient(env: NodeJS.ProcessEnv): AgentClient | undefined;
+/** How the process was launched, from the path of its entry script. Only the bucket leaves. */
+export declare function launchMethodOf(entry: string | undefined): LaunchMethod;

package/dist/telemetry/agent-client.js

@@ -0,0 +1,57 @@
+/**
+ * Which coding agent an event came from, as a closed value — and how the running `reticle` was
+ * launched. Both are envelope fields, read per event (the client) or once per process (the launch).
+ *
+ * The client is the MCP handshake's `clientInfo.name` for the call in flight (or the only agent
+ * attached), normalised by `agentClientOf`. When no handshake has said anything — a one-shot CLI
+ * command, a proxy, a client that skipped `initialize` — the agent's own marker in the environment
+ * of what it spawned is the fallback. Only markers an agent sets on purpose are read.
+ */
+import { AgentClient, LaunchMethod } from '@reticlehq/core/telemetry';
+import { agentClientOf, callingClientName } from '../hooks/coding-agents.js';
+/**
+ * Environment markers a coding agent sets on the processes it spawns. A shared daemon inherits the
+ * environment of whichever agent started it, so this is a fallback after the handshake, never ahead
+ * of it.
+ */
+const ENV_MARKERS = [
+    ['CLAUDECODE', AgentClient.CLAUDE_CODE],
+    ['CODEX_SANDBOX', AgentClient.CODEX],
+    ['CODEX_MANAGED_BY_NPM', AgentClient.CODEX],
+    ['CURSOR_TRACE_ID', AgentClient.CURSOR],
+    ['GEMINI_CLI', AgentClient.GEMINI_CLI],
+];
+export function envAgentClient(env) {
+    return ENV_MARKERS.find(([key]) => (env[key] ?? '') !== '')?.[1];
+}
+/** The client for an event being built now. */
+export function currentAgentClient(env) {
+    return agentClientOf(callingClientName()) ?? envAgentClient(env);
+}
+/**
+ * Where a global install puts packages, by package manager. A path that matches none of these but
+ * still sits in a `node_modules` is a project's own dependency.
+ */
+const GLOBAL_DIRS = [
+    '/lib/node_modules/',
+    '/npm/node_modules/',
+    '/pnpm/global/',
+    '/.volta/',
+    '/.bun/install/global/',
+    '/yarn/global/',
+    '/.nvm/',
+    '/.npm-global/',
+];
+/** How the process was launched, from the path of its entry script. Only the bucket leaves. */
+export function launchMethodOf(entry) {
+    if (entry === undefined)
+        return LaunchMethod.OTHER;
+    const path = entry.replace(/\\/g, '/').toLowerCase();
+    if (path.includes('/_npx/') || path.includes('/dlx-'))
+        return LaunchMethod.NPX;
+    if (GLOBAL_DIRS.some((dir) => path.includes(dir)))
+        return LaunchMethod.GLOBAL;
+    if (path.includes('/node_modules/'))
+        return LaunchMethod.PROJECT;
+    return LaunchMethod.OTHER;
+}

package/dist/telemetry/app-instrumented.js

@@ -15,8 +15,10 @@
  */
 import { OnboardingPhase, OnboardingStepStatus, TelemetryEventKind, } from '@reticlehq/core/telemetry';
 import { getTelemetry } from './telemetry.js';
-import { reportOnboardingStep } from './onboarding-funnel.js';
+import { FirstEver, claimFirstEver, reportFirstStep } from './onboarding-firsts.js';
 let reported = false;
+/** The on-disk claim for the EVENT, kept apart from the `app_connected` step's own claim. */
+const APP_INSTRUMENTED_CLAIM = 'app_instrumented';
 /** Set at daemon start so the first connect can report how long the install sat un-instrumented. */
 let daemonStartedAt;
 export function markInstrumentationClock(now) {
@@ -32,8 +34,13 @@ export function reportAppInstrumented(facts, now = () => Date.now()) {
         return;
     reported = true;
     try {
+        // Still once per RUN: `daemon_started` minus `app_instrumented`, joined on sessionId, is the
+        // documented failure side and needs a row per run. Only the true first on this machine +
+        // project says `firstEver`, so a per-machine count no longer counts daemon restarts.
+        const firstEver = FirstEver.FIRST === claimFirstEver(APP_INSTRUMENTED_CLAIM);
         void getTelemetry().emit(TelemetryEventKind.APP_INSTRUMENTED, {
             instrumentation: {
+                ...(firstEver ? { firstEver: true } : {}),
                 initialized: facts.initialized,
                 agentAttached: facts.agentAttached,
                 // How long the daemon ran before an app showed up. Large values are the interesting ones:
@@ -47,7 +54,7 @@ export function reportAppInstrumented(facts, now = () => Date.now()) {
         //
         // `instrumented` means files were written; THIS means a page actually dialled the bridge. Every
         // silent install bug so far has lived in the gap between those two.
-        void reportOnboardingStep({
+        reportFirstStep({
             phase: OnboardingPhase.FIRST_RUN,
             step: 'app_connected',
             status: OnboardingStepStatus.COMPLETED,

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;