@reticlehq/server 2.11.0 → 2.13.0

package/dist/telemetry/feedback-context.js

@@ -9,11 +9,12 @@
  * holds to. Detection is entirely best-effort: an unreadable package.json or an SDK too old to report
  * its runtime yields `undefined`, never a throw and never a guess.
  */
+import { mcpClientIdentity, setMcpClientIdentityHook } from '../mcp/client-identity.js';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
-import { AppRuntime, McpScope, PageDriver } from '@reticlehq/core';
+import { AppRuntime, McpScope, PageDriver, StackUnknownReason, } from '@reticlehq/core';
 import { parseMajor } from '../init/detect.js';
-import { findWorkspaceApps } from '../init/run.js';
+import { findWorkspaceApps } from '../init/workspace-apps.js';
 /**
  * Dependency → reported stack, in resolution order. Meta-frameworks come FIRST: a Next app also
  * depends on react, and reporting `react` for it would collapse the single most important segment
@@ -40,10 +41,14 @@ const PACKAGE_JSON = 'package.json';
 /** A project-scoped MCP registration lives in one of these; `reticle init` writes user scope instead. */
 const PROJECT_MCP_FILES = ['.mcp.json', join('.cursor', 'mcp.json'), join('.vscode', 'mcp.json')];
 /**
- * The project's framework and its MAJOR version, or `{}` when package.json is absent, unreadable, or
- * names nothing we recognize. The major comes from `parseMajor` — the same range parser `reticle init`
- * uses to decide React 19 source mapping — so a range like `^15.0.0-canary.3` narrows the same way in
- * both places instead of via a second, subtly different reader.
+ * The project's framework and its MAJOR version. The major comes from `parseMajor` — the same range
+ * parser `reticle init` uses to decide React 19 source mapping — so a range like `^15.0.0-canary.3`
+ * narrows the same way in both places instead of via a second, subtly different reader.
+ *
+ * `no-manifest` covers absent AND unreadable: both mean this directory could not answer, which is
+ * the distinction that matters to the caller. Unreadable is not separated because a manifest we
+ * cannot parse is not evidence about the app, and a reason nobody can act on is noise in a closed
+ * vocabulary.
  */
 function stackOfManifest(dir, read) {
     let pkg;
@@ -51,7 +56,7 @@ function stackOfManifest(dir, read) {
         pkg = JSON.parse(read(join(dir, PACKAGE_JSON)));
     }
     catch {
-        return {};
+        return { kind: 'no-manifest' };
     }
     const deps = { ...pkg.devDependencies, ...pkg.dependencies };
     for (const [dep, stack] of STACK_BY_DEP) {
@@ -59,15 +64,17 @@ function stackOfManifest(dir, read) {
         if (range === undefined)
             continue;
         const stackMajor = parseMajor(range);
-        return { stack, ...(stackMajor !== undefined ? { stackMajor } : {}) };
+        return { kind: 'found', stack, ...(stackMajor !== undefined ? { stackMajor } : {}) };
     }
-    return {};
+    return { kind: 'unrecognised', declaresWorkspaces: pkg.workspaces !== undefined };
 }
 export function detectStack(cwd, read = readFile) {
     // The cwd wins when it IS an app — never redirect away from the real answer.
     const here = stackOfManifest(cwd, read);
-    if (here.stack !== undefined)
-        return { ...here, stackSource: 'cwd' };
+    if ('found' === here.kind) {
+        const { stack, stackMajor } = here;
+        return { stack, ...(stackMajor !== undefined ? { stackMajor } : {}), stackSource: 'cwd' };
+    }
     // Otherwise look for the app. The daemon's cwd is wherever the agent's client happened to launch,
     // which for a real repo is the ROOT while the app sits in `frontend/`, `web/`, or a declared
     // workspace. Reading one directory and giving up is why this returned nothing for every project
@@ -78,19 +85,53 @@ export function detectStack(cwd, read = readFile) {
     // declared workspaces (pnpm-workspace.yaml, package.json `workspaces`) AND scans top-level
     // directories, and it was widened once already for a repo shape a user hit twice. A second
     // detector here would drift from it the first time either changed.
+    //
+    // Every exit below carries WHY, because an empty result is not a cause. Four different facts used
+    // to arrive as one `{}`: no app anywhere, an app we read and did not recognise, workspace apps
+    // that were all unrecognised, and discovery erroring. They have different fixes, and the bucket
+    // was unusable while they were indistinguishable (#617).
+    let sawWorkspaceApp = false;
     try {
         for (const app of findWorkspaceApps(profileIo(cwd))) {
             const found = stackOfManifest(join(cwd, app), read);
             // Reported as `workspace` so the share of projects needing discovery is measurable — that
             // number is what says whether our inference needs an agent to correct it.
-            if (found.stack !== undefined)
-                return { ...found, stackSource: 'workspace' };
+            if ('found' === found.kind) {
+                const { stack, stackMajor } = found;
+                return {
+                    stack,
+                    ...(stackMajor !== undefined ? { stackMajor } : {}),
+                    stackSource: 'workspace',
+                };
+            }
+            // A manifest we READ and did not recognise is evidence about the app; a directory with no
+            // manifest is not an app at all and says nothing either way.
+            if ('unrecognised' === found.kind)
+                sawWorkspaceApp = true;
         }
     }
     catch {
         // Discovery touches the filesystem; a permission error must never cost us the profile event.
+        // Named rather than folded into "found nothing": an error is not an absence, and a detector
+        // that reports one as the other sends the reader looking for a project that was there.
+        return { stackUnknownReason: StackUnknownReason.DISCOVERY_FAILED };
+    }
+    if (sawWorkspaceApp) {
+        return { stackUnknownReason: StackUnknownReason.WORKSPACE_APPS_UNRECOGNISED };
     }
-    return {};
+    // The cwd's own manifest is the stronger statement when it exists: we read this app and did not
+    // know it. Ranked below the workspace answer only because discovery may have found the REAL app.
+    if ('unrecognised' === here.kind) {
+        // A monorepo root naming no framework is not an unrecognised APP — the app is a directory down
+        // and discovery did not surface it. Reporting MANIFEST_UNRECOGNISED here would read as "add
+        // this framework to the table" about a manifest that describes no framework at all.
+        return {
+            stackUnknownReason: here.declaresWorkspaces
+                ? StackUnknownReason.WORKSPACE_ROOT_NO_APPS
+                : StackUnknownReason.MANIFEST_UNRECOGNISED,
+        };
+    }
+    return { stackUnknownReason: StackUnknownReason.NO_APP_FOUND };
 }
 /**
  * The three filesystem methods `findWorkspaceApps` needs, rooted at `cwd`.
@@ -150,26 +191,16 @@ function fileExists(path) {
  * client's own claim about itself, while an env-var table is a guess that silently rots every time a
  * vendor renames a variable. Unset (a CLI run with no MCP peer) simply reports no client.
  */
-let clientNameHook;
+/** Kept as the telemetry-facing name; the mechanism itself lives in mcp/client-identity.ts. */
 export function setMcpClientNameHook(hook) {
-    clientNameHook = hook;
+    setMcpClientIdentityHook(hook);
 }
-/**
- * The client's own name and version from its handshake.
- *
- * Note what is NOT here and cannot be: the MODEL. MCP's `clientInfo` carries a name, a title and a
- * version and has no concept of a model, so the transport genuinely cannot tell us. The agent
- * self-reports it on the feedback itself, which is the only mechanism available and a reliable one
- * given the report is already something the agent authored.
- */
 function detectClient() {
     try {
-        const info = clientNameHook?.();
-        const name = info?.name;
-        const version = info?.version;
+        const info = mcpClientIdentity();
         return {
-            ...(name !== undefined && name !== '' ? { client: name.slice(0, 64) } : {}),
-            ...(version !== undefined && version !== '' ? { clientVersion: version.slice(0, 32) } : {}),
+            ...(info.name === undefined ? {} : { client: info.name }),
+            ...(info.version === undefined ? {} : { clientVersion: info.version }),
         };
     }
     catch {

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

@@ -0,0 +1,15 @@
+import type { Feedback } from '@reticlehq/core';
+export interface SavedFeedback {
+    path: string;
+    /** A ready-to-run command that turns the file into an issue. */
+    command: string;
+}
+/**
+ * Write the report under `<cwd>/.reticle/feedback/`. Returns undefined if it cannot be written —
+ * a feedback save that throws would take down the tool call that was reporting a problem, which is
+ * the one outcome worse than losing the report.
+ */
+export declare function saveFeedbackLocally(cwd: string, input: {
+    kind?: string;
+    source?: string;
+}, text: string, context: Partial<Feedback>, now?: number): SavedFeedback | undefined;

package/dist/telemetry/feedback-local.js

@@ -0,0 +1,56 @@
+/**
+ * Where a feedback report goes when it cannot be sent.
+ *
+ * The report is fully written and redacted by the time delivery is refused. Throwing it away
+ * punishes exactly the behaviour the channel exists to encourage — and it hits hardest where the
+ * reports are best, because a Reticle source checkout disables telemetry by cwd, so the contributor
+ * who can name the file and the line is the one person who cannot file at all.
+ *
+ * Writing it down costs nothing and loses nothing. The receipt then carries a path and a command,
+ * so the human is handed one thing to run instead of being asked to retype what an agent already
+ * wrote.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ReticleDir } from '@reticlehq/core';
+/** Reports live beside the rest of the workspace, not in a temp dir somebody has to be told about. */
+const FEEDBACK_SUBDIR = 'feedback';
+/** Filesystem-safe, sortable, and unique enough for one report per second per kind. */
+const stamp = (now) => new Date(now).toISOString().replace(/[:.]/g, '-').replace('Z', '');
+const asMarkdown = (input, text, context) => {
+    const title = `Reticle feedback: ${input.kind ?? 'note'}`;
+    return [
+        `# ${title}`,
+        '',
+        text.trim(),
+        '',
+        '## Context',
+        '',
+        '```json',
+        JSON.stringify(context, null, 2),
+        '```',
+        '',
+    ].join('\n');
+};
+/**
+ * Write the report under `<cwd>/.reticle/feedback/`. Returns undefined if it cannot be written —
+ * a feedback save that throws would take down the tool call that was reporting a problem, which is
+ * the one outcome worse than losing the report.
+ */
+export function saveFeedbackLocally(cwd, input, text, context, now = Date.now()) {
+    try {
+        const dir = join(cwd, ReticleDir.ROOT, FEEDBACK_SUBDIR);
+        mkdirSync(dir, { recursive: true });
+        const path = join(dir, `${stamp(now)}-${input.kind ?? 'note'}.md`);
+        writeFileSync(path, asMarkdown(input, text, context), 'utf8');
+        return {
+            path,
+            // `--body-file` rather than an inlined body: the report contains newlines, quotes and JSON,
+            // and a command somebody has to repair before running is a command they do not run.
+            command: `gh issue create --repo reticlehq/reticle --title "Reticle feedback: ${input.kind ?? 'note'}" --body-file "${path}"`,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -1,5 +1,5 @@
 /** One queued report: the payload, plus what is needed to find and remove it again. */
-export interface OutboxEntry {
+interface OutboxEntry {
     id: string;
     t: string;
     payload: unknown;
@@ -20,3 +20,4 @@ export declare function readOutbox(home?: string): OutboxEntry[];
  * Volume is a handful of lines a week, so the cost is irrelevant.
  */
 export declare function markDelivered(id: string | null, home?: string): void;
+export {};

package/dist/telemetry/feedback.d.ts

@@ -55,6 +55,17 @@ export interface FeedbackReceipt {
      */
     accepted: boolean;
     reason?: string;
+    /**
+     * Where the report was written when it could not be SENT.
+     *
+     * A refusal used to be the end of the road: the report was already written by then, and throwing
+     * it away punished exactly the behaviour this channel exists to encourage. Worse, the commonest
+     * refusal is a Reticle SOURCE CHECKOUT — so the reporter best placed to name a file and a line was
+     * the only one who could not file at all.
+     */
+    savedTo?: string;
+    /** A ready-to-run command that turns the saved file into an issue. */
+    fileWith?: string;
     /** Which redaction rules fired. Empty when nothing needed removing. */
     redacted: string[];
     /** The exact context that went with it, echoed back so the send is never a black box. */

package/dist/telemetry/feedback.js

@@ -26,6 +26,7 @@ import { platform } from 'node:os';
 import { getTelemetry } from './telemetry.js';
 import { noteFeedbackUndelivered } from './feedback-delivery.js';
 import { isReticleSourceCheckout } from './dev-repo.js';
+import { saveFeedbackLocally } from './feedback-local.js';
 import { SERVER_VERSION } from '../version/server-version.js';
 import { feedbackContext } from './feedback-context.js';
 import { markDelivered, outboxPath, queueFeedback } from './feedback-outbox.js';
@@ -140,15 +141,27 @@ export async function submitFeedback(input, opts = {}) {
     }
     const telemetry = getTelemetry();
     if (!telemetry.enabled) {
+        /*
+         * Cannot SEND is not the same as cannot FILE.
+         *
+         * The report is fully written and redacted by this point. Discarding it punishes the exact
+         * behaviour this channel exists to encourage, and it hits hardest where the reports are best: a
+         * Reticle source checkout disables telemetry by cwd, so a contributor who can name the file and
+         * the line was the one person who could not file at all.
+         *
+         * So it goes to disk and the receipt says where, plus a command that turns it into an issue.
+         * Nothing is lost, and the human is handed one thing to run rather than asked to retype it.
+         */
+        const cwd = opts.cwd ?? process.cwd();
+        const saved = saveFeedbackLocally(cwd, input, body.text, context);
         return {
             sent: false,
             accepted: false,
-            // Named precisely, because the commonest cause is not what the old wording suggested: a
-            // Reticle SOURCE CHECKOUT disables telemetry by cwd, and that is exactly where release runs and
-            // contributor sessions happen — so the reports most worth having were the ones silently lost.
-            reason: isReticleSourceCheckout(opts.cwd ?? process.cwd())
-                ? 'this is a Reticle source checkout, where telemetry is disabled by design, so feedback has nowhere to go. Open an issue at https://github.com/reticlehq/reticle/issues instead, or run from the app you are verifying.'
-                : `telemetry is disabled on this machine, so feedback has nowhere to go. Re-enable with \`reticle telemetry enable\`, or open an issue at https://github.com/reticlehq/reticle/issues.`,
+            // Named precisely, because the commonest cause is not what the old wording suggested.
+            reason: isReticleSourceCheckout(cwd)
+                ? 'this is a Reticle source checkout, where telemetry is disabled by design, so this could not be sent — it has been written to disk instead, and nothing was lost.'
+                : `telemetry is disabled on this machine, so this could not be sent — it has been written to disk instead. Re-enable with \`reticle telemetry enable\` to send directly.`,
+            ...(saved === undefined ? {} : { savedTo: saved.path, fileWith: saved.command }),
             redacted,
             context,
         };

package/dist/telemetry/init-telemetry.d.ts

@@ -15,6 +15,8 @@ import { type InitOutcome } from '@reticlehq/core';
 export declare const InitFailure: {
     /** Run outside a project root. The single most common first-run mistake. */
     readonly NO_PACKAGE_JSON: "no_package_json";
+    /** The manifest exists and is not valid JSON — a trailing comma, usually. Never a stack trace. */
+    readonly MALFORMED_PACKAGE_JSON: "malformed_package_json";
     /** The package manager failed: offline, a locked registry, a broken install. */
     readonly DEPENDENCY_INSTALL: "dependency_install";
     /** The `claude mcp add` step failed — the CLI is missing or refused. Reticle installs but is unreachable. */

package/dist/telemetry/init-telemetry.js

@@ -17,6 +17,8 @@ import { resolveInstallSource } from './install-source.js';
 export const InitFailure = {
     /** Run outside a project root. The single most common first-run mistake. */
     NO_PACKAGE_JSON: 'no_package_json',
+    /** The manifest exists and is not valid JSON — a trailing comma, usually. Never a stack trace. */
+    MALFORMED_PACKAGE_JSON: 'malformed_package_json',
     /** The package manager failed: offline, a locked registry, a broken install. */
     DEPENDENCY_INSTALL: 'dependency_install',
     /** The `claude mcp add` step failed — the CLI is missing or refused. Reticle installs but is unreachable. */

package/dist/telemetry/install-source.d.ts

@@ -54,3 +54,17 @@ export declare function declaredInstallSource(env?: NodeJS.ProcessEnv): InstallS
  * data, and a hand-edited one must not be able to put an arbitrary string on the wire.
  */
 export declare function projectInstallSource(cwd: string, env?: NodeJS.ProcessEnv): InstallSource;
+/**
+ * The same config with `installSource` added, or `undefined` when there is nothing to add.
+ *
+ * `installSource` is written only when `.reticle.json` is CREATED, and `init` reports that file as
+ * `already exists` on every re-run — so everyone who was already here when the marker shipped, and
+ * everyone who ran `init` once without one, keeps `unknown` forever with no way to fix it. That is
+ * most of the population the field exists to describe.
+ *
+ * An EXISTING value is never overwritten. The first channel is the one that brought the user in, and
+ * a later `init` through a different route must not take credit for an acquisition it did not make.
+ * Anything unparseable is left exactly as it is: a config is user data, and `init` rewriting a file
+ * it could not read would be a far worse failure than a missing dimension.
+ */
+export declare function configWithInstallSource(source: string | null | undefined, declared: string | undefined): string | undefined;

package/dist/telemetry/install-source.js

@@ -72,3 +72,33 @@ export function projectInstallSource(cwd, env = process.env) {
     }
     return resolveInstallSource(env);
 }
+/**
+ * The same config with `installSource` added, or `undefined` when there is nothing to add.
+ *
+ * `installSource` is written only when `.reticle.json` is CREATED, and `init` reports that file as
+ * `already exists` on every re-run — so everyone who was already here when the marker shipped, and
+ * everyone who ran `init` once without one, keeps `unknown` forever with no way to fix it. That is
+ * most of the population the field exists to describe.
+ *
+ * An EXISTING value is never overwritten. The first channel is the one that brought the user in, and
+ * a later `init` through a different route must not take credit for an acquisition it did not make.
+ * Anything unparseable is left exactly as it is: a config is user data, and `init` rewriting a file
+ * it could not read would be a far worse failure than a missing dimension.
+ */
+export function configWithInstallSource(source, declared) {
+    if (undefined === declared || null === source || undefined === source)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        return undefined;
+    }
+    if (null === parsed || 'object' !== typeof parsed || Array.isArray(parsed))
+        return undefined;
+    const fields = parsed;
+    if (undefined !== fields['installSource'])
+        return undefined;
+    return `${JSON.stringify({ ...fields, installSource: declared }, null, 2)}\n`;
+}

package/dist/telemetry/license-activation.d.ts

@@ -30,6 +30,12 @@ import { LicenseActivation } from '@reticlehq/core';
 export interface LicenseFacts {
     licenseId?: string;
     licenseStatus?: LicenseActivation;
+    /**
+     * A key was placed, whether or not this build could judge it. See LICENSE_KEY_PRESENT in core.
+     * Reported even in evaluation mode, which is the whole point: that is the case where every other
+     * licence property is deliberately silent.
+     */
+    licenseKeyPresent?: boolean;
 }
 /**
  * Resolve activation for one event. The clock is passed in (rule 7) and is the EVENT's clock, not a
@@ -45,4 +51,4 @@ export interface LicenseFacts {
  * Never throws. A telemetry property may not change behaviour (rule 5), and this one sits in front of
  * key parsing, which is the part most likely to be handed something malformed.
  */
-export declare function licenseFacts(now: number, env?: NodeJS.ProcessEnv): LicenseFacts;
+export declare function licenseFacts(now: number, env?: NodeJS.ProcessEnv, baked?: string): LicenseFacts;

package/dist/telemetry/license-activation.js

@@ -26,7 +26,7 @@
  * holds a customer list.
  */
 import { LicenseActivation } from '@reticlehq/core';
-import { describeLicense } from '../license/license.js';
+import { describeLicense, LICENSE_KEY_ENV } from '../license/license.js';
 /**
  * Resolve activation for one event. The clock is passed in (rule 7) and is the EVENT's clock, not a
  * value captured at startup: sessions here run to eleven hours, so a key that expires mid-session must
@@ -41,13 +41,17 @@ import { describeLicense } from '../license/license.js';
  * Never throws. A telemetry property may not change behaviour (rule 5), and this one sits in front of
  * key parsing, which is the part most likely to be handed something malformed.
  */
-export function licenseFacts(now, env = process.env) {
+export function licenseFacts(now, env = process.env, baked) {
     try {
-        const report = describeLicense(now, env);
-        if (LicenseActivation.EVAL === report.status)
-            return {};
+        const report = baked === undefined ? describeLicense(now, env) : describeLicense(now, env, baked);
+        // Asked BEFORE the eval short-circuit, because eval is exactly the case that used to be silent.
+        const keyPresent = (env[LICENSE_KEY_ENV] ?? '').length > 0;
+        if (LicenseActivation.EVAL === report.status) {
+            return keyPresent ? { licenseKeyPresent: true } : {};
+        }
         return {
             licenseStatus: report.status,
+            ...(keyPresent ? { licenseKeyPresent: true } : {}),
             ...(report.licenseId !== undefined ? { licenseId: report.licenseId } : {}),
         };
     }

package/dist/telemetry/mcp-connection.js

@@ -11,6 +11,7 @@
  */
 import { TelemetryEventKind } from '@reticlehq/core';
 import { getTelemetry } from './telemetry.js';
+import { appEverConnected } from './app-instrumented.js';
 let connectsSeen = 0;
 /** Set when the daemon starts, so the FIRST connect can report how long Reticle sat unused. */
 let daemonStartedAt;
@@ -30,6 +31,12 @@ export function reportMcpConnected(client, now = () => Date.now()) {
                 // sat there. On a reconnect it is just how long the daemon has been up.
                 daemonAgeMs: daemonStartedAt === undefined ? 0 : Math.max(0, now() - daemonStartedAt),
                 ...(client !== undefined ? { client } : {}),
+                // WHAT THE AGENT HAD TO LOOK AT. Most clients that attach never call a tool, and that cohort
+                // emits nothing at all — an agent that reads the instructions, learns nothing is wired and
+                // stops has refused nothing, so `tool_refused` cannot see it either. Read off the same flag
+                // `app_instrumented` sets, never a second counter, so the two halves of the funnel cannot
+                // disagree about one daemon run.
+                appConnected: appEverConnected(),
             },
         });
     }

package/dist/telemetry/project-profile.d.ts

@@ -13,9 +13,6 @@ export declare const FeatureFamily: {
     readonly BUG_CAPSULES: "bug_capsules";
     readonly CROSS_RUN_HISTORY: "cross_run_history";
 };
-export type FeatureFamily = (typeof FeatureFamily)[keyof typeof FeatureFamily];
-/** Count source files, stopping at the cap (the cap itself lands in the largest bucket, correctly). */
-export declare function countSourceFiles(root: string, readDir?: DirReader): number;
 export declare function sizeBucket(sourceFiles: number): ProjectSize;
 /**
  * Project age in whole WEEKS, from the repo's first commit.
@@ -30,15 +27,21 @@ export declare function sizeBucket(sourceFiles: number): ProjectSize;
 export declare function projectAgeWeeks(root: string, now: number, read?: FileReader): number | undefined;
 /** True when package.json declares workspaces — monorepos exercise very different code paths. */
 export declare function isMonorepo(root: string, read?: FileReader): boolean;
-interface DirEntry {
-    name: string;
-    isDirectory: boolean;
-}
-type DirReader = (dir: string) => DirEntry[];
 type FileReader = (path: string) => string;
 /**
  * Build the full profile. Best-effort throughout: an unreadable project yields a profile of zeroes
  * rather than an exception, because a telemetry snapshot must never be able to fail a daemon start.
  */
-export declare function profileProject(cwd: string, now: number): ProjectProfile;
+/**
+ * Facts about the install that the filesystem cannot answer.
+ *
+ * Passed in rather than read here for the same reason `previouslyConnected` is passed to the MCP
+ * server: it needs the daemon's port and the state home, and a profile that reached for those would
+ * stop being a pure function of a directory.
+ */
+export interface InstallFacts {
+    /** Has an app for this project EVER connected to Reticle, from durable state. */
+    appConnectedBefore: boolean;
+}
+export declare function profileProject(cwd: string, now: number, install?: InstallFacts): ProjectProfile;
 export {};

package/dist/telemetry/project-profile.js

@@ -15,6 +15,7 @@ import { join } from 'node:path';
 import { ProjectSize, ReticleDir } from '@reticlehq/core';
 import { gitFacts } from './git-facts.js';
 import { detectStack } from './feedback-context.js';
+import { readProjectId } from '../cli/cli-port.js';
 /**
  * The feature FAMILIES, and the on-disk evidence that a project has adopted each. Named rather than
  * counted so the vocabulary stays stable as tools are added, renamed, or merged into action-dispatched
@@ -45,7 +46,7 @@ const MAX_FILES_SCANNED = 6000;
 const MAX_WALK_DEPTH = 8;
 const MS_PER_WEEK = 7 * 24 * 60 * 60 * 1000;
 /** Count source files, stopping at the cap (the cap itself lands in the largest bucket, correctly). */
-export function countSourceFiles(root, readDir = defaultReadDir) {
+function countSourceFiles(root, readDir = defaultReadDir) {
     let count = 0;
     const walk = (dir, depth) => {
         if (depth > MAX_WALK_DEPTH || count >= MAX_FILES_SCANNED)
@@ -151,11 +152,7 @@ function exists(path) {
         return false;
     }
 }
-/**
- * Build the full profile. Best-effort throughout: an unreadable project yields a profile of zeroes
- * rather than an exception, because a telemetry snapshot must never be able to fail a daemon start.
- */
-export function profileProject(cwd, now) {
+export function profileProject(cwd, now, install) {
     const reticleRoot = join(cwd, ReticleDir.ROOT);
     const flowCount = countIn(reticleRoot, ReticleDir.FLOWS_SUBDIR, /\.json$/);
     const baselineCount = countIn(reticleRoot, ReticleDir.BASELINES_SUBDIR);
@@ -180,7 +177,7 @@ export function profileProject(cwd, now) {
         featuresUsed.push(FeatureFamily.BUG_CAPSULES);
     if (hasHistory)
         featuresUsed.push(FeatureFamily.CROSS_RUN_HISTORY);
-    const { stack, stackMajor, stackSource } = detectStack(cwd);
+    const { stack, stackMajor, stackSource, stackUnknownReason } = detectStack(cwd);
     const ageWeeks = projectAgeWeeks(cwd, now);
     const git = gitFacts(cwd);
     return {
@@ -189,6 +186,8 @@ export function profileProject(cwd, now) {
         ...(stack !== undefined ? { stack } : {}),
         ...(stackSource !== undefined ? { stackSource } : {}),
         ...(stackMajor !== undefined ? { stackMajor } : {}),
+        // Present only when `stack` is absent, so the field's presence marks the unknown bucket.
+        ...(stackUnknownReason !== undefined ? { stackUnknownReason } : {}),
         size: sizeBucket(countSourceFiles(cwd)),
         monorepo: isMonorepo(cwd),
         ...(ageWeeks !== undefined ? { ageWeeks } : {}),
@@ -202,5 +201,11 @@ export function profileProject(cwd, now) {
         // Rounded to 2dp: the exact ratio is a function of the counts above, and an unrounded float would
         // just be a higher-cardinality restatement of them.
         featureDepth: Math.round((featuresUsed.length / ALL_FAMILIES.length) * 100) / 100,
+        // WHERE the install stopped, for the daemons that never see an app. `daemon_started` minus
+        // `app_instrumented` says one happened and cannot say why; these two bits split that silence
+        // into "never ran init", "ran it and no page has ever reached us", and "works, just not up
+        // right now". See the fields on ProjectProfileSchema.
+        initialized: readProjectId(cwd) !== undefined,
+        ...(install === undefined ? {} : { appConnectedBefore: install.appConnectedBefore }),
     };
 }

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

@@ -0,0 +1,3 @@
+import { type SessionMetrics } from './session-metrics.js';
+import { type Telemetry } from './telemetry.js';
+export declare function flushProxySessionMetrics(telemetry?: Telemetry, metrics?: SessionMetrics): Promise<void>;

package/dist/telemetry/proxy-telemetry.js

@@ -0,0 +1,21 @@
+/**
+ * The MCP proxy's session rollup.
+ *
+ * POST socket failures (`ENOBUFS`, `EMFILE`, `ECONNREFUSED` before any bytes were sent) happen in
+ * this process, not the daemon's. `tool_refused` never fires (the handler never ran) and
+ * `mcp_connection_lost` never fires (the SSE stream is fine). Counts live on SessionMetrics here
+ * and leave as one `session_progress` — an existing kind, omitted when nothing happened.
+ *
+ * The send is awaited. Fire-and-forget microseconds before `process.exit` is how `daemon_stopped`
+ * never arrived: the POST was killed every time and nothing threw.
+ */
+import { TelemetryEventKind } from '@reticlehq/core';
+import { getSessionMetrics } from './session-metrics.js';
+import { getTelemetry } from './telemetry.js';
+export async function flushProxySessionMetrics(telemetry = getTelemetry(), metrics = getSessionMetrics()) {
+    if (metrics.empty)
+        return;
+    await telemetry.emit(TelemetryEventKind.SESSION_PROGRESS, {
+        session: metrics.summarize(true),
+    });
+}

package/dist/telemetry/run-telemetry.d.ts

@@ -11,8 +11,6 @@
  * how a replay works.
  */
 import { type ReticleVerificationRun } from '@reticlehq/core';
-/** The tool name reported for this path, so CI runs are distinguishable from agent-driven ones. */
-export declare const VERIFY_SURFACE = "reticle_verify";
 /**
  * Report one completed verification run: the verdict, and one bug per failing flow.
  *

package/dist/telemetry/run-telemetry.js

@@ -14,7 +14,7 @@ import { BugAttribution, BugSource, RunFlowStatus, TelemetryActor, TelemetryEven
 import { getSessionMetrics } from './session-metrics.js';
 import { getTelemetry } from './telemetry.js';
 /** The tool name reported for this path, so CI runs are distinguishable from agent-driven ones. */
-export const VERIFY_SURFACE = 'reticle_verify';
+const VERIFY_SURFACE = 'reticle_verify';
 /**
  * Report one completed verification run: the verdict, and one bug per failing flow.
  *

package/dist/telemetry/session-metrics.d.ts

@@ -65,6 +65,18 @@ export declare class SessionMetrics {
      * one inside a much larger pile. Same treatment otherwise — fingerprinted, variables stripped.
      */
     recordSdkFailure(site: string, message: string): void;
+    /**
+     * The MCP proxy could not POST a tool call because the TCP socket itself failed (`ENOBUFS`,
+     * `EMFILE`, `ECONNREFUSED` before any bytes left). The SSE stream is still up, so this is
+     * invisible to `mcp_connection_lost`, and the handler never ran, so it is invisible to
+     * `tool_refused`. Counted so a dashboard can see it without a new event kind.
+     */
+    recordPostSocketFailure(): void;
+    /**
+     * A bounded retry of an unsent POST then delivered. The pair against `recordPostSocketFailure`:
+     * the retry that quietly saved a call is a different fact from the one that never ran.
+     */
+    recordPostRetrySaved(): void;
     /** The agent's recent approach run + the call in flight — context for a crash report. */
     get trail(): {
         breadcrumb: string[];