@reticlehq/server 2.11.0 → 2.13.0

package/dist/session/no-session-watch.js

@@ -10,14 +10,17 @@
  * daemon that outlives the agent by hours has no business scanning ports it does not need.
  */
 import { probeDevServers, probeDevServerStates } from './dev-server-probe.js';
-import { diagnoseNoSession } from './no-session-diagnosis.js';
+import { explainNoSession } from './no-session-diagnosis.js';
 import { detectDevCommand } from './dev-command.js';
 import { nextActionFor, renderNextAction } from './no-session-next-action.js';
 import { readProjectFramework, readProjectId, readProjectPort } from '../cli/cli-port.js';
 import { discoverProjectConfigs } from '../cli/config-discovery.js';
 import { hasProjectConnectedBefore, rememberConnected } from './connection-memory.js';
-import { reticleStateHome } from '../daemon/daemon.js';
+import { isAlive, reticleStateHome } from '../daemon/daemon.js';
+import { daemonsServingProjectElsewhere, splitBrainNote } from '../daemon/daemon-resolve.js';
 import { stallUptime } from './stall-clock.js';
+import { probeDaemon } from '../mcp/mcp-proxy.js';
+import { findOccupiedSiblings } from '../cli/sibling-ports.js';
 /** Slow enough to be free, fast enough that a dev server started 15s ago is already reflected. */
 const REFRESH_MS = 15_000;
 /** The URL an auto-attach opens. `localhost` for the same reason the probe uses it: both stacks. */
