@reticlehq/server 2.3.0 → 2.5.0

package/dist/telemetry/bug-found.js

@@ -15,6 +15,7 @@
  * `console-error`, `duplicate-request`. Never a selector, a URL, an element, or a description of
  * anyone's app: that a class of defect was found, never what it was found in.
  */
+import { ReticleTool } from '../tools/tool-names.js';
 import { BugSource, ContradictionKind } from '@reticlehq/core';
 /** Cap per tool call — a pathological crawl must not turn one call into a thousand events. */
 const MAX_BUGS_PER_CALL = 25;
@@ -24,7 +25,7 @@ function kindsOf(value) {
     return value
         .map((entry) => {
         const kind = entry?.kind;
-        return typeof kind === 'string' ? kind : undefined;
+        return 'string' === typeof kind ? kind : undefined;
     })
         .filter((kind) => kind !== undefined);
 }
@@ -35,16 +36,111 @@ function kindsOf(value) {
  * the case the product exists for — the screen looked right, the write failed, and every other tool
  * on the market would have called it green. That pairing is what `falseGreen` marks.
  */
+/**
+ * The verdict this result carries, whatever envelope it arrived in.
+ *
+ * `reticle_assert` reports a top-level boolean `pass`. `reticle_act_and_wait` — the tool agents
+ * actually reach for, and the one whose description calls it the act->observe->assert loop — reports
+ * `verdict.pass` with the summary at `verified`. Reading only `result.pass` meant a FAILED
+ * act_and_wait produced no bug at all, and a contradiction found next to a PASSING one was recorded
+ * with `falseGreen: false` — deflating the single number this product exists to publish, by the
+ * shape of its own envelope.
+ */
+function verdictOf(result) {
+    if ('boolean' === typeof result['pass'])
+        return result['pass'];
+    const verdict = result['verdict'];
+    if ('object' === typeof verdict && verdict !== null) {
+        const nested = verdict['pass'];
+        if ('boolean' === typeof nested)
+            return nested;
+    }
+    // `verified` is the field the agent is told to gate on; "unknown" is deliberately not a verdict.
+    const verified = result['verified'];
+    if ('yes' === verified)
+        return true;
+    if ('no' === verified)
+        return false;
+    return undefined;
+}
+/** The assertion label, from either envelope — act_and_wait nests it under `verdict`. */
+function assertionOf(result) {
+    if (result['assertion'] !== undefined)
+        return result['assertion'];
+    const verdict = result['verdict'];
+    return 'object' === typeof verdict && verdict !== null
+        ? verdict['assertion']
+        : undefined;
+}
+/**
+ * A verdict that could not be reached is not a defect found. `inconclusive` is set when the
+ * assertion was never evaluated — an under-specified call, or nothing instrumented to read — so
+ * counting it would put the agent's own mistakes into the number we publish.
+ */
+function isInconclusive(result) {
+    const verdict = result['verdict'];
+    return ('object' === typeof verdict &&
+        verdict !== null &&
+        'string' === typeof verdict['inconclusive']);
+}
+/** A suite row whose replay never STARTED — see SuiteFlowResult.couldNotRun. */
+function couldNotRun(failure) {
+    return ('object' === typeof failure &&
+        failure !== null &&
+        true === failure.couldNotRun);
+}
+/**
+ * `bug.attribution` was REMOVED, deliberately, and this note is here so it is not re-added casually.
+ *
+ * It shipped twice and was wrong both times. First it stamped `app` on every contradiction, including
+ * `request-never-settled` — which Reticle raises from the ABSENCE of a settle event, so a dev-overlay
+ * poll manufactured it with the app doing nothing wrong. That was fixed, and a real drive then found
+ * it still inverted: across two full runs, EVERY `attribution: 'app'` was a misattribution, while the
+ * one defect that genuinely was a bad agent predicate carried none. One session would have published
+ * "2 defects in the app" against a true count of 0.
+ *
+ * A metric that is confidently wrong about WHOSE fault a defect is, is worse than no metric: it is
+ * the number a founder steers on, and it points at the customer. Counting nothing is recoverable;
+ * publishing a false accusation about somebody's product is not.
+ *
+ * Bringing it back needs evidence that actually separates the cases. It does not exist in the payload
+ * today: `element.present` covers "the button is missing", "the API is down" and "the agent mistyped
+ * a testid" identically, and `signal.absent` covers both a signal the app never fired and a ref
+ * Reticle drove into nothing. Until a verdict carries the reason it came out that way, the honest
+ * output is no owner at all.
+ */
 export function bugsInResult(toolName, result) {
+    // `reticle_run` is a WRAPPER: its handler calls runTool on the real tool, which already reported
+    // that result's defects under the real tool's name — then the outer chokepoint reports the very
+    // same object again as `reticle_run`. One sweep of 34 events was a perfect mirror image:
+    // flow-regression x8/reticle_flow_verify AND x8/reticle_run; assertion-failed x8/reticle_verify_change
+    // AND x8/reticle_run. Sixteen of the thirty-four were echoes, and a headline number that doubles
+    // because of HOW a tool was reached is not a measurement.
+    //
+    // Nothing is lost by staying silent here: when the inner tool refuses or throws, the wrapper
+    // returns { error, tool, params, hint }, which carries no verdict and no failures to classify.
+    if (toolName === ReticleTool.RUN)
+        return [];
     const bugs = [];
-    const passed = result['pass'] === true;
+    const verdict = verdictOf(result);
+    const passed = true === verdict;
     // 1. Contradictions — channels disagreeing. Invisible to a human watching the screen.
     for (const kind of kindsOf(result['contradictions'])) {
-        bugs.push({ source: BugSource.CONTRADICTION, kind, falseGreen: passed, tool: toolName });
+        // A contradiction is two of the APP's own channels disagreeing — never the agent's phrasing.
+        // Omitted for the one kind Reticle can produce on its own: see contradictionAttribution.
+        bugs.push({
+            source: BugSource.CONTRADICTION,
+            kind,
+            falseGreen: passed,
+            tool: toolName,
+        });
     }
     // 2. Crawl anomalies — found autonomously, with nobody writing a test. Crawl reports its own
     //    contradictions inside `anomalies` too, so classify by kind rather than by which array it sat in.
     for (const kind of kindsOf(result['anomalies'])) {
+        // Crawl reports contradictions in this array too, so the same kind must get the same owner
+        // wherever it arrives — a `request-never-settled` found by the crawler is no better evidence
+        // about whose fault it was than one found by an assertion.
         bugs.push({
             source: BugSource.CRAWL,
             kind,
@@ -52,28 +148,44 @@ export function bugsInResult(toolName, result) {
             // — even though no assertion was made. See the definition on `falseGreen`.
             falseGreen: CONTRADICTION_KINDS.has(kind),
             tool: toolName,
+            // Nobody wrote a predicate here, so there is no bad request to blame: a crawl anomaly is a
+            // fault the app produced on its own.
         });
     }
     // 3. A failed assertion — the agent declared a consequence and it did not hold.
     //    Only when nothing above already explained it, or one defect would be counted twice.
-    if (result['pass'] === false && bugs.length === 0) {
-        const reason = result['assertion'];
+    // A red the APP earned, not one Reticle produced. `verified: "unknown"` is the honesty layer
+    // saying nothing was proved either way, and a top-level `error` is a refusal — measured over one
+    // sweep, every bug_found emitted was one of these two: "no session connected" from reticle_run and
+    // an unverifiable suite from reticle_verify_change, counted as defects in the user's app.
+    const reticleFailure = 'unknown' === result['verified'] || 'string' === typeof result['error'];
+    if (false === verdict && 0 === bugs.length && !isInconclusive(result) && !reticleFailure) {
+        const reason = assertionOf(result);
+        const kind = 'string' === typeof reason && reason.length > 0 ? reason.slice(0, 64) : 'assertion-failed';
         bugs.push({
             source: BugSource.ASSERTION,
-            kind: typeof reason === 'string' && reason.length > 0 ? reason.slice(0, 64) : 'assertion-failed',
+            kind,
             falseGreen: false,
             tool: toolName,
+            // Omitted when the label cannot say whose fault it was — see ASSERTION_ATTRIBUTION.
         });
     }
     // 4. Replay failures — a saved flow that used to pass no longer does. That is a regression caught,
     //    which is a different and stronger claim than "a check failed".
-    if (result['status'] === 'fail' && Array.isArray(result['failures'])) {
-        for (const _failure of result['failures'].slice(0, MAX_BUGS_PER_CALL)) {
+    if ('fail' === result['status'] && Array.isArray(result['failures'])) {
+        for (const failure of result['failures'].slice(0, MAX_BUGS_PER_CALL)) {
+            // A suite that failed because nothing could RUN is not a regression in the user's app. This
+            // rule never looked past `status`, so a project whose flow files did not resolve reported one
+            // "defect found" per flow — Reticle's own failure, published as the customer's.
+            if (couldNotRun(failure))
+                continue;
             bugs.push({
                 source: BugSource.REPLAY,
                 kind: 'flow-regression',
                 falseGreen: false,
                 tool: toolName,
+                // A saved flow that used to pass and no longer does is a regression in the app. Rows that
+                // never RAN are skipped above precisely so Reticle's own failures do not land here.
             });
         }
     }

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

@@ -1,13 +1,3 @@
-/**
- * Report that a person ran a `reticle` subcommand.
- *
- * `_daemon` is EXCLUDED, and that exclusion is the whole point of this function. `reticle mcp` and
- * `reticle serve` start the daemon by re-running this very binary, so the child re-entered the CLI
- * entry point and emitted a second event for what a person experienced as ONE action. The old
- * `invoke` metric was therefore inflated ~2x — and inflated worst on the agent-driven sessions that
- * matter most, while one-shot commands like `version` counted once. That skewed the RATIO between
- * commands, not merely the scale, which is the kind of error you cannot correct for after the fact.
- * The daemon\'s own lifecycle is already reported by `daemon_started` / `daemon_stopped`; a spawned
- * daemon is not a CLI run.
- */
+/** True when this command represents a person typing something. Exported for the gate. */
+export declare function isHumanCliCommand(command: string): boolean;
 export declare function reportCliRun(argv: readonly string[]): void;

package/dist/telemetry/cli-telemetry.js

@@ -4,8 +4,8 @@
  * Lives in its own module so `cli.ts` stays a dispatcher, and so the `_daemon` exclusion below sits
  * next to the explanation of why it exists rather than buried in a startup function.
  */
-import { TelemetryActor, TelemetryEventKind } from '@reticlehq/core';
-import { DAEMON_INNER_COMMAND, knownCommand } from '../cli-parse.js';
+import { TelemetryEventKind } from '@reticlehq/core';
+import { DAEMON_INNER_COMMAND, knownCommand } from '../cli/cli-parse.js';
 import { getTelemetry } from './telemetry.js';
 import { describeCliFlags } from './argument-shape.js';
 /**
@@ -20,22 +20,45 @@ import { describeCliFlags } from './argument-shape.js';
  * The daemon\'s own lifecycle is already reported by `daemon_started` / `daemon_stopped`; a spawned
  * daemon is not a CLI run.
  */
+/**
+ * The agent's MCP transport, not a person. `reticle mcp` is what an MCP client runs to open a stdio
+ * connection — nobody types it. Measured over one real day it was 475 of 561 `cli_command_run`
+ * events (85%), on an event whose whole purpose is human intent, and the agent attaching is already
+ * reported by `mcp_client_connected` with strictly more detail (reconnect, daemon age, client).
+ *
+ * `serve` is NOT excluded: nothing spawns it on a person's behalf, so typing it is a real act.
+ */
+const AGENT_TRANSPORT_COMMAND = 'mcp';
+/** True when this command represents a person typing something. Exported for the gate. */
+export function isHumanCliCommand(command) {
+    return command !== AGENT_TRANSPORT_COMMAND && command !== DAEMON_INNER_COMMAND;
+}
 export function reportCliRun(argv) {
     const firstArg = argv[0];
     if (firstArg === DAEMON_INNER_COMMAND)
         return;
+    const command = knownCommand(firstArg);
     const telemetry = getTelemetry();
+    // FIRST — before the human-command filter. The install happened whichever command ran, and on most
+    // machines the very first contact is the agent spawning `reticle mcp`, which that filter excludes.
+    // Measured over one sweep: 15 `init_completed` and ZERO `reticle_installed`, in a run that
+    // installed the SDK into nine apps — the top of every funnel, missing.
     // `detach` so a quick command (`version`/`gate`) exits immediately instead of waiting out the POST.
     if (telemetry.firstRun)
         void telemetry.emit(TelemetryEventKind.RETICLE_INSTALLED, { detach: true });
+    if (!isHumanCliCommand(command))
+        return;
     void telemetry.emit(TelemetryEventKind.CLI_COMMAND_RUN, {
         detach: true,
-        actor: TelemetryActor.HUMAN,
+        // No `actor`: with the agent's transport excluded, this event is human BY DEFINITION. It was
+        // constant `human` on all 561 events in a real day — zero information, and wrong for the 475
+        // that were the agent. `actor` stays where it earns its place: verification_completed and
+        // bug_found, where it splits the agent's own loop from a human/CI-triggered run.
         // A fixed, low-cardinality vocabulary WE define, so it is safe to send whole and it is the closest
         // honest read we have on intent: `verify` and `gate` mean something very different from `status`.
         // An unrecognized first arg reports as `unknown` rather than being echoed — an echo would put
         // whatever someone mistyped, including a path or a URL, straight onto the wire.
-        command: knownCommand(firstArg),
+        command,
         // Which flags were PRESENT, by name only — never their values. `--http-token` alone makes that
         // rule absolute rather than case-by-case; `--drive` and `--storage-state` carry a URL and a path.
         flags: describeCliFlags(argv),

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

@@ -1,3 +1,22 @@
+/**
+ * How often a long-lived daemon flushes its counters.
+ *
+ * ponytail: coarse on purpose. A daemon that is SIGKILLed — OOM, a closed laptop, `kill -9` — never
+ * reaches its shutdown handler, so without this the whole session's counters die with it. Thirty
+ * minutes bounds that loss to one window while keeping the event volume near zero for the common case
+ * (most daemons stop cleanly and send exactly one summary). If the lost windows ever show up as a
+ * real gap, the upgrade is a small on-disk journal replayed at the next start, not a shorter timer.
+ */
+/**
+ * How often a running daemon rolls up its window.
+ *
+ * Exported because it is the BOUND ON WHAT IS LOST: a daemon that has served a tool never
+ * idle-exits, so nothing calls shutdown, so its last partial window dies with the process. At 30
+ * minutes against a median 28-minute session that meant the median session reported nothing at all.
+ * Only non-empty windows emit, so a shorter interval costs nothing on the 74% of daemons that never
+ * serve a tool.
+ */
+export declare const SESSION_FLUSH_MS: number;
 /** Stops the timers this installed. Called from the daemon's shutdown path. */
 export interface DaemonTelemetry {
     /**

package/dist/telemetry/daemon-telemetry.js

@@ -23,7 +23,16 @@ const PROJECT_PROFILE_DELAY_MS = 5_000;
  * (most daemons stop cleanly and send exactly one summary). If the lost windows ever show up as a
  * real gap, the upgrade is a small on-disk journal replayed at the next start, not a shorter timer.
  */
-const SESSION_FLUSH_MS = 30 * 60 * 1000;
+/**
+ * How often a running daemon rolls up its window.
+ *
+ * Exported because it is the BOUND ON WHAT IS LOST: a daemon that has served a tool never
+ * idle-exits, so nothing calls shutdown, so its last partial window dies with the process. At 30
+ * minutes against a median 28-minute session that meant the median session reported nothing at all.
+ * Only non-empty windows emit, so a shorter interval costs nothing on the 74% of daemons that never
+ * serve a tool.
+ */
+export const SESSION_FLUSH_MS = 5 * 60 * 1000;
 /**
  * Report the daemon as started, profile the project once, and keep the session counters flushing.
  * Every timer is `unref`'d so telemetry can never be the reason a daemon refuses to exit.
@@ -51,7 +60,8 @@ export function installDaemonTelemetry(cwd, now = () => Date.now()) {
     const flush = setInterval(() => {
         if (metrics.empty)
             return; // an idle window is not worth an event
-        void getTelemetry().emit(TelemetryEventKind.DAEMON_STOPPED, {
+        // NOT daemon_stopped: the daemon is still running. See SESSION_PROGRESS.
+        void getTelemetry().emit(TelemetryEventKind.SESSION_PROGRESS, {
             session: metrics.summarize(false),
         });
         metrics.reset();

package/dist/telemetry/dev-repo.js

@@ -21,7 +21,7 @@ export function isReticleSourceCheckout(cwd) {
         if (existsSync(pkg)) {
             try {
                 const parsed = JSON.parse(readFileSync(pkg, 'utf8'));
-                const name = typeof parsed === 'object' && parsed !== null
+                const name = 'object' === typeof parsed && parsed !== null
                     ? parsed.name
                     : undefined;
                 if (name === MONOREPO_NAME)
@@ -42,7 +42,7 @@ export function isReticleSourceCheckout(cwd) {
 /** Strip one layer of matching quotes from a .env value. */
 function unquote(value) {
     const first = value[0];
-    if ((first === '"' || first === "'") && value.endsWith(first) && value.length >= 2) {
+    if (('"' === first || "'" === first) && value.endsWith(first) && value.length >= 2) {
         return value.slice(1, -1);
     }
     return value;
@@ -67,13 +67,13 @@ export function loadDotEnv(dir, env = process.env) {
     }
     for (const raw of text.split('\n')) {
         const line = raw.trim();
-        if (line.length === 0 || line.startsWith('#'))
+        if (0 === line.length || line.startsWith('#'))
             continue;
         const eq = line.indexOf('=');
         if (eq <= 0)
             continue; // not a KEY=value pair — skip rather than fail the whole file
         const key = line.slice(0, eq).trim();
-        if (key.length === 0 || env[key] !== undefined)
+        if (0 === key.length || env[key] !== undefined)
             continue;
         env[key] = unquote(line.slice(eq + 1).trim());
     }

package/dist/telemetry/error-fingerprint.js

@@ -19,6 +19,25 @@ import { createHash } from 'node:crypto';
  * quoted value often contains the very numbers and paths the later rules would only partly catch.
  */
 const VARIABLE_PARTS = [
+    // ── Identifiers and credentials FIRST ────────────────────────────────────────────────────────
+    //
+    // The rules below this block were written to make messages GROUPABLE — blank the variable parts so
+    // the same defect hashes the same everywhere. Redaction was a side effect of that, and a side
+    // effect is not a guarantee. A telemetry audit caught `bob@acme.com` arriving verbatim in
+    // `crash_message`; probing further, API-key-shaped tokens survived intact and a JWT was only
+    // half-masked. This function also feeds `session.errors[]` on EVERY session summary, so the
+    // exposure was every session that logged an error naming a user, not a rare crash path.
+    //
+    // Order matters: these run before the generic patterns, because `\d+` and the hex rule would chew
+    // a token into pieces that no longer match a credential shape while still leaking most of it —
+    // which is exactly what happened to the JWT.
+    /[\w.+-]+@[\w-]+\.[\w.-]+/g, // email addresses
+    /\beyJ[\w-]*\.[\w-]*\.?[\w-]*/g, // JWTs (header segment is always base64 `eyJ`)
+    /\b(?:sk|pk|rk|ghp|gho|ghs|ghu|ghr|github_pat|xox[abposr]|AKIA|ASIA|glpat)[_-][A-Za-z0-9_-]{8,}/gi,
+    // Anything else long enough and dense enough to be a secret rather than a word. The catch-all for
+    // formats nobody here has seen: on a privacy boundary, unrecognised is not the same as safe.
+    /\b[A-Za-z0-9_-]{24,}\b/g,
+    // ── Then the grouping rules ──────────────────────────────────────────────────────────────────
     /"[^"]*"|'[^']*'|`[^`]*`/g, // quoted values — names, selectors, snippets
     /\b[a-z][a-z0-9+.-]*:\/\/\S+/gi, // URLs
     /(?:\/[\w.-]+){2,}\/?/g, // POSIX-ish paths
@@ -53,7 +72,7 @@ export function reticleFrames(stack) {
         if (!/@reticlehq[/\\]|[/\\]reticle[/\\]dist[/\\]/.test(line))
             continue;
         const location = line.match(/([\w.-]+\.(?:js|mjs|cjs|ts)):(\d+)/);
-        if (location === null)
+        if (null === location)
             continue;
         // `at Object.runTool (/path/to/invoke-tool.js:88:3)` → `runTool`. The function name is half the
         // value of a frame in an RCA — "it died in act-tools.js" narrows to a file, "it died in
@@ -62,7 +81,7 @@ export function reticleFrames(stack) {
         const where = `${location[1] ?? ''}:${location[2] ?? ''}`;
         // `Object.` / `Module.` prefixes are V8 noise that make the same function look like two.
         const name = fn?.replace(/^(?:Object|Module|Function)\./, '');
-        frames.push(name === undefined || name === '' ? where : `${name}@${where}`);
+        frames.push(name === undefined || '' === name ? where : `${name}@${where}`);
     }
     return frames;
 }

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

@@ -1,4 +1,4 @@
-import { TelemetryAction } from '../cli-parse.js';
+import { TelemetryAction } from '../cli/cli-parse.js';
 /**
  * `reticle feedback [--rating 1-5] [--bug] "what happened"` — the human half of the feedback channel.
  *

package/dist/telemetry/feedback-cli.js

@@ -1,8 +1,8 @@
 import { FeedbackKind, FeedbackSource } from '@reticlehq/core';
-import { BUG_FLAG, RATING_FLAG } from '../cli-parse.js';
+import { BUG_FLAG, RATING_FLAG } from '../cli/cli-parse.js';
 import { describeFeedbackPayload, submitFeedback } from './feedback.js';
 import { describeTelemetry, setTelemetryEnabled } from './telemetry.js';
-import { TelemetryAction } from '../cli-parse.js';
+import { TelemetryAction } from '../cli/cli-parse.js';
 import { clearIdentity, IDENTIFY_NOTICE, readIdentity, saveIdentity, submitIdentity, UsageContextKind, } from './identify.js';
 /**
  * `reticle feedback [--rating 1-5] [--bug] "what happened"` — the human half of the feedback channel.
@@ -18,7 +18,7 @@ export async function handleFeedback(text, rating, bug) {
     const line = (s) => {
         process.stdout.write(`${s}\n`);
     };
-    if (text === '' && rating === undefined) {
+    if ('' === text && rating === undefined) {
         line(`usage: reticle feedback [${RATING_FLAG} 1-5] [${BUG_FLAG}] "what worked, what didn't"`);
         line('       your words go to the maintainers; nothing from your app is ever included.');
         process.exitCode = 1;
@@ -28,7 +28,7 @@ export async function handleFeedback(text, rating, bug) {
         source: FeedbackSource.HUMAN,
         kind: bug ? FeedbackKind.BUG : FeedbackKind.EXPERIENCE,
         // A rating with no words is a real report, but the schema wants text — say what the rating means.
-        text: text === '' ? `rated ${String(rating)}/5 with no comment` : text,
+        text: '' === text ? `rated ${String(rating)}/5 with no comment` : text,
         ...(rating !== undefined ? { rating } : {}),
     });
     line(`sending      ${JSON.stringify(describeFeedbackPayload(receipt.context))}`);

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

@@ -27,6 +27,28 @@ export interface SessionFacts {
     engine?: string;
     /** True when Reticle drives the page over CDP rather than observing the human's own browser. */
     driven?: boolean;
+    /** What the APP said it is running, from the SDK's hello. The only session-scoped stack evidence. */
+    adapters?: string[];
 }
+/**
+ * Reconcile what the DIRECTORY says with what the APP says.
+ *
+ * `detectStack` reads the daemon's cwd, which is not the session's project whenever one daemon
+ * serves several apps — the normal case for anyone with two dev servers, and the default in the
+ * fixtures. Reported from the field: feedback filed from an astro session arrived stamped
+ * `"stack":"sveltekit"`, because that was the directory the daemon happened to be started in. The
+ * sessionId was passed and ignored.
+ *
+ * The rule: keep the directory's answer only while the app agrees with it. An adapter that implies a
+ * different family means the directory is describing somebody else's project, so the app's own
+ * report wins — less specific, and true, which is the right trade for an attribution field.
+ */
+export declare function reconcileStack(fromCwd: {
+    stack?: string;
+    stackMajor?: number;
+}, adapters: readonly string[] | undefined): {
+    stack?: string;
+    stackMajor?: number;
+};
 /** Assemble the full context. Every field independently optional — a partial context still ships. */
 export declare function feedbackContext(cwd: string, session?: SessionFacts): FeedbackContext;

package/dist/telemetry/feedback-context.js

@@ -116,6 +116,43 @@ function detectClient() {
         return {};
     }
 }
+/**
+ * Which cwd-derived stacks each SDK adapter is consistent with.
+ *
+ * The adapter names a UI library; the directory may name a meta-framework built on it. `react` and
+ * `next` are the same app described at two levels, so the more specific one is kept. `react` and
+ * `sveltekit` are not — that pairing means the daemon's directory is not this session's project.
+ */
+const ADAPTER_IMPLIES = {
+    react: ['react', 'next', 'remix'],
+    svelte: ['svelte', 'sveltekit'],
+    vue: ['vue', 'nuxt'],
+    solid: ['solid'],
+    angular: ['angular'],
+};
+/**
+ * Reconcile what the DIRECTORY says with what the APP says.
+ *
+ * `detectStack` reads the daemon's cwd, which is not the session's project whenever one daemon
+ * serves several apps — the normal case for anyone with two dev servers, and the default in the
+ * fixtures. Reported from the field: feedback filed from an astro session arrived stamped
+ * `"stack":"sveltekit"`, because that was the directory the daemon happened to be started in. The
+ * sessionId was passed and ignored.
+ *
+ * The rule: keep the directory's answer only while the app agrees with it. An adapter that implies a
+ * different family means the directory is describing somebody else's project, so the app's own
+ * report wins — less specific, and true, which is the right trade for an attribution field.
+ */
+export function reconcileStack(fromCwd, adapters) {
+    const claimed = adapters?.find((adapter) => adapter in ADAPTER_IMPLIES);
+    if (claimed === undefined)
+        return fromCwd;
+    const consistent = ADAPTER_IMPLIES[claimed] ?? [];
+    if (fromCwd.stack !== undefined && consistent.includes(fromCwd.stack))
+        return fromCwd;
+    // The major belonged to the directory's framework, so it cannot travel with a different stack.
+    return { stack: claimed };
+}
 function asRuntime(value) {
     return Object.values(AppRuntime).find((known) => known === value);
 }
@@ -131,7 +168,10 @@ export function feedbackContext(cwd, session) {
     const engine = asEngine(session?.engine);
     const client = detectClient();
     return {
-        ...detectStack(cwd),
+        // Session-scoped when the app reports something that contradicts the directory — see
+        // reconcileStack. A daemon serving two apps otherwise stamps both with whichever one it was
+        // started next to.
+        ...reconcileStack(detectStack(cwd), session?.adapters),
         ...client,
         ...(runtime !== undefined ? { runtime } : {}),
         ...(engine !== undefined ? { engine } : {}),

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

@@ -0,0 +1,20 @@
+/**
+ * Telling the reporter that a BACKGROUND feedback delivery failed.
+ *
+ * The agent's `reticle_feedback` no longer waits for the POST — a ~340ms network round-trip on the
+ * one call an agent makes mid-task is the product blocking the user's work to talk about itself. But
+ * not waiting reopens the exact hole the awaited version was written to close: `sent` used to be
+ * unconditional, so a DNS miss and a 4xx both reported "filed", and this is the ONLY qualitative
+ * channel the product has. A lost report that was announced as filed is worse than no channel.
+ *
+ * So the wait goes and the honesty stays: the receipt says ACCEPTED (validated, redacted, queued),
+ * never "delivered", and if the send then fails the agent is told on its next tool result through
+ * the same one-shot envelope the update and skew nudges use. Told once — a reporter who cannot fix
+ * the network does not need it repeated, and a banner on every call is one agents learn to skip.
+ */
+/** Record that a queued report never made it. */
+export declare function noteFeedbackUndelivered(reason: string): void;
+/** The undelivered-feedback notice, once. */
+export declare function takeFeedbackUndelivered(): string | undefined;
+/** Tests only — drop the module state so each case starts clean. */
+export declare function resetFeedbackDelivery(): void;

package/dist/telemetry/feedback-delivery.js

@@ -0,0 +1,30 @@
+/**
+ * Telling the reporter that a BACKGROUND feedback delivery failed.
+ *
+ * The agent's `reticle_feedback` no longer waits for the POST — a ~340ms network round-trip on the
+ * one call an agent makes mid-task is the product blocking the user's work to talk about itself. But
+ * not waiting reopens the exact hole the awaited version was written to close: `sent` used to be
+ * unconditional, so a DNS miss and a 4xx both reported "filed", and this is the ONLY qualitative
+ * channel the product has. A lost report that was announced as filed is worse than no channel.
+ *
+ * So the wait goes and the honesty stays: the receipt says ACCEPTED (validated, redacted, queued),
+ * never "delivered", and if the send then fails the agent is told on its next tool result through
+ * the same one-shot envelope the update and skew nudges use. Told once — a reporter who cannot fix
+ * the network does not need it repeated, and a banner on every call is one agents learn to skip.
+ */
+/** Set when a background feedback send failed and the reporter has not been told yet. */
+let pending;
+/** Record that a queued report never made it. */
+export function noteFeedbackUndelivered(reason) {
+    pending = reason;
+}
+/** The undelivered-feedback notice, once. */
+export function takeFeedbackUndelivered() {
+    const notice = pending;
+    pending = undefined;
+    return notice;
+}
+/** Tests only — drop the module state so each case starts clean. */
+export function resetFeedbackDelivery() {
+    pending = undefined;
+}

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

@@ -0,0 +1,22 @@
+/** One queued report: the payload, plus what is needed to find and remove it again. */
+export interface OutboxEntry {
+    id: string;
+    t: string;
+    payload: unknown;
+}
+export declare function outboxPath(home?: string): string;
+/**
+ * Persist a report and return its id. Never throws: failing to queue must not also fail the send
+ * that was about to happen anyway.
+ */
+export declare function queueFeedback(payload: unknown, now?: () => Date, home?: string): string | null;
+/** Read every queued report. A malformed line is skipped, never fatal — the rest still matter. */
+export declare function readOutbox(home?: string): OutboxEntry[];
+/**
+ * Drop a report that was delivered. Rewrites the file without it.
+ *
+ * A rewrite rather than a tombstone because the file's whole purpose is "what still needs sending" —
+ * a reader should be able to `cat` it and see exactly the backlog, with no filtering rule to learn.
+ * Volume is a handful of lines a week, so the cost is irrelevant.
+ */
+export declare function markDelivered(id: string | null, home?: string): void;