@reticlehq/server 2.13.1 → 2.14.0

package/dist/setup/run-setup.js

@@ -12,6 +12,7 @@
  * and a real browser to find out what happens when neither works.
  */
 import { judgeWait, QUIET_MEANS_HUNG_MS, urlToWatch, WaitVerdict } from './dev-server-wait.js';
+import { waitProgressLine } from './wait-progress.js';
 /**
  * Windows gets longer to say something before silence counts as a wedge.
  *
@@ -26,10 +27,17 @@ import { judgeWait, QUIET_MEANS_HUNG_MS, urlToWatch, WaitVerdict } from './dev-s
 const WINDOWS_QUIET_MEANS_HUNG_MS = 3 * 60_000;
 const WINDOWS_QUIET_MEANS_HUNG_MS_APPLIES = 'win32' === process.platform;
 import { pickSession } from './session-pick.js';
-import { readPage, describePage } from './page-probe.js';
+import { readPage, describePage, PageFinding } from './page-probe.js';
 import { remainingSteps } from './remaining-steps.js';
 import { AppShape, isDesktop, policyFor } from './desktop-shape.js';
 /** Where a run got to, and why it stopped if it did. */
+/**
+ * How long to keep asking whether the SDK has reached the page before giving up on opening a window.
+ * Bounded by the connect budget, so a short budget is never overrun by the readiness check.
+ */
+const SDK_READY_WINDOW_MS = 15_000;
+/** The wait left when no browser was opened: only a tab that is ALREADY loaded can still appear. */
+const NO_BROWSER_GRACE_MS = 3_000;
 export const SetupPhase = {
     DEV_SERVER: 'dev-server',
     CONNECT: 'connect',
@@ -68,54 +76,81 @@ export async function runSetupPhases(input, fx) {
     };
     // ── the app has to be running ────────────────────────────────────────────────────────────────
     let url = input.suppliedUrl;
+    let attachedToExisting = false;
     if (undefined === url) {
-        if (undefined === input.devCommand) {
+        const announced = undefined === fx.existingAppUrl ? undefined : await fx.existingAppUrl();
+        if (undefined !== announced && 0 < announced.length) {
+            // The plugin already announced a live server for THIS project. Starting `dev` beside it is
+            // how Vite binds 5174, a second tab opens, and `reticle_sessions` lists three with no way
+            // to pick. The registry is scoped; an unscoped listen would attach to a sibling app.
+            url = announced;
+            attachedToExisting = true;
+            note(`This project is already running at ${announced} — attaching instead of starting a second server.`);
+        }
+        else if (undefined === input.devCommand) {
             note(
             // "stop here rather than invent one" is the SKILL.md rule, and the words are the contract —
             // inventing a dev command is how a setup script runs the wrong thing and reports success.
             'No dev command: the project names no dev, start or serve script, and there is no --url. ' +
-                'Stopping here rather than invent one — pass --dev-cmd or --url to say what serves this app.');
+                'Stopping here rather than invent one — start the app yourself and pass --url to say ' +
+                'where it is serving, or add a dev/start/serve script to package.json and re-run.');
             return stop(input, SetupPhase.DEV_SERVER, {}, notes);
         }
-        await fx.startDevServer(input.devCommand, input.appDir);
-        const startedAt = fx.now();
-        for (;;) {
-            const watching = urlToWatch(fx.devServerOutput(), fx.observedPorts());
-            const serving = undefined === watching ? false : (await fx.probePage(watching)).served;
-            const verdict = judgeWait({
-                output: fx.devServerOutput(),
-                launcherExited: fx.devServerExited(),
-                serving,
-                quietForMs: fx.devServerQuietForMs(),
-                elapsedMs: fx.now() - startedAt,
-                quietMeansHungMs: WINDOWS_QUIET_MEANS_HUNG_MS_APPLIES
-                    ? WINDOWS_QUIET_MEANS_HUNG_MS
-                    : QUIET_MEANS_HUNG_MS,
-            });
-            if (WaitVerdict.READY === verdict && undefined !== watching) {
-                url = watching;
-                break;
-            }
-            // A desktop shell serves its webview from inside the app, so there is no port to answer and
-            // nothing to be READY. Once it has announced a url, or bound one we can see, that is as far
-            // as this phase can get: the session it dials from its own window is the real signal.
-            if (isDesktop(input.shape) && undefined !== watching) {
-                url = watching;
-                break;
-            }
-            if (WaitVerdict.DEAD === verdict) {
-                note('The dev server exited without serving anything.');
-                return stop(input, SetupPhase.DEV_SERVER, {}, notes);
-            }
-            if (WaitVerdict.HUNG === verdict) {
-                // Says BOTH were checked. A server that prints nothing but IS listening is the CRA case and
-                // must not be failed, so a reader has to be able to tell "we looked at the log" from "we
-                // looked at the log AND the ports".
-                note('The dev server neither printed a URL nor bound a port, so setup has nothing to open. ' +
-                    'Check its log, or pass --url with the address it serves.');
-                return stop(input, SetupPhase.DEV_SERVER, {}, notes);
+        else {
+            await fx.startDevServer(input.devCommand, input.appDir);
+            const startedAt = fx.now();
+            // This loop used to poll in complete silence. Reported as thirty minutes of nothing ending in a
+            // SIGKILL — and whatever made that wait long, a user who cannot tell "still starting" from
+            // "wedged" has been given no way to act. See wait-progress.ts.
+            let spokeAtMs;
+            for (;;) {
+                const watching = urlToWatch(fx.devServerOutput(), fx.observedPorts());
+                const waitedMs = fx.now() - startedAt;
+                const progress = waitProgressLine(waitedMs, watching, spokeAtMs);
+                if (progress !== undefined) {
+                    note(progress);
+                    spokeAtMs = waitedMs;
+                }
+                const probe = undefined === watching
+                    ? { served: false, sdkInPage: false }
+                    : await fx.probePage(watching);
+                const serving = probe.served;
+                const verdict = judgeWait({
+                    output: fx.devServerOutput(),
+                    launcherExited: fx.devServerExited(),
+                    serving,
+                    quietForMs: fx.devServerQuietForMs(),
+                    elapsedMs: fx.now() - startedAt,
+                    quietMeansHungMs: WINDOWS_QUIET_MEANS_HUNG_MS_APPLIES
+                        ? WINDOWS_QUIET_MEANS_HUNG_MS
+                        : QUIET_MEANS_HUNG_MS,
+                });
+                if (WaitVerdict.READY === verdict && undefined !== watching) {
+                    // Prefer the URL that answered when the announcement was the wrong family (#884).
+                    url = probe.reachedUrl ?? watching;
+                    break;
+                }
+                // A desktop shell serves its webview from inside the app, so there is no port to answer and
+                // nothing to be READY. Once it has announced a url, or bound one we can see, that is as far
+                // as this phase can get: the session it dials from its own window is the real signal.
+                if (isDesktop(input.shape) && undefined !== watching) {
+                    url = watching;
+                    break;
+                }
+                if (WaitVerdict.DEAD === verdict) {
+                    note('The dev server exited without serving anything.');
+                    return stop(input, SetupPhase.DEV_SERVER, {}, notes);
+                }
+                if (WaitVerdict.HUNG === verdict) {
+                    // Says BOTH were checked. A server that prints nothing but IS listening is the CRA case and
+                    // must not be failed, so a reader has to be able to tell "we looked at the log" from "we
+                    // looked at the log AND the ports".
+                    note('The dev server neither printed a URL nor bound a port, so setup has nothing to open. ' +
+                        'Check its log, or pass --url with the address it serves.');
+                    return stop(input, SetupPhase.DEV_SERVER, {}, notes);
+                }
+                await fx.sleep(input.pollMs);
             }
-            await fx.sleep(input.pollMs);
         }
     }
     // ── and something has to connect from inside it ──────────────────────────────────────────────
@@ -123,17 +158,73 @@ export async function runSetupPhases(input, fx) {
     // Through `note`, not `fx.note`: a caller reading the result should see it too.
     if (undefined !== policy.note)
         note(policy.note);
-    const before = new Set((await fx.listSessions()).map((s) => s.sessionId));
-    // Never for a desktop app: its own window is the client, and a browser tab would be a SECOND
-    // session that is not the app.
-    if (input.openBrowser && policy.openBrowser)
-        await fx.openBrowser(url);
-    const deadline = fx.now() + (input.connectBudgetMs ?? Math.max(input.phaseTimeoutMs, policy.connectBudgetMs));
-    let session = null;
-    for (;;) {
+    const listed = await fx.listSessions();
+    const requiredRuntime = isDesktop(input.shape) ? input.shape : undefined;
+    // A tab already on this URL is the answer. Opening another is how three sessions appear.
+    // `before` is empty so pickSession will take that tab rather than waiting for a new one.
+    const alreadyConnected = attachedToExisting
+        ? pickSession(listed, url, new Set(), requiredRuntime)
+        : null;
+    const before = new Set(listed.map((s) => s.sessionId));
+    // Do not put a window in front of somebody until the page behind it can actually do something.
+    //
+    // The probe that says whether the SDK is even IN the page used to run only in the failure branch
+    // below, AFTER the browser was already open. So a mis-wired app opened a real window onto a page
+    // that was never going to connect, and the person watching it saw a browser appear and then
+    // nothing happen for the whole connect budget — which reads as "Reticle is broken" rather than
+    // "the bundle predates the config edit". One fetch, before the window, turns that into a sentence.
+    //
+    // Only the browser is gated. The wait below still runs: something else may connect (an already
+    // open tab, a desktop window), and the probe is a statement about one fetch of the document, not
+    // proof that nothing can ever dial in.
+    const budgetMs = input.connectBudgetMs ?? Math.max(input.phaseTimeoutMs, policy.connectBudgetMs);
+    let openedBrowser = false;
+    if (null === alreadyConnected && input.openBrowser && policy.openBrowser) {
+        // SERVED is the precondition, not SDK_PRESENT: a url that answers nothing is the only state
+        // where a window is certainly useless. Whether the SDK is in the served HTML is a DIFFERENT
+        // question — Vite injects a marker, while Nuxt, React Router, Astro, SvelteKit and CRA deliver
+        // the connect in the JS BUNDLE, so their HTML never carries it. Gating on presence failed five
+        // of ten scaffolds in the install gate: no window, so no bundle, so no session, so exit 1 on a
+        // correct install. page-probe.ts says it is a diagnostic for a connect that already failed; the
+        // same signal as a precondition deadlocks every case it is wrong about.
+        //
+        // So presence decides only WHEN: open the moment it appears (the fast path for the frameworks
+        // that inline it), otherwise once the short readiness window is out.
+        const readyBy = fx.now() + Math.min(SDK_READY_WINDOW_MS, budgetMs);
+        let finding = readPage(await fx.probePage(url));
+        while (PageFinding.SDK_MISSING === finding && fx.now() < readyBy) {
+            await fx.sleep(input.pollMs);
+            finding = readPage(await fx.probePage(url));
+        }
+        if (PageFinding.NOT_SERVED === finding || PageFinding.TLS_REFUSED === finding) {
+            note(describePage(finding, url));
+            note('Not opening a browser: nothing answered that url, so the window could only show an error ' +
+                'page. Fix the line above and re-run — `init` is idempotent.');
+        }
+        else {
+            // Said BEFORE the window appears, so somebody watching a page that stays inert has already
+            // been told which of the two it is.
+            if (PageFinding.SDK_MISSING === finding)
+                note(describePage(finding, url));
+            await fx.openBrowser(url);
+            openedBrowser = true;
+        }
+    }
+    // Waiting the full budget for a session when nothing was opened to create one is dead time, and
+    // it used to be over two minutes of it: the browser is the session source on web, so declining to
+    // open it and then waiting as if we had is a promise to the reader that cannot be kept. Something
+    // else may still dial in — a tab the user already has open, a desktop window — and the existing
+    // diagnosis says such a session "will appear within a second of the page loading", so a short
+    // grace is the honest wait. A run that DID open a browser keeps the whole budget.
+    const deadline = fx.now() +
+        (openedBrowser || !(input.openBrowser && policy.openBrowser)
+            ? budgetMs
+            : Math.min(NO_BROWSER_GRACE_MS, budgetMs));
+    let session = alreadyConnected;
+    while (null === session) {
         // On a desktop app, only the desktop window counts. AppShape and the runtime a page reports use
         // the same three names, so the shape IS the requirement — see session-pick.
-        session = pickSession(await fx.listSessions(), url, before, isDesktop(input.shape) ? input.shape : undefined);
+        session = pickSession(await fx.listSessions(), url, before, requiredRuntime);
         if (null !== session)
             break;
         if (deadline <= fx.now())

package/dist/setup/setup-command.d.ts

@@ -6,7 +6,7 @@
  * run-setup.ts and the pieces it calls.
  */
 import { type SetupInput, type SetupOutcome } from './run-setup.js';
-export interface SetupCommandInput extends Omit<SetupInput, 'shape'> {
+interface SetupCommandInput extends Omit<SetupInput, 'shape'> {
     /** Where setup was invoked, which is not the app directory in a monorepo. */
     readonly invokedAt: string;
     readonly bridgePort: number;
@@ -26,7 +26,7 @@ export interface SetupCommandInput extends Omit<SetupInput, 'shape'> {
  * so a VS Code user has no tools outside the directory they ran init in.
  */
 export declare function registerOtherAgents(print: (line: string) => void): void;
-export interface SetupCommandResult extends SetupOutcome {
+interface SetupCommandResult extends SetupOutcome {
     /** Set when a weak flow was re-recorded with the stronger model. */
     readonly escalated?: {
         readonly from: string;
@@ -43,3 +43,4 @@ export interface SetupCommandResult extends SetupOutcome {
  * files and a dead tab.
  */
 export declare function runSetupCommand(input: SetupCommandInput, print: (line: string) => void): Promise<SetupCommandResult>;
+export {};

package/dist/setup/setup-command.js

@@ -16,8 +16,12 @@ import { ApprovalOutcome, grantAutoApproval } from './auto-approve.js';
 import { agentIo } from './agent-io.js';
 import { EnsureDaemon, ensureDaemon, nodeEnsureDaemonDeps } from './ensure-daemon.js';
 import { openInBrowser } from '../cli/cli-launch.js';
+import { readProjectId } from '../cli/cli-port.js';
+import { reticleStateHome } from '../daemon/daemon.js';
+import { readDevServers } from '../daemon/dev-servers.js';
 import { chooseDriver, DRIVERS, shouldEscalate } from './drive-plan.js';
 import { driveWith } from './drive-agent.js';
+import { urlOfExistingApp } from './existing-app.js';
 import { binaryExists, flowsSaved, listSessions, OwnedDevServer, probePage, } from './node-effects.js';
 import { runSetupPhases, } from './run-setup.js';
 /** The capabilities file init scaffolds, in the order a project is likely to have it. */
@@ -105,6 +109,10 @@ export async function runSetupCommand(input, print) {
             server.start(command, cwd, input.env);
             return Promise.resolve();
         },
+        existingAppUrl: () => Promise.resolve(urlOfExistingApp(readDevServers(reticleStateHome()), {
+            projectId: readProjectId(input.appDir),
+            root: input.appDir,
+        })),
         devServerOutput: () => server.output(),
         devServerExited: () => server.exited(),
         devServerQuietForMs: () => server.quietForMs(),

package/dist/setup/setup-options.d.ts

@@ -18,8 +18,9 @@
  *               backend named in the README, the variable that skips an auth wall: all readable by
  *               an agent, none inferable by a script. Without this a real app sits on a login
  *               screen and there is no flow to drive at all.
- *   --dev-cmd   the command, when the project's own scripts do not say it plainly.
- *   --url       the app is already running here, so do not start anything.
+ *   --url       the app is already running here, so do not start anything. This is also the answer
+ *               when the project's own scripts do not name a dev command: start it yourself and say
+ *               where. There is no flag that overrides the dev command; --url replaces the need.
  *
  * Everything else on this type is an operator's dial, not an agent's judgement.
  */
@@ -29,7 +30,7 @@ export declare const DEFAULT_BRIDGE_PORT = 4400;
 export declare const DEFAULT_PHASE_TIMEOUT_MS = 120000;
 /** What the drive may spend before it is stopped. */
 export declare const DEFAULT_DRIVE_BUDGET_USD = 3;
-export interface SetupOptions {
+interface SetupOptions {
     /** The journey to drive, in the caller's own words. */
     readonly flow?: string | undefined;
     /** Which app in a monorepo. */
@@ -72,3 +73,4 @@ export declare function parseEnvAssignment(pair: string): {
  * something else should see its variable missing, not see setup invent one.
  */
 export declare function collectEnv(pairs: readonly string[]): Record<string, string>;
+export {};

package/dist/setup/setup-options.js

@@ -18,8 +18,9 @@
  *               backend named in the README, the variable that skips an auth wall: all readable by
  *               an agent, none inferable by a script. Without this a real app sits on a login
  *               screen and there is no flow to drive at all.
- *   --dev-cmd   the command, when the project's own scripts do not say it plainly.
- *   --url       the app is already running here, so do not start anything.
+ *   --url       the app is already running here, so do not start anything. This is also the answer
+ *               when the project's own scripts do not name a dev command: start it yourself and say
+ *               where. There is no flag that overrides the dev command; --url replaces the need.
  *
  * Everything else on this type is an operator's dial, not an agent's judgement.
  */

package/dist/setup/wait-progress.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Say what the dev-server wait is waiting FOR, while it waits.
+ *
+ * `init`'s wait loop polled in complete silence. Reported as thirty minutes of nothing, ending in a
+ * SIGKILL: no output, no exit, no verdict. The cause of that particular wait is still unexplained,
+ * but the silence is a failure on its own terms — a user cannot tell "still starting" from "wedged",
+ * and cannot see the thing most likely to be wrong, which is the URL being watched rather than the
+ * server itself.
+ *
+ * That distinction is not hypothetical: `dev-server-wait.ts` already reasons about a server that
+ * serves happily on a port we never found (the CRA case, where no url is printed outside a tty), and
+ * has never said so out loud while it happens.
+ *
+ * Pure, and the clock is the caller's. `elapsedMs` and `lastSpokeAtMs` come in; nothing here reads a
+ * real clock, so the decision is testable without one and cannot assert a duration.
+ */
+/**
+ * How often to speak. Long enough that a normal start — under a second — says nothing at all, since
+ * announcing a wait that is not happening is noise in the first command a user ever runs.
+ */
+export declare const WAIT_PROGRESS_EVERY_MS = 15000;
+/**
+ * The line to print now, or undefined to stay quiet.
+ *
+ * `lastSpokeAtMs` is when this last returned a line, so the caller can poll as fast as it likes
+ * without a line per poll burying the output it exists to explain.
+ */
+export declare function waitProgressLine(elapsedMs: number, watching: string | undefined, lastSpokeAtMs: number | undefined): string | undefined;

package/dist/setup/wait-progress.js

@@ -0,0 +1,43 @@
+/**
+ * Say what the dev-server wait is waiting FOR, while it waits.
+ *
+ * `init`'s wait loop polled in complete silence. Reported as thirty minutes of nothing, ending in a
+ * SIGKILL: no output, no exit, no verdict. The cause of that particular wait is still unexplained,
+ * but the silence is a failure on its own terms — a user cannot tell "still starting" from "wedged",
+ * and cannot see the thing most likely to be wrong, which is the URL being watched rather than the
+ * server itself.
+ *
+ * That distinction is not hypothetical: `dev-server-wait.ts` already reasons about a server that
+ * serves happily on a port we never found (the CRA case, where no url is printed outside a tty), and
+ * has never said so out loud while it happens.
+ *
+ * Pure, and the clock is the caller's. `elapsedMs` and `lastSpokeAtMs` come in; nothing here reads a
+ * real clock, so the decision is testable without one and cannot assert a duration.
+ */
+/**
+ * How often to speak. Long enough that a normal start — under a second — says nothing at all, since
+ * announcing a wait that is not happening is noise in the first command a user ever runs.
+ */
+export const WAIT_PROGRESS_EVERY_MS = 15_000;
+/**
+ * The line to print now, or undefined to stay quiet.
+ *
+ * `lastSpokeAtMs` is when this last returned a line, so the caller can poll as fast as it likes
+ * without a line per poll burying the output it exists to explain.
+ */
+export function waitProgressLine(elapsedMs, watching, lastSpokeAtMs) {
+    if (elapsedMs < WAIT_PROGRESS_EVERY_MS)
+        return undefined;
+    const since = elapsedMs - (lastSpokeAtMs ?? 0);
+    if (lastSpokeAtMs !== undefined && since < WAIT_PROGRESS_EVERY_MS)
+        return undefined;
+    const seconds = `${String(Math.floor(elapsedMs / 1000))}s`;
+    if (watching === undefined) {
+        // A different problem, and one the reader can act on: we do not know where to look. The CRA
+        // case reaches here, and so does any launcher whose url never appears in its output.
+        return (`Waiting ${seconds} for the dev server. It has not announced a url yet and no port was ` +
+            `observed, so there is nothing to watch — if it IS up, stop this and pass --url <its url>.`);
+    }
+    return (`Waiting ${seconds} for the dev server — watching ${watching}. If the app is already up ` +
+        `somewhere else, that url is the thing to check first.`);
+}

package/dist/telemetry/app-instrumented.d.ts

@@ -16,7 +16,7 @@
  * `project_profiled` already carries it on the same daemon run, so the two join on sessionId.
  */
 export declare function markInstrumentationClock(now: number): void;
-export interface InstrumentationFacts {
+interface InstrumentationFacts {
     /** Whether this project has a projectId stamped — i.e. `init` has run here. */
     initialized: boolean;
     /**
@@ -43,3 +43,4 @@ export declare function reportAppInstrumented(facts: InstrumentationFacts, now?:
 export declare function appEverConnected(): boolean;
 /** Tests only. */
 export declare function resetAppInstrumented(): void;
+export {};

package/dist/telemetry/app-instrumented.js

@@ -15,7 +15,7 @@
  * project path, the URL, or anything from the page. The stack is deliberately NOT repeated here;
  * `project_profiled` already carries it on the same daemon run, so the two join on sessionId.
  */
-import { TelemetryEventKind } from '@reticlehq/core';
+import { TelemetryEventKind } from '@reticlehq/core/telemetry';
 import { getTelemetry } from './telemetry.js';
 let reported = false;
 /** Set at daemon start so the first connect can report how long the install sat un-instrumented. */

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

@@ -1,4 +1,4 @@
-import { AutomationHint } from '@reticlehq/core';
+import { AutomationHint } from '@reticlehq/core/telemetry';
 interface AutomationInput {
     env: NodeJS.ProcessEnv;
     fileExists: (path: string) => boolean;

package/dist/telemetry/automation-hint.js

@@ -25,7 +25,7 @@
  *    developer machines trip it; it separates nothing.
  */
 import { existsSync } from 'node:fs';
-import { AutomationHint } from '@reticlehq/core';
+import { AutomationHint } from '@reticlehq/core/telemetry';
 /** Container runtimes drop one of these at the filesystem root. */
 const CONTAINER_MARKERS = ['/.dockerenv', '/run/.containerenv'];
 /** Hosted dev environments that declare themselves. Self-declared, never inferred. */

package/dist/telemetry/cli-telemetry.js

@@ -4,7 +4,7 @@
  * 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 { TelemetryEventKind } from '@reticlehq/core';
+import { TelemetryEventKind } from '@reticlehq/core/telemetry';
 import { DAEMON_INNER_COMMAND, knownCommand } from '../cli/cli-parse.js';
 import { getTelemetry } from './telemetry.js';
 import { describeCliFlags } from './argument-shape.js';

package/dist/telemetry/connect-failure.d.ts

@@ -11,6 +11,6 @@
  * this list needs another entry — which is a signal in itself, and the reason it is never merged
  * into one of the known causes.
  */
-import { ConnectFailure } from '@reticlehq/core';
+import { ConnectFailure } from '@reticlehq/core/telemetry';
 /** The cause behind a connection error, or `OTHER` when we do not recognize it. */
 export declare function classifyConnectFailure(error: unknown): ConnectFailure;

package/dist/telemetry/connect-failure.js

@@ -11,7 +11,7 @@
  * this list needs another entry — which is a signal in itself, and the reason it is never merged
  * into one of the known causes.
  */
-import { ConnectFailure } from '@reticlehq/core';
+import { ConnectFailure } from '@reticlehq/core/telemetry';
 /** Ordered most-specific first; the first match wins. Patterns track messages we have actually seen. */
 const RULES = [
     // Playwright's own wording when the browser was never downloaded.

package/dist/telemetry/crash-cause.d.ts

@@ -20,14 +20,14 @@
  * are read and deliberately thrown away.
  */
 /** The structured cause of a crash, when the error carries one. Every field is optional. */
-export interface CrashCause {
+interface CrashCause {
     syscall?: string;
     errno?: string;
     loopback?: boolean;
     port?: CrashPort;
     internalFrame?: string;
 }
-import { CrashPort } from '@reticlehq/core';
+import { CrashPort } from '@reticlehq/core/telemetry';
 /**
  * The innermost frame that names NODE's own source.
  *
@@ -45,3 +45,4 @@ export declare function innermostInternalFrame(stack: string): string | undefine
  * comparison is testable — the port itself is used to answer one enum and is then discarded.
  */
 export declare function crashCause(value: unknown, knownPorts: readonly number[]): CrashCause;
+export {};

package/dist/telemetry/crash-cause.js

@@ -19,7 +19,7 @@
  * reported as an enum, and the frame names a line in NODE's source. The address and the port number
  * are read and deliberately thrown away.
  */
-import { CrashPort } from '@reticlehq/core';
+import { CrashPort } from '@reticlehq/core/telemetry';
 import { reticleFrames } from './error-fingerprint.js';
 /** IPv4 loopback is the whole 127/8 block, not just 127.0.0.1. */
 const IPV4_LOOPBACK = /^127\./;

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

@@ -6,7 +6,7 @@
  * (nothing here may ever be able to fail a daemon start), and because `cli.ts` is a dispatcher — the
  * more of this that lives there, the harder it is to see what a command actually does.
  */
-import { type SessionSummary } from '@reticlehq/core';
+import { type SessionSummary } from '@reticlehq/core/telemetry';
 /**
  * How often a running daemon rolls up its window.
  *
@@ -36,7 +36,7 @@ export declare const SESSION_FLUSH_MS: number;
  */
 export declare const FIRST_FLUSH_MS: number;
 /** Stops the timers this installed. Called from the daemon's shutdown path. */
-export interface DaemonTelemetry {
+interface DaemonTelemetry {
     /**
      * Emit the final, rich session summary and stop flushing. Safe to call more than once.
      *
@@ -61,3 +61,4 @@ export declare function installDaemonTelemetry(cwd: string, now?: () => number,
  * trustworthy.
  */
 port?: number): DaemonTelemetry;
+export {};

package/dist/telemetry/daemon-telemetry.js

@@ -6,7 +6,7 @@
  * (nothing here may ever be able to fail a daemon start), and because `cli.ts` is a dispatcher — the
  * more of this that lives there, the harder it is to see what a command actually does.
  */
-import { TelemetryEventKind } from '@reticlehq/core';
+import { TelemetryEventKind } from '@reticlehq/core/telemetry';
 import { getTelemetry } from './telemetry.js';
 import { getSessionMetrics } from './session-metrics.js';
 import { profileProject } from './project-profile.js';

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

@@ -11,7 +11,7 @@
  * counts. The full message is already fingerprinted and skeletonised elsewhere.
  */
 /** Whose defect. Ordered by which fix it implies. */
-export declare const ErrorClass: {
+declare const ErrorClass: {
     /** Missing/unknown parameter, wrong type, unparseable predicate. **Our schema is unclear.** */
     readonly SCHEMA: "schema";
     /** No session, stale ref, disconnected. The world moved under the agent; not a schema problem. */
@@ -21,6 +21,7 @@ export declare const ErrorClass: {
     /** Unrecognised. The bucket to watch: a large one is a blind spot, not a long tail. */
     readonly OTHER: "other";
 };
-export type ErrorClass = (typeof ErrorClass)[keyof typeof ErrorClass];
+type ErrorClass = (typeof ErrorClass)[keyof typeof ErrorClass];
 /** Which bucket this message belongs to. Never throws — a classifier must not break a tool path. */
 export declare function classifyError(message: string): ErrorClass;
+export {};

package/dist/telemetry/error-class.js

@@ -11,7 +11,7 @@
  * counts. The full message is already fingerprinted and skeletonised elsewhere.
  */
 /** Whose defect. Ordered by which fix it implies. */
-export const ErrorClass = {
+const ErrorClass = {
     /** Missing/unknown parameter, wrong type, unparseable predicate. **Our schema is unclear.** */
     SCHEMA: 'schema',
     /** No session, stale ref, disconnected. The world moved under the agent; not a schema problem. */

package/dist/telemetry/feedback-cli.js

@@ -1,4 +1,4 @@
-import { FeedbackKind, FeedbackSource } from '@reticlehq/core';
+import { FeedbackKind, FeedbackSource } from '@reticlehq/core/telemetry';
 import { AGENT_FLAG, BUG_FLAG, FEEDBACK_KINDS, KIND_FLAG, RATING_FLAG } from '../cli/cli-parse.js';
 import { describeFeedbackPayload, submitFeedback } from './feedback.js';
 import { describeTelemetry, setTelemetryEnabled } from './telemetry.js';

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

@@ -1,6 +1,6 @@
-import { McpScope, StackUnknownReason, type Feedback } from '@reticlehq/core';
+import { McpScope, StackUnknownReason, type Feedback } from '@reticlehq/core/telemetry';
 /** The context fields — the whole `Feedback` shape minus what the author supplies. */
-export type FeedbackContext = Pick<Feedback, 'stack' | 'stackMajor' | 'runtime' | 'engine' | 'driver' | 'client' | 'clientVersion' | 'mcpScope'>;
+type FeedbackContext = Pick<Feedback, 'stack' | 'stackMajor' | 'runtime' | 'engine' | 'driver' | 'client' | 'clientVersion' | 'mcpScope'>;
 export declare function detectStack(cwd: string, read?: (path: string) => string): {
     stack?: string;
     stackMajor?: number;
@@ -55,3 +55,4 @@ export declare function reconcileStack(fromCwd: {
 };
 /** Assemble the full context. Every field independently optional — a partial context still ships. */
 export declare function feedbackContext(cwd: string, session?: SessionFacts): FeedbackContext;
+export {};

package/dist/telemetry/feedback-context.js

@@ -12,9 +12,8 @@
 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, StackUnknownReason, } from '@reticlehq/core';
-import { parseMajor } from '../init/detect.js';
-import { findWorkspaceApps } from '../init/workspace-apps.js';
+import { AppRuntime, McpScope, PageDriver, StackUnknownReason, } from '@reticlehq/core/telemetry';
+import { parseMajor, findWorkspaceApps } from '@reticlehq/init';
 /**
  * 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
@@ -30,6 +29,8 @@ const STACK_BY_DEP = [
     ['nuxt', 'nuxt'],
     ['astro', 'astro'],
     ['@remix-run/react', 'remix'],
+    ['@tanstack/react-start', 'tanstack-start'],
+    ['@tanstack/start', 'tanstack-start'],
     ['@angular/core', 'angular'],
     ['react', 'react'],
     ['vue', 'vue'],
@@ -215,7 +216,7 @@ function detectClient() {
  * `sveltekit` are not — that pairing means the daemon's directory is not this session's project.
  */
 const ADAPTER_IMPLIES = {
-    react: ['react', 'next', 'remix'],
+    react: ['react', 'next', 'remix', 'tanstack-start'],
     svelte: ['svelte', 'sveltekit'],
     vue: ['vue', 'nuxt'],
     solid: ['solid'],

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

@@ -1,5 +1,5 @@
-import type { Feedback } from '@reticlehq/core';
-export interface SavedFeedback {
+import type { Feedback } from '@reticlehq/core/telemetry';
+interface SavedFeedback {
     path: string;
     /** A ready-to-run command that turns the file into an issue. */
     command: string;
@@ -13,3 +13,4 @@ export declare function saveFeedbackLocally(cwd: string, input: {
     kind?: string;
     source?: string;
 }, text: string, context: Partial<Feedback>, now?: number): SavedFeedback | undefined;
+export {};