@@ -56,6 +59,7 @@ export function startNoSessionWatch(options) {
      * `options.probe` returns only the serving set, so this stays empty for injected probes.
      */
     let slowListeners = [];
+    let siblingListeners = [];
     let running = false;
     /** Ports auto-attach has already spent its one attempt on. Bounded: never a loop, never a retry. */
     const attempted = new Set();
@@ -66,6 +70,27 @@ export function startNoSessionWatch(options) {
     // is routinely written by `init` AFTER this daemon started, so re-read rather than cache. See the
     // `initialized` comment below, which this shares.
     const isWired = () => options.initialized || readProjectId(directory) !== undefined;
+    /**
+     * Resolve the daemon's current project scope once for both halves of a sessions response.
+     *
+     * This remains a live read because `init` commonly writes the config after the daemon starts.
+     */
+    const projectScopeFacts = () => {
+        const initialized = isWired();
+        if (initialized)
+            return { initialized };
+        const discovery = discoverProjectConfigs(directory);
+        const elsewhere = discovery.found.filter((config) => config.directory !== directory);
+        return 0 === elsewhere.length
+            ? { initialized, searchedDirectories: discovery.searched }
+            : {
+                initialized,
+                configsElsewhere: elsewhere.map((config) => ({
+                    directory: config.directory,
+                    ...(config.projectId === undefined ? {} : { projectId: config.projectId }),
+                })),
+            };
+    };
     // Read at boot: the daemon's own identity does not change under it, and this is the key the
     // durable bit is stored under.
     const stateDir = options.stateDir ?? reticleStateHome();
@@ -78,6 +103,19 @@ export function startNoSessionWatch(options) {
      * is the same over-confident claim this whole file exists to remove, pointing the other way.
      */
     const connectedBefore = () => hasProjectConnectedBefore(stateDir, options.port, readProjectId(directory));
+    /**
+     * The split brain, asked fresh every time like everything else here.
+     *
+     * Cheap — a directory listing of `~/.reticle` and a few small JSON reads — and only ever reached
+     * on a daemon with no session, which is the state this whole file exists for. Reading it once at
+     * boot would miss the ordinary case entirely: the app connects to the other daemon SECONDS after
+     * this one starts, which is precisely the window the agent then spends being told to start a dev
+     * server that is already running.
+     */
+    const splitBrain = () => {
+        const projectId = readProjectId(directory);
+        return splitBrainNote(options.port, daemonsServingProjectElsewhere(projectId, options.port, stateDir, isAlive, (port) => hasProjectConnectedBefore(stateDir, port, projectId)));
+    };
     // Every path that registers a session goes through SessionManager.add, so this is the one hook
     // that makes the bit durable. Recorded per port + projectId so a shared 4400 cannot make one
     // project's success into evidence about another's.
@@ -129,6 +167,12 @@ export function startNoSessionWatch(options) {
             : probe())
             .then(async (ports) => {
             listening = ports;
+            siblingListeners =
+                options.occupiedSiblings !== undefined
+                    ? await options.occupiedSiblings()
+                    : options.probe === undefined
+                        ? await findOccupiedSiblings(options.port, probeDaemon)
+                        : [];
             await autoAttach(ports);
         })
             .catch(() => {
@@ -141,81 +185,87 @@ export function startNoSessionWatch(options) {
     refresh();
     const timer = setInterval(refresh, REFRESH_MS);
     timer.unref();
-    const nextAction = () => nextActionFor({
-        everConnected: options.sessions.everConnected(),
-        initialized: isWired(),
-        previouslyConnected: connectedBefore(),
-        listening,
-        // Read when asked, like everything else here: a `package.json` can gain a dev script, and a
-        // daemon that cached "there is none" at boot would keep saying so for the rest of the day.
-        dev: detectDevCommand(directory),
+    const nextAction = (scope) => {
+        const split = splitBrain();
+        return nextActionFor({
+            everConnected: options.sessions.everConnected(),
+            initialized: scope.initialized,
+            ...(scope.configsElsewhere === undefined ? {} : { configsElsewhere: scope.configsElsewhere }),
+            previouslyConnected: connectedBefore(),
+            ...(split === undefined ? {} : { splitBrain: split }),
+            listening,
+            // Read when asked, like everything else here: a `package.json` can gain a dev script, and a
+            // daemon that cached "there is none" at boot would keep saying so for the rest of the day.
+            dev: detectDevCommand(directory),
+        });
+    };
+    options.sessions.setNoSessionNextAction(() => nextAction(projectScopeFacts()));
+    // ONE call for both registrations below. The prose and the branch code have to come from the
+    // same evaluation or they can describe different branches - the facts are read when asked, so two
+    // calls a moment apart can genuinely disagree (#615).
+    const explain = () => {
+        const scope = projectScopeFacts();
+        return explainNoSession({
+            everConnected: options.sessions.everConnected(),
+            // Read WHEN ASKED, for the same reason `projectPort` below is: `.reticle.json` is routinely
+            // written by `init` after this daemon started — that is the ordinary first-install order — and
+            // the boot-time answer is then permanently stale. Reported from the field as `reticle status`
+            // saying the project had never been through `init` about a project whose config named its
+            // framework and its projectId, and whose real problem was a dev server older than the plugin.
+            // The boot value still counts: it is the one the daemon scoped its sessions with.
+            ...scope,
+            listening,
+            slowListeners,
+            port: options.port,
+            // The directory `initialized` was decided in. Named in the message because "there is no
+            // `.reticle.json`" is a claim about ONE directory, and a reader standing somewhere else
+            // cannot tell whether it is a claim about their app at all.
+            directory,
+            // The one fact that outranks every absence below it, and the reason a fresh daemon stopped
+            // claiming that an install which has demonstrably worked has never worked.
+            previouslyConnected: connectedBefore(),
+            // Ranks the causes. Read when asked, like the rest: `init` writes this file after the daemon
+            // starts on an ordinary first install.
+            ...(() => {
+                const framework = readProjectFramework(directory);
+                return framework === undefined ? {} : { framework };
+            })(),
+            // Decided from the session that actually went away, not from a lifetime tally: the lease
+            // sentence is only right when the thing that vanished WAS a lease.
+            leaseExpired: (() => {
+                const departed = options.sessions.lastDeparted();
+                return departed === undefined ? false : (options.wasReapedLease?.(departed) ?? false);
+            })(),
+            // How long this daemon has been waiting with no app. The diagnosis uses it to surface
+            // "install never finished" — the same condition telemetry already knows about.
+            ...(() => {
+                const upMs = stallUptime(Date.now());
+                return upMs === undefined ? {} : { daemonUpMs: upMs };
+            })(),
+            // Read here rather than at boot: `.reticle.json` can be written by `init` after this daemon
+            // started, which is the ordinary first-install order, and a port cached from before it existed
+            // would make the daemon confidently report no mismatch on the one run where there is one.
+            ...(() => {
+                const configured = readProjectPort(directory);
+                return configured === undefined ? {} : { projectPort: configured };
+            })(),
+            ...(0 === siblingListeners.length ? {} : { siblingListeners }),
+        });
+    };
+    options.sessions.setNoSessionHint(() => {
+        const scope = projectScopeFacts();
+        return (explain().message +
+            // Prose for the human, then the literal command for the agent. Both consume the same scope
+            // facts so a discovered workspace config cannot become an `init` recommendation below it.
+            ` ${renderNextAction(nextAction(scope))}` +
+            (attachFailure ?? ''));
     });
-    options.sessions.setNoSessionNextAction(nextAction);
-    options.sessions.setNoSessionHint(() => diagnoseNoSession({
-        everConnected: options.sessions.everConnected(),
-        // Read WHEN ASKED, for the same reason `projectPort` below is: `.reticle.json` is routinely
-        // written by `init` after this daemon started — that is the ordinary first-install order — and
-        // the boot-time answer is then permanently stale. Reported from the field as `reticle status`
-        // saying the project had never been through `init` about a project whose config named its
-        // framework and its projectId, and whose real problem was a dev server older than the plugin.
-        // The boot value still counts: it is the one the daemon scoped its sessions with.
-        initialized: isWired(),
-        listening,
-        slowListeners,
-        port: options.port,
-        // The directory `initialized` was decided in. Named in the message because "there is no
-        // `.reticle.json`" is a claim about ONE directory, and a reader standing somewhere else
-        // cannot tell whether it is a claim about their app at all.
-        directory,
-        // Where the config actually is, when it is not here — and where we looked, when it is
-        // nowhere. Computed only on the branch that needs it: a wired daemon has its answer already,
-        // and a workspace scan on every hint would be a directory walk per tool refusal.
-        ...(isWired()
-            ? {}
-            : (() => {
-                const discovery = discoverProjectConfigs(directory);
-                const elsewhere = discovery.found.filter((c) => c.directory !== directory);
-                return 0 === elsewhere.length
-                    ? { searchedDirectories: discovery.searched }
-                    : {
-                        configsElsewhere: elsewhere.map((c) => ({
-                            directory: c.directory,
-                            ...(c.projectId === undefined ? {} : { projectId: c.projectId }),
-                        })),
-                    };
-            })()),
-        // The one fact that outranks every absence below it, and the reason a fresh daemon stopped
-        // claiming that an install which has demonstrably worked has never worked.
-        previouslyConnected: connectedBefore(),
-        // Ranks the causes. Read when asked, like the rest: `init` writes this file after the daemon
-        // starts on an ordinary first install.
-        ...(() => {
-            const framework = readProjectFramework(directory);
-            return framework === undefined ? {} : { framework };
-        })(),
-        leaseExpired: (options.reapedLeases?.() ?? 0) > 0,
-        // How long this daemon has been waiting with no app. The diagnosis uses it to surface
-        // "install never finished" — the same condition telemetry already knows about.
-        ...(() => {
-            const upMs = stallUptime(Date.now());
-            return upMs === undefined ? {} : { daemonUpMs: upMs };
-        })(),
-        // Read here rather than at boot: `.reticle.json` can be written by `init` after this daemon
-        // started, which is the ordinary first-install order, and a port cached from before it existed
-        // would make the daemon confidently report no mismatch on the one run where there is one.
-        ...(() => {
-            const configured = readProjectPort(directory);
-            return configured === undefined ? {} : { projectPort: configured };
-        })(),
-    }) +
-        // Prose for the human, then the literal command for the agent. Appended rather than folded
-        // into the diagnosis so that file stays pure and its cases stay independently pinned.
-        ` ${renderNextAction(nextAction())}` +
-        (attachFailure ?? ''));
+    options.sessions.setNoSessionReason(() => explain().reason);
     return () => {
         clearInterval(timer);
         options.sessions.setConnectionRecorder(undefined);
         options.sessions.setNoSessionHint(undefined);
+        options.sessions.setNoSessionReason(undefined);
         options.sessions.setNoSessionNextAction(undefined);
     };
 }
@@ -226,8 +276,8 @@ export function startNoSessionWatch(options) {
  * adjacent blocks in the bootstrap.
  */
 export function wireSessionScope(sessions, activeProjectId, port, 
-/** Reader for the pool's aged-out-lease count; omitted when this daemon runs no pool. */
-reapedLeases, 
+/** Asks the pool whether a session id was a lease it aged out; omitted when there is no pool. */
+wasReapedLease, 
 /** Opens a URL in a Reticle-owned browser (the pool). Omitted ⇒ auto-attach is off. */
 attach) {
     if (activeProjectId !== undefined)
@@ -236,7 +286,7 @@ attach) {
         sessions,
         port,
         initialized: activeProjectId !== undefined,
-        ...(reapedLeases === undefined ? {} : { reapedLeases }),
+        ...(wasReapedLease === undefined ? {} : { wasReapedLease }),
         ...(attach === undefined ? {} : { attach }),
     });
 }

package/dist/session/output-budget.js

@@ -50,7 +50,10 @@ export function estimateTokens(text) {
 }
 export function sizeCost(payload) {
     const json = JSON.stringify(payload) ?? '';
-    return { bytes: json.length, tokens: estimateTokens(json) };
+    // Actual UTF-8 wire bytes, not json.length (UTF-16 code units) — the field is labeled `bytes`
+    // and drives the large-snapshot recommendation, so a multibyte-heavy payload was under-counted.
+    const bytes = Buffer.byteLength(json, 'utf8');
+    return { bytes, tokens: estimateTokens(json) };
 }
 /**
  * Attach a `cost` size preview to a read result. Pure: the cost is computed over the result BEFORE

package/dist/session/pending-commands.d.ts

@@ -11,6 +11,16 @@ import type { CommandResult } from '@reticlehq/core';
  */
 export declare class CommandTimeoutError extends Error {
 }
+/**
+ * The transport under this command was displaced by a newer connection claiming the same id.
+ *
+ * Typed, not a string to match on, because the two failures need OPPOSITE handling and the only
+ * thing separating them used to be the wording of a message. A read can simply be re-asked on the
+ * successor; a WRITE cannot — nobody can prove it did not land — so the honest answer is that the
+ * outcome went unobserved, which is a verdict this engine already has a word for.
+ */
+export declare class SessionReplacedError extends Error {
+}
 export declare class PendingCommands {
     #private;
     /** Next correlation id. Monotonic per session, so a reply can never match an earlier command. */
@@ -20,5 +30,5 @@ export declare class PendingCommands {
     /** Resolve the command this reply belongs to. Unknown ids are ignored, never thrown on. */
     settle(result: CommandResult): void;
     /** Reject everything still in flight — used on disconnect, so no caller waits on a dead socket. */
-    rejectAll(reason: string): void;
+    rejectAll(reason: string, replaced?: boolean): void;
 }

package/dist/session/pending-commands.js

@@ -10,6 +10,16 @@
  */
 export class CommandTimeoutError extends Error {
 }
+/**
+ * The transport under this command was displaced by a newer connection claiming the same id.
+ *
+ * Typed, not a string to match on, because the two failures need OPPOSITE handling and the only
+ * thing separating them used to be the wording of a message. A read can simply be re-asked on the
+ * successor; a WRITE cannot — nobody can prove it did not land — so the honest answer is that the
+ * outcome went unobserved, which is a verdict this engine already has a word for.
+ */
+export class SessionReplacedError extends Error {
+}
 export class PendingCommands {
     #pending = new Map();
     #seq = 0;
@@ -39,10 +49,10 @@ export class PendingCommands {
         pending.resolve(result);
     }
     /** Reject everything still in flight — used on disconnect, so no caller waits on a dead socket. */
-    rejectAll(reason) {
+    rejectAll(reason, replaced = false) {
         for (const [id, pending] of this.#pending) {
             clearTimeout(pending.timer);
-            pending.reject(new Error(reason));
+            pending.reject(replaced ? new SessionReplacedError(reason) : new Error(reason));
             this.#pending.delete(id);
         }
     }

package/dist/session/resolve-within.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Resolve a session, or spend the caller's stated budget waiting for one to arrive.
+ *
+ * Every tool that takes a `timeout_ms` used to resolve the session as its FIRST statement, so an
+ * empty session map threw before the budget was ever consulted. A caller that said "wait up to
+ * thirty seconds for the app" was refused in under a millisecond, and the only way to actually wait
+ * was to poll `reticle_sessions` blind.
+ *
+ * That is the wrong answer to the commonest situation in the product. The moment an agent has run
+ * `init` and restarted the dev server is exactly the moment there is no session yet and one is about
+ * to appear — and `no_session` is the refusal agents hit most. An agent that gets refused rarely
+ * retries; it concludes and moves on. Spending the budget it already asked for turns the most common
+ * dead end into a wait that ends in a verdict.
+ *
+ * Deliberately narrow in two ways.
+ *
+ * Only the EMPTY case waits. A `sessionId` that names a session which is not connected while others
+ * are is a different error with a different fix, and waiting on it would hide a typo behind a
+ * timeout.
+ *
+ * The original error is what gets thrown on expiry, never a generic timeout message. That error
+ * carries the daemon's whole diagnosis — the port scan, the next action, the literal command — and
+ * it is the single most valuable string this product emits to an agent that has nothing connected.
+ * Replacing it with "timed out" would trade the answer for a stopwatch reading.
+ */
+/** Just the part of the session manager this needs, so a test does not have to build one. */
+export interface ResolvableSessions<S> {
+    resolve: (sessionId?: string) => S;
+    count: () => number;
+}
+export declare function resolveSessionWithin<S>(sessions: ResolvableSessions<S>, sessionId: string | undefined, timeoutMs: number, deps: {
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+}): Promise<S>;

package/dist/session/resolve-within.js

@@ -0,0 +1,53 @@
+/**
+ * Resolve a session, or spend the caller's stated budget waiting for one to arrive.
+ *
+ * Every tool that takes a `timeout_ms` used to resolve the session as its FIRST statement, so an
+ * empty session map threw before the budget was ever consulted. A caller that said "wait up to
+ * thirty seconds for the app" was refused in under a millisecond, and the only way to actually wait
+ * was to poll `reticle_sessions` blind.
+ *
+ * That is the wrong answer to the commonest situation in the product. The moment an agent has run
+ * `init` and restarted the dev server is exactly the moment there is no session yet and one is about
+ * to appear — and `no_session` is the refusal agents hit most. An agent that gets refused rarely
+ * retries; it concludes and moves on. Spending the budget it already asked for turns the most common
+ * dead end into a wait that ends in a verdict.
+ *
+ * Deliberately narrow in two ways.
+ *
+ * Only the EMPTY case waits. A `sessionId` that names a session which is not connected while others
+ * are is a different error with a different fix, and waiting on it would hide a typo behind a
+ * timeout.
+ *
+ * The original error is what gets thrown on expiry, never a generic timeout message. That error
+ * carries the daemon's whole diagnosis — the port scan, the next action, the literal command — and
+ * it is the single most valuable string this product emits to an agent that has nothing connected.
+ * Replacing it with "timed out" would trade the answer for a stopwatch reading.
+ */
+/** How often to re-ask. A session appearing is an out-of-band event; this is a plain poll. */
+const POLL_MS = 250;
+export async function resolveSessionWithin(sessions, sessionId, timeoutMs, deps) {
+    try {
+        return sessions.resolve(sessionId);
+    }
+    catch (first) {
+        // Nothing to wait FOR unless the map is empty, and nothing to wait WITH unless a budget was
+        // given. Either way the caller gets the same error it would have got before.
+        if (timeoutMs <= 0 || sessions.count() > 0)
+            throw first;
+        const deadline = deps.now() + timeoutMs;
+        for (;;) {
+            const remaining = deadline - deps.now();
+            if (remaining <= 0)
+                throw first;
+            await deps.sleep(Math.min(POLL_MS, remaining));
+            try {
+                return sessions.resolve(sessionId);
+            }
+            catch {
+                // Still nothing. Keep the FIRST error: it was raised when the daemon had most recently
+                // computed its diagnosis, and re-throwing the newest one would report the same fact with a
+                // staler explanation.
+            }
+        }
+    }
+}

package/dist/session/session-health.d.ts

@@ -45,6 +45,15 @@ export declare function healthEnvelope(session: Session): HealthEnvelope;
  * warn-only so background testing never breaks.
  */
 export declare function refuseIfThrottled(session: Session, refuse: unknown): void;
+/**
+ * Suffix the starvation note onto a FAILED predicate verdict when the tab is throttled. A pass is
+ * returned untouched — starvation is context for a failure, not a reason to doubt a hold. Pure and
+ * generic over the verdict shape so assert/wait_for/act_and_wait share one rule.
+ */
+export declare function annotateStarvedFailure<V extends {
+    pass?: boolean;
+    failureReason?: string;
+}>(session: Session, verdict: V): V;
 /** The page's own visibility/runtime report, narrowed out of an untrusted PAGE_HEALTH payload. */
 interface HealthReport {
     hidden: boolean | undefined;

package/dist/session/session-health.js

@@ -35,6 +35,29 @@ export function refuseIfThrottled(session, refuse) {
         throw new Error(`refusing to act: ${THROTTLED_WARNING}`);
     }
 }
+/**
+ * The sentence appended to a FAILED predicate verdict waited out on a throttled tab.
+ *
+ * A starved tab and a missing element read identically as a bare near-miss: after a hard reload a
+ * backgrounded tab can sit on its loading state forever (hydration starved, nothing painted), and
+ * `wait_for { text }` timing out there looks exactly like "the code did not render" (#521). The
+ * health envelope already rode alongside saying `throttled:true`, but nothing connected it to the
+ * verdict an agent actually gates on. Appended, not replacing: the original diagnosis still leads,
+ * and on a healthy tab the failure says exactly what it always said.
+ */
+const STARVED_WAIT_NOTE = ' (the tab was throttled during this wait, so starvation can look exactly like absence: bring it to the front and re-check before concluding this is genuinely missing)';
+/**
+ * Suffix the starvation note onto a FAILED predicate verdict when the tab is throttled. A pass is
+ * returned untouched — starvation is context for a failure, not a reason to doubt a hold. Pure and
+ * generic over the verdict shape so assert/wait_for/act_and_wait share one rule.
+ */
+export function annotateStarvedFailure(session, verdict) {
+    if (true === verdict.pass || verdict.failureReason === undefined)
+        return verdict;
+    if (true !== session.throttled())
+        return verdict;
+    return { ...verdict, failureReason: `${verdict.failureReason}${STARVED_WAIT_NOTE}` };
+}
 /**
  * Narrow a PAGE_HEALTH payload. Every field is optional on the wire — an older SDK does not report
  * `runtime` at all — so each is returned as undefined rather than defaulted here, letting the caller

package/dist/session/session-info.d.ts

@@ -8,6 +8,15 @@ export interface SessionInfo {
     title?: string;
     adapters: string[];
     hasCapabilities: boolean;
+    /**
+     * Which shell answered: `web`, `electron` or `tauri`.
+     *
+     * Absent — never defaulted to `web` — on an SDK too old to report one, because the guess is wrong
+     * on exactly the machines this exists to tell apart. Two windows on the same url are otherwise
+     * indistinguishable, and a browser tab is not a desktop app: it has none of its IPC, and it does
+     * not render like it.
+     */
+    runtime?: string;
     /** Present only when the page's SDK version differs from the daemon's — see version-skew.ts. */
     versionSkew?: string;
     /** ms since the SDK last reported anything (silence ⇒ likely throttled). */
@@ -19,6 +28,13 @@ export interface SessionInfo {
     recommendation?: string;
     stale?: boolean;
     cleanup_suggestion?: string;
+    /**
+     * present ONLY when this tab has stopped answering commands — attached, streaming events, and
+     * missing every command budget. Never `false`: absence means "answering, or not asked yet".
+     */
+    unresponsive?: true;
+    /** present with `unresponsive` — the in-protocol way out of a wedged tab. */
+    unresponsive_suggestion?: string;
     /** present only when the human has flagged bugs on this tab — count of pending review marks. */
     pendingMarks?: number;
     /** present with pendingMarks — nudges the agent to drain them with reticle_review. */
@@ -47,11 +63,13 @@ interface SessionView {
     title: string;
     adapters: string[];
     hasCapabilities: boolean;
+    runtime: string | undefined;
     versionSkew: string | undefined;
     hidden: boolean;
     health: () => SessionHealth;
     staleMs: () => number;
     pendingMarkCount: () => number;
+    unresponsive: () => boolean;
 }
 /**
  * Project a live Session into the shape the tools return.

package/dist/session/session-info.js

@@ -25,6 +25,8 @@ export function buildSessionInfo(session) {
         ...('' === session.title.trim() ? {} : { title: session.title }),
         adapters: session.adapters,
         hasCapabilities: session.hasCapabilities,
+        // Omitted when the page never said, so absence stays readable as "unknown" rather than "web".
+        ...(session.runtime === undefined ? {} : { runtime: session.runtime }),
         // On every listing, not buried in a log — skew explains failures that read as app bugs.
         ...(session.versionSkew === undefined ? {} : { versionSkew: session.versionSkew }),
         hidden: session.hidden,
@@ -35,6 +37,15 @@ export function buildSessionInfo(session) {
         base.cleanup_suggestion =
             'Call reticle_session{action:"end"} to free this session before starting new work.';
     }
+    // A tab that is attached and answering nothing. Said out loud because every health field beside it
+    // reads fine — that combination is exactly what made the wedge invisible.
+    if (session.unresponsive()) {
+        base.unresponsive = true;
+        base.unresponsive_suggestion =
+            'This tab is connected but has stopped answering commands, so every call against it will time ' +
+                'out. Ending the session does not revive the page. Reload the tab, or run `reticle open <url>` ' +
+                'to get a fresh one — it will no longer hand this tab back.';
+    }
     // Surface human bug reports in reticle_sessions (only when > 0, so a clean session adds nothing).
     const marks = session.pendingMarkCount();
     if (marks > 0) {

package/dist/session/session-manager.d.ts

@@ -1,3 +1,4 @@
+import type { NoSessionReason } from '@reticlehq/core';
 import { Session, type SessionInfo } from './session.js';
 import { AttachmentHistory } from './attachment-history.js';
 import type { NoSessionNextAction } from './no-session-next-action.js';
@@ -37,6 +38,8 @@ export declare class SessionManager {
      * already computed for the error path; this exposes it to the read path too.
      */
     noSessionHint(): string | undefined;
+    setNoSessionReason(reason: (() => NoSessionReason | undefined) | undefined): void;
+    noSessionReason(): NoSessionReason | undefined;
     setNoSessionNextAction(next: (() => NoSessionNextAction | undefined) | undefined): void;
     noSessionNextAction(): NoSessionNextAction | undefined;
     everConnected(): boolean;
@@ -47,6 +50,17 @@ export declare class SessionManager {
         at: number;
         reason: string;
     } | undefined;
+    /**
+     * The id of the session that most recently went away, if any.
+     *
+     * Distinct from {@link lastClosure}, which only records closes the bridge itself initiated
+     * (handshake refusals, auth failures) — an ordinary disconnect never reaches it. This reads the
+     * tombstone ring `remove()` maintains, so it covers every departure.
+     *
+     * Read by the no-session diagnosis, which needs to say something about the session that actually
+     * vanished rather than about the daemon's lifetime history (#611).
+     */
+    lastDeparted(): string | undefined;
     resolve(sessionId?: string, scope?: ResolveScope): Session;
 }
 export {};