@phnx-labs/agents-cli 1.22.83 → 1.22.85

package/dist/lib/session/prompt.js

@@ -5,16 +5,6 @@
  * wrapper tags, team-spawn boilerplate) so that only the real user intent
  * remains. Used by the session picker to show a human-readable topic line.
  */
-/** Patterns that cause the entire message to be skipped for topic extraction. */
-const WHOLE_MESSAGE_SKIP_PATTERNS = [
-    /<permissions instructions>/i,
-    /<collaboration_mode>/i,
-    /^# AGENTS\.md instructions for\b/im,
-    /<local-command-caveat>/i,
-    // Slash-command invocations (e.g. /continue, /done) — actual user intent
-    // lives in the next user message, not in these wrapper tags.
-    /<command-(message|name|args)>/i,
-];
 /** Per-line noise patterns stripped during prompt cleaning (env context, bare paths, etc). */
 const NOISE_LINE_PATTERNS = [
     /^(cwd|shell|current_date|timezone|os|platform|arch|home|user)\b\s*:/i,
@@ -58,6 +48,18 @@ const SYNTHETIC_USER_MESSAGE_PATTERNS = [
     /^\s*\[Request interrupted/i,
     /^\s*Base directory for this skill:/i,
     /^\s*[A-Za-z][A-Za-z-]* hook feedback:/,
+    /^\s*<\/?notification\b/i,
+    /^\s*<\/?hook_?result\b/i,
+    /^\s*\[SYSTEM NOTIFICATION/i,
+    /^\s*\[Image: original/i,
+    /^\s*Skill tool loaded instructions/i,
+    // A skill expansion the harness injects when a `/name` command resolves: the
+    // routing line the loader prepends to the skill body.
+    /^\s*\*\*`\/[\w:-]+` routes to/,
+    // The AGENTS.md preamble Claude injects ahead of a turn. `m` because it can
+    // follow other injected blocks rather than opening the message; this is the
+    // one pattern that only `extractSessionTopic` used to carry.
+    /^# AGENTS\.md instructions for\b/im,
 ];
 /**
  * True when a `role=user` message is harness-injected scaffolding, not a genuine
@@ -92,6 +94,25 @@ export function cleanFirstUserMessage(raw) {
     const clean = unwrapUserQuery(raw);
     return clean || undefined;
 }
+/**
+ * LATEST genuine user message from an already-normalized event stream.
+ *
+ * The operative request of a `/continue`d, redirected, or interrupted-and-
+ * restated session is the last thing the user said, not the first (PHNX-3939).
+ * Same rejection rules as {@link firstUserMessageFromEvents} — walking from the
+ * end so a long transcript stops at the first genuine turn it meets.
+ */
+export function lastUserMessageFromEvents(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event.type !== 'message' || event.role !== 'user' || event._synthetic)
+            continue;
+        const latest = cleanFirstUserMessage(event.content);
+        if (latest)
+            return latest;
+    }
+    return undefined;
+}
 /** First genuine user message from an already-normalized event stream. */
 export function firstUserMessageFromEvents(events) {
     for (const event of events) {
@@ -257,19 +278,249 @@ export function cleanGeneratedSessionLabel(title) {
     const classified = classifyUserPrompt(trimmed);
     return classified.kind === 'skill' ? classified.clean : trimmed;
 }
-/** Extract a one-line topic from a raw user message, or undefined if the message is pure noise. */
+/**
+ * Extract a one-line topic from a raw user message, or undefined if the message
+ * is pure noise.
+ *
+ * Rejection is {@link isSyntheticUserMessage} — the SAME list the turn cleaner
+ * uses. This function used to consult a shorter, looser copy of it
+ * (permissions / collaboration / AGENTS.md / local-command-caveat /
+ * `<command-*>` only), which is how a `/model` echo (`<local-command-stdout>`)
+ * or a skill body ("Base directory for this skill:") became a session's topic —
+ * and then its displayed title — while `cleanFirstUserMessage` rejected the same
+ * text (PHNX-3939). Whatever is not a genuine user turn is not a topic either.
+ *
+ * The check runs twice on purpose: once on the raw message, and again after
+ * {@link cleanSessionPrompt} strips wrapper tags, since stripping can expose a
+ * marker (a skill body) that the tags were hiding.
+ */
 export function extractSessionTopic(raw) {
     if (!raw.trim())
         return undefined;
-    if (WHOLE_MESSAGE_SKIP_PATTERNS.some(pattern => pattern.test(raw))) {
+    if (isSyntheticUserMessage(raw))
         return undefined;
-    }
     const cleaned = cleanSessionPrompt(raw);
     if (!cleaned)
         return undefined;
-    if (WHOLE_MESSAGE_SKIP_PATTERNS.some(pattern => pattern.test(cleaned))) {
+    if (isSyntheticUserMessage(cleaned))
         return undefined;
-    }
     const firstLine = cleaned.split('\n').map(line => line.trim()).find(Boolean);
     return firstLine || undefined;
 }
+/** `host:/abs/path.png`, `/abs/path.pdf`, or a bare `@rel/path` mention. */
+const REQUEST_ATTACHMENT_RE = /^(?:[\w.-]+:)?\/\S.*\.(?:png|jpe?g|gif|pdf|mov|mp4)$|^@\S+$/i;
+/**
+ * A line the user pasted out of a terminal rather than typed: a shell prompt
+ * echo (`box % `, `$ `), the CLI's own run banners, a resume hint, or the
+ * box-drawing frame of a TUI panel — a pasted `│ script (hooks, daemon, ext)`
+ * row is chrome, and it read as the request's first sentence before this.
+ */
+const REQUEST_ECHO_RE = /^\S+ % |^\[agents\]|^Running: |^Session [0-9a-f]{8}|^\s*Resume later:|^✔ |^\s*Week \d+% left|^\s*\$ |^[\u2500-\u257F\u2580-\u259F]/;
+/** The full `<command-name>…</command-name> … <command-args>…</command-args>` pair. */
+const COMMAND_WRAPPER_PAIR_RE = /<command-name>\s*(\/?[\w:-]+)\s*<\/command-name>[\s\S]*?<command-args>([\s\S]*?)<\/command-args>/;
+/** `/name <id> [prose]` — a slash command typed with a session id argument. */
+const SLASH_WITH_ID_RE = /^\/([\w:-]+)\s+([A-Za-z0-9_-]{8,})\s*([\s\S]*)$/;
+/** `$name <id>` — the same invocation as the resume banner echoes it. */
+const DOLLAR_WITH_ID_RE = /^\s*\$(\w[\w:-]*)\s+([0-9a-f-]{8,})\s*([\s\S]*)$/;
+/** The stock body `/continue` and friends append when there is nothing else to say. */
+const CONTINUE_FILLER = "Let's continue this session.";
+/** A sentence ends, or continues past, a terminator — the tell that a line is prose. */
+const SENTENCE_PUNCTUATION_RE = /[.?!]\s|[.?!]$/;
+/**
+ * An absolute or `~`-rooted image path appearing INSIDE a line of prose. Same
+ * shape as {@link IMAGE_PATH_RE}, global so every path on the line is pulled
+ * out; matched across spaces because a CleanShot filename carries them.
+ */
+const INLINE_IMAGE_PATH_RE = /[\/~][^\n]*?\.(?:png|jpe?g|gif|webp|heic|bmp|svg)\b/gi;
+/**
+ * A bare session UUID opening the turn — how `agents message <id> <text>`
+ * arrives. Full 8-4-4-4-12 only, so an ordinary word is never mistaken for one.
+ */
+const LEADING_SESSION_UUID_RE = /^\s*[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\s+/i;
+/** Leading tokens that mark a multi-line paste as terminal output, not a question. */
+const PASTED_OUTPUT_HEAD_RE = /^(agents|git|gh|npm|bun|ls|cat|curl|ssh|scp)\b/;
+/**
+ * First sentence of a block of text, flattened and capped.
+ *
+ * Leading markdown headings are skipped so the headline is the ask, not the
+ * section label. A block that then opens with markdown structure (a table row, a
+ * bullet, a numbered item) is reduced to its first LINE — a sentence-terminator
+ * scan across a table would otherwise splice two cells together. Markdown
+ * emphasis characters are dropped so a headline never renders as raw syntax. A
+ * "sentence" shorter than 12 characters is not one (an abbreviation, a version
+ * number), so the whole flattened text is kept instead.
+ */
+export function firstSentence(text, cap = 96) {
+    // A block that opens with markdown HEADINGS names its section before it says
+    // anything: `## Mission` / `Ship the CLI half of …` headlines as "Mission",
+    // which is the label, not the ask. Skip leading heading lines and headline the
+    // first real line under them. A heading-only block keeps the heading — there
+    // is nothing else, and inventing a line is not an option.
+    let body = text.replace(/\r/g, '').trimStart();
+    while (/^#{1,6}\s/.test(body)) {
+        const newline = body.indexOf('\n');
+        if (newline < 0)
+            break;
+        const rest = body.slice(newline + 1).trimStart();
+        if (!rest)
+            break;
+        body = rest;
+    }
+    const trimmed = body.trim() || text.trim();
+    const structured = /^([|\-*]|1\.)/.test(trimmed);
+    const source = structured ? (trimmed.split('\n')[0] ?? '') : trimmed;
+    const flat = source
+        // A leading list marker is syntax, not words.
+        .replace(/^\s*(?:[-*+]|\d+\.)\s+/, '')
+        .replace(/[*`#|_]+/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const match = flat.match(/^(.+?[.!?])(\s|$)/);
+    const sentence = match && match[1].length >= 12 ? match[1] : flat;
+    return sentence.length <= cap ? sentence : `${sentence.slice(0, cap - 1).trimEnd()}…`;
+}
+/** A `/name <id>` invocation with no prose of its own. */
+function bareCommandRequest(command) {
+    return { kind: 'skill', command, text: '', headline: command, attachments: [], pastedLines: 0 };
+}
+/** Image attachments the row carries that the prose did not already name. */
+function attachmentsFromRow(attachments, already) {
+    if (!attachments?.length)
+        return [];
+    const seen = new Set(already.map((a) => a.name));
+    const extra = [];
+    for (const attachment of attachments) {
+        const name = (attachment.name || attachment.path || '').split(/[\\/]/).pop()?.trim();
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        extra.push({ kind: attachment.mediaType?.startsWith('image/') ? 'image' : 'file', name });
+    }
+    return extra;
+}
+/**
+ * Split one raw user turn into prose, attachments and pasted terminal echo
+ * WITHOUT rewriting a word of it (PHNX-3939). Returns `undefined` when the turn
+ * is harness-injected scaffolding or carries nothing to show.
+ *
+ * Order matters and mirrors how a turn is actually assembled:
+ *   1. a `<user_query>` wrapper is unwrapped (Grok/Cursor);
+ *   2. a `/name <id>` or `<command-name>` invocation becomes `command`, and any
+ *      prose inside `<command-args>` becomes the request itself — this is what
+ *      makes a `/plan -- Wait hold on…` turn read as the user's sentence rather
+ *      than as a bare command name;
+ *   3. whole-message scaffolding is rejected;
+ *   4. a multi-line paste that opens with a command and asks nothing is pasted
+ *      output, not a request;
+ *   5. every remaining segment (split on ` -- ` and per line) is classified as
+ *      an attachment, terminal echo, or prose.
+ *
+ * `opts.attachments` are the row's own recorded attachments, folded in so an
+ * image the harness captured but the text never named still shows as a chip.
+ */
+export function tidyRequest(raw, opts = {}, depth = 0) {
+    let text = (raw ?? '').trim().replace(/^"+/, '');
+    if (!text)
+        return undefined;
+    text = unwrapUserQuery(text);
+    const wrapped = COMMAND_WRAPPER_PAIR_RE.exec(text);
+    let prefix;
+    if (!wrapped && depth < 3) {
+        const slash = SLASH_WITH_ID_RE.exec(text);
+        if (slash) {
+            const command = `/${slash[1]} ${slash[2].slice(0, 8)}`;
+            const prose = slash[3].trim();
+            if (!prose || prose === CONTINUE_FILLER)
+                return bareCommandRequest(command);
+            const inner = tidyRequest(prose, opts, depth + 1);
+            if (!inner)
+                return undefined;
+            return { ...inner, command, headline: `/${slash[1]} · ${inner.headline}` };
+        }
+        const dollar = DOLLAR_WITH_ID_RE.exec(text);
+        if (dollar && !dollar[3].replace(CONTINUE_FILLER, '').trim()) {
+            return bareCommandRequest(`/${dollar[1]} ${dollar[2].slice(0, 8)}`);
+        }
+    }
+    if (wrapped) {
+        const name = wrapped[1].startsWith('/') ? wrapped[1] : `/${wrapped[1]}`;
+        const args = wrapped[2].trim().replace(/^--\s*/, '');
+        if (!args || /^[0-9a-f-]{8,}$/i.test(args)) {
+            return bareCommandRequest(`${name} ${args.slice(0, 8)}`.trim());
+        }
+        text = args;
+        prefix = name;
+    }
+    if (isSyntheticUserMessage(text))
+        return undefined;
+    const lines = text.split('\n').filter((line) => line.trim());
+    if (lines.length >= 3 && PASTED_OUTPUT_HEAD_RE.test(lines[0].trim()) && !text.slice(0, 200).includes('?')) {
+        return {
+            kind: 'command',
+            text: '',
+            headline: `pasted terminal output (${lines.length} lines)`,
+            attachments: [],
+            pastedLines: lines.length,
+        };
+    }
+    const prose = [];
+    const attachments = [];
+    let pastedLines = 0;
+    for (const segment of text.split(/\s+--\s+/)) {
+        for (const rawLine of segment.split('\n')) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            if (REQUEST_ATTACHMENT_RE.test(line)) {
+                const kind = line.startsWith('@')
+                    ? 'dir'
+                    : /\.(png|jpe?g|gif)$/i.test(line) ? 'image' : 'file';
+                const name = line.startsWith('@') ? line : (line.split(':').pop() ?? line).split('/').pop() ?? line;
+                attachments.push({ kind, name });
+                continue;
+            }
+            // A long line that is mostly flags and never punctuates is a pasted
+            // command invocation, not a sentence — the `agents run … --device auto
+            // --cwd … --session-id … --strategy balanced` banner a dispatch echoes.
+            const flagSoup = line.length > 80
+                && (line.match(/\s--\w/g) ?? []).length >= 3
+                && !SENTENCE_PUNCTUATION_RE.test(line);
+            // The `<id> --flag` shape a banner continues on, and any flag-bearing
+            // continuation once a pasted line has already been seen — so a sentence
+            // containing a dash survives when nothing was pasted.
+            const continuesPaste = pastedLines > 0 && /--\w+/.test(line) && !SENTENCE_PUNCTUATION_RE.test(line);
+            if (REQUEST_ECHO_RE.test(line) || /^[0-9a-f-]{8,}\s+--/.test(line) || flagSoup || continuesPaste) {
+                pastedLines++;
+                continue;
+            }
+            // An image path INSIDE a prose line (a screenshot dropped mid-sentence)
+            // becomes a chip and leaves the sentence intact, rather than sitting in
+            // the middle of the request text as a wall of path.
+            const withoutImages = line.replace(INLINE_IMAGE_PATH_RE, (match) => {
+                attachments.push({ kind: 'image', name: match.split('/').pop() ?? match });
+                return '';
+            }).replace(/\s{2,}/g, ' ').trim();
+            if (withoutImages)
+                prose.push(withoutImages);
+        }
+    }
+    attachments.push(...attachmentsFromRow(opts.attachments, attachments));
+    const joined = prose.join(' ').trim();
+    if (!joined && attachments.length === 0)
+        return undefined;
+    // Headline from the LINES, not the joined text: `firstSentence` skips a leading
+    // markdown heading, which it can only see while the line breaks survive. A
+    // leading bare session UUID is addressing, not the ask (`agents message
+    // <id> <text>` lands as `<uuid> Hey Claude…`), so it is dropped from the
+    // headline — the full id stays in `text`.
+    const headlineSource = prose.join('\n').replace(LEADING_SESSION_UUID_RE, '');
+    const headline = joined ? firstSentence(headlineSource || prose.join('\n'), 120) : '[image]';
+    return {
+        kind: joined ? 'text' : 'image',
+        text: joined,
+        headline: prefix ? `${prefix} · ${headline}` : headline,
+        ...(prefix ? { command: prefix } : {}),
+        attachments,
+        pastedLines,
+    };
+}

package/dist/lib/session/remote/peer-stream.d.ts

@@ -0,0 +1,47 @@
+import type { DeviceProfile } from '../../devices/registry.js';
+/** First reconnect delay after a failed subscription. */
+export declare const PEER_BACKOFF_BASE_MS = 2000;
+/** Ceiling the doubling delay saturates at. */
+export declare const PEER_BACKOFF_CAP_MS = 60000;
+/** Consecutive failed spawns before the peer is parked. */
+export declare const PEER_PARK_AFTER_FAILURES = 3;
+/** Bytes of a peer's stderr retained for the `unavailable` reason. */
+export declare const PEER_STDERR_BYTES = 2048;
+/** How often a parked peer re-checks the device registry for a refresh. */
+export declare const PEER_REGISTRY_POLL_MS = 5000;
+/**
+ * Reconnect delay for `failures` consecutive failed spawns: 0 for a healthy
+ * peer, then {@link PEER_BACKOFF_BASE_MS} doubling to {@link PEER_BACKOFF_CAP_MS}.
+ */
+export declare function peerBackoffDelayMs(failures: number, base?: number, cap?: number): number;
+export interface PeerStreamOptions {
+    /** The device to subscribe to. */
+    device: DeviceProfile;
+    /** Remote command to run over ssh, already shell-quoted for the peer's OS. */
+    command: string;
+    signal: AbortSignal;
+    /**
+     * One line of the peer's stdout. Return `true` when the line was a valid
+     * protocol event — that is the health signal that resets the backoff.
+     */
+    onLine: (line: string) => boolean;
+    /** Report the peer as unavailable, with the captured reason. */
+    onUnavailable: (reason: string) => void;
+    /** Override the first backoff delay (tests). */
+    backoffBaseMs?: number;
+    /** Override the backoff ceiling (tests). */
+    backoffCapMs?: number;
+    /** Override the park threshold (tests). */
+    parkAfterFailures?: number;
+    /** Override the ssh binary (tests). */
+    sshBin?: string;
+    /** Override the parked peer's registry re-check cadence (tests). */
+    registryPollMs?: number;
+    /** Override the registry file a parked peer waits on (tests). */
+    registryPath?: string;
+}
+/**
+ * Hold one peer subscription open for the life of the signal, reconnecting with
+ * backoff. Resolves when the signal aborts or the peer cannot be addressed.
+ */
+export declare function streamFromPeer(options: PeerStreamOptions): Promise<void>;

package/dist/lib/session/remote/peer-stream.js

@@ -0,0 +1,142 @@
+/**
+ * One peer's `--local` watch subscription, with connection hygiene.
+ *
+ * Both fleet fan-outs (`watchFleetSessions`, `watchFleetFeed`) subscribe to
+ * every dialable device with a long-lived `ssh <peer> agents … watch --json
+ * --local`. Both used to respawn that child on a bare 2 s timer with the
+ * child's stderr set to `'ignore'`, so an offline peer — and `isDialableDevice`
+ * deliberately never excludes one — got a fresh ssh every ConnectTimeout + 2 s
+ * for the whole life of the watcher, with the reason discarded. That is the
+ * ssh-child churn the 2026-09-03 incident reported.
+ *
+ * This module is the single implementation both fan-outs call:
+ *
+ * - exponential backoff per peer, {@link PEER_BACKOFF_BASE_MS} doubling to
+ *   {@link PEER_BACKOFF_CAP_MS}, reset the moment the peer delivers a healthy
+ *   protocol event;
+ * - the child's stderr captured (bounded to {@link PEER_STDERR_BYTES}) and
+ *   surfaced as the `unavailable` reason instead of being thrown away;
+ * - a peer that fails {@link PEER_PARK_AFTER_FAILURES} spawns in a row parked —
+ *   it stops the reconnect cycle and re-dials only when the device registry
+ *   changes or the capped backoff elapses;
+ * - abort listeners removed per iteration, so a watcher open for hours does not
+ *   accumulate one per reconnect on the caller's AbortSignal.
+ */
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import { createInterface } from 'node:readline';
+import { deviceIdentityArgs, sshTargetFor } from '../../devices/connect.js';
+import { SSH_OPTS, controlOpts } from '../../ssh-exec.js';
+import { getDevicesRegistryPath } from '../../state.js';
+/** First reconnect delay after a failed subscription. */
+export const PEER_BACKOFF_BASE_MS = 2_000;
+/** Ceiling the doubling delay saturates at. */
+export const PEER_BACKOFF_CAP_MS = 60_000;
+/** Consecutive failed spawns before the peer is parked. */
+export const PEER_PARK_AFTER_FAILURES = 3;
+/** Bytes of a peer's stderr retained for the `unavailable` reason. */
+export const PEER_STDERR_BYTES = 2_048;
+/** How often a parked peer re-checks the device registry for a refresh. */
+export const PEER_REGISTRY_POLL_MS = 5_000;
+/**
+ * Reconnect delay for `failures` consecutive failed spawns: 0 for a healthy
+ * peer, then {@link PEER_BACKOFF_BASE_MS} doubling to {@link PEER_BACKOFF_CAP_MS}.
+ */
+export function peerBackoffDelayMs(failures, base = PEER_BACKOFF_BASE_MS, cap = PEER_BACKOFF_CAP_MS) {
+    if (failures <= 0)
+        return 0;
+    return Math.min(cap, base * 2 ** (failures - 1));
+}
+/** Bounded tail of a child's stderr, kept for the unavailable reason. */
+function stderrTail(chunks, next, limit) {
+    const joined = chunks + next;
+    return joined.length > limit ? joined.slice(joined.length - limit) : joined;
+}
+/** Collapse captured stderr to one quotable line. */
+function reasonFor(exit, stderr) {
+    const detail = stderr.split('\n').map((line) => line.trim()).filter(Boolean).pop();
+    return detail ? `${exit}: ${detail}` : exit;
+}
+/** Await a delay, a device-registry change, or abort — whichever comes first. */
+async function parkedWait(options, delayMs) {
+    const registry = options.registryPath ?? getDevicesRegistryPath();
+    const pollMs = options.registryPollMs ?? PEER_REGISTRY_POLL_MS;
+    const stampOf = () => {
+        try {
+            const st = fs.statSync(registry);
+            return `${st.size}:${st.mtimeMs}`;
+        }
+        catch {
+            return '';
+        }
+    };
+    const before = stampOf();
+    await new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(deadline);
+            clearInterval(poll);
+            options.signal.removeEventListener('abort', finish);
+            resolve();
+        };
+        const deadline = setTimeout(finish, delayMs);
+        const poll = setInterval(() => { if (stampOf() !== before)
+            finish(); }, Math.min(pollMs, Math.max(delayMs, 1)));
+        options.signal.addEventListener('abort', finish, { once: true });
+    });
+}
+/**
+ * Hold one peer subscription open for the life of the signal, reconnecting with
+ * backoff. Resolves when the signal aborts or the peer cannot be addressed.
+ */
+export async function streamFromPeer(options) {
+    const parkAfter = options.parkAfterFailures ?? PEER_PARK_AFTER_FAILURES;
+    let failures = 0;
+    while (!options.signal.aborted) {
+        let target;
+        try {
+            target = sshTargetFor(options.device);
+        }
+        catch (error) {
+            // No address at all is not a transient failure: retrying cannot fix it.
+            options.onUnavailable(error instanceof Error ? error.message : String(error));
+            return;
+        }
+        const child = spawn(options.sshBin ?? 'ssh', [
+            ...SSH_OPTS, ...controlOpts(), ...deviceIdentityArgs(options.device), target, options.command,
+        ], { stdio: ['ignore', 'pipe', 'pipe'] });
+        const stop = () => child.kill('SIGTERM');
+        options.signal.addEventListener('abort', stop, { once: true });
+        let stderr = '';
+        child.stderr?.setEncoding('utf-8');
+        child.stderr?.on('data', (chunk) => { stderr = stderrTail(stderr, chunk, PEER_STDERR_BYTES); });
+        const reader = createInterface({ input: child.stdout });
+        reader.on('line', (line) => {
+            // A peer that is delivering protocol is healthy, so the next disconnect
+            // starts the backoff over rather than inheriting an old failure streak.
+            if (options.onLine(line))
+                failures = 0;
+        });
+        const code = await new Promise((resolve) => {
+            child.once('error', () => resolve(null));
+            child.once('close', resolve);
+        });
+        reader.close();
+        // Removed per iteration: a watcher open for hours would otherwise leak one
+        // listener per reconnect onto the caller's signal.
+        options.signal.removeEventListener('abort', stop);
+        if (options.signal.aborted)
+            return;
+        failures += 1;
+        const exit = code == null ? 'ssh failed' : `ssh exited ${code}`;
+        const parked = failures >= parkAfter;
+        const delay = peerBackoffDelayMs(failures, options.backoffBaseMs, options.backoffCapMs);
+        options.onUnavailable(parked
+            ? `${reasonFor(exit, stderr)} — parked after ${failures} failed connections, retrying in ${Math.round(delay / 1000)}s or on a device refresh`
+            : reasonFor(exit, stderr));
+        await parkedWait(options, delay);
+    }
+}

package/dist/lib/session/remote/watch.d.ts

@@ -1,5 +1,5 @@
 import { type ActiveSession } from '../active.js';
-import type { SessionMeta } from '../types.js';
+import { type SessionMeta } from '../types.js';
 import { readActiveSessionsCache } from '../session-cache.js';
 export declare const SESSION_WATCH_VERSION: 1;
 export declare const SESSION_WATCH_HEARTBEAT_MS = 15000;

package/dist/lib/session/remote/watch.js

@@ -1,17 +1,16 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { loadDevices, isDialableDevice } from '../../devices/registry.js';
-import { deviceIdentityArgs, sshTargetFor } from '../../devices/connect.js';
 import { machineId, normalizeHost } from '../../machine-id.js';
-import { SSH_OPTS, controlOpts, shellQuote } from '../../ssh-exec.js';
+import { shellQuote } from '../../ssh-exec.js';
+import { streamFromPeer } from './peer-stream.js';
 import { buildWindowsAgentsCommand, remoteShellFor } from '../../hosts/remote-cmd.js';
 import { isReapableOrphan } from '../active.js';
-import { querySessions, readSessionSummaryAny } from '../db.js';
+import { querySessions, readSessionSummaryAny, readSessionTimelineAny } from '../db.js';
 import { linearIssueUrl } from '../linear.js';
 import { sessionAgentSupportsResume } from '../recovery.js';
+import { SESSION_AGENTS } from '../types.js';
 import { activeSessionsJournalPath, activeSessionJournalIdentity, readActiveSessionsCache, noteActiveSessionsJournalReader, resolveStreamSummaryState, } from '../session-cache.js';
 export const SESSION_WATCH_VERSION = 1;
 export const SESSION_WATCH_HEARTBEAT_MS = 15_000;
@@ -83,6 +82,10 @@ export function toPreviousSessionWatchRow(scope, session) {
             summaryState: session.summaryState,
         }
         : readSessionSummaryAny(session.id);
+    // Project the daemon-folded timeline onto the history row from the same
+    // transcript-keyed cache the live merge reads (PHNX-3939), so a closed session
+    // still shows the request it was given and what the agent did — no re-parse.
+    const folded = readSessionTimelineAny(session.id);
     return {
         context: 'recent',
         kind: session.agent,
@@ -90,7 +93,14 @@ export function toPreviousSessionWatchRow(scope, session) {
         sessionId: session.id,
         ...(session.cwd ? { cwd: session.cwd } : {}),
         ...(session.project ? { project: session.project } : {}),
-        ...(session.label ? { label: session.label, title: session.label } : session.topic ? { title: session.topic } : {}),
+        // `request.headline` is the user's own sentence with the attachment noise
+        // pulled out, so it beats the raw `topic` for the row title — a `/model` echo
+        // or a skill body can no longer become a session's name (PHNX-3939).
+        ...(session.label
+            ? { label: session.label, title: session.label }
+            : folded?.request?.headline
+                ? { title: folded.request.headline }
+                : session.topic ? { title: session.topic } : {}),
         ...(session.topic ? { topic: session.topic } : {}),
         ...(session.firstUserMessage ? { firstUserMessage: session.firstUserMessage } : {}),
         ...(session.version ? { version: session.version } : {}),
@@ -108,6 +118,9 @@ export function toPreviousSessionWatchRow(scope, session) {
         ...(summary?.checkpoints ? { checkpoints: summary.checkpoints } : {}),
         ...(summary?.summaryChecklist ? { summaryChecklist: summary.summaryChecklist } : {}),
         summaryState: resolveStreamSummaryState(summary?.summaryState),
+        ...(folded?.request ? { request: folded.request } : {}),
+        ...(folded?.timeline ? { timeline: folded.timeline } : {}),
+        ...(folded?.files ? { files: folded.files } : {}),
         startedAtMs,
         lastActivityMs,
         status: 'closed',
@@ -285,7 +298,12 @@ export function readPreviousSessionsForWatch(scope) {
     try {
         return querySessions({
             machine: normalizeHost(scope),
-            agents: ['claude', 'codex', 'muse', 'opencode'],
+            // Every harness that writes a discoverable transcript. The list used to be
+            // four, so a Kimi/Grok/Cursor/Droid session simply never appeared as a
+            // Previous row — and after PHNX-3939 it would also have been the only rows
+            // with no request/timeline. Kept explicit (not `SESSION_AGENTS`) so
+            // `openclaw`, which has no transcript to project, stays out.
+            agents: SESSION_AGENTS.filter((agent) => agent !== 'openclaw'),
             sinceMs: Date.now() - 7 * 24 * 60 * 60 * 1000,
             excludeTeamOrigin: true,
         })
@@ -406,47 +424,28 @@ export async function watchFleetSessions(options) {
     const peers = Object.values(devices).filter((device) => isDialableDevice(device)
         && normalizeHost(device.name) !== self
         && ['windows', 'linux', 'macos'].includes(device.platform));
-    const reconnectMs = options.reconnectMs ?? 2_000;
     const peerTasks = peers.map(async (device) => {
         const scope = normalizeHost(device.name);
         const state = new SessionWatchState();
-        while (!options.signal.aborted) {
-            let target;
-            try {
-                target = sshTargetFor(device);
-            }
-            catch (error) {
-                options.emit(state.scope(scope, 'unavailable', error instanceof Error ? error.message : String(error)));
-                break;
-            }
-            const child = spawn('ssh', [
-                ...SSH_OPTS, ...controlOpts(), ...deviceIdentityArgs(device), target, remoteWatchCommand(device.platform),
-            ], { stdio: ['ignore', 'pipe', 'ignore'] });
-            const stop = () => child.kill('SIGTERM');
-            options.signal.addEventListener('abort', stop, { once: true });
-            const reader = createInterface({ input: child.stdout });
-            reader.on('line', (line) => {
+        await streamFromPeer({
+            device,
+            signal: options.signal,
+            command: remoteWatchCommand(device.platform),
+            backoffBaseMs: options.reconnectMs,
+            onLine: (line) => {
                 try {
                     const event = JSON.parse(line);
-                    if (event.version === SESSION_WATCH_VERSION && typeof event.sequence === 'number')
-                        options.emit(event);
+                    if (event.version !== SESSION_WATCH_VERSION || typeof event.sequence !== 'number')
+                        return false;
+                    options.emit(event);
+                    return true;
                 }
-                catch { /* incomplete/non-protocol peer output is not state */ }
-            });
-            const code = await new Promise((resolve) => {
-                child.once('error', () => resolve(null));
-                child.once('close', resolve);
-            });
-            reader.close();
-            options.signal.removeEventListener('abort', stop);
-            if (options.signal.aborted)
-                break;
-            options.emit(state.scope(scope, 'unavailable', code === null ? 'ssh failed' : `ssh exited ${code}`));
-            await new Promise((resolve) => {
-                const timer = setTimeout(resolve, reconnectMs);
-                options.signal.addEventListener('abort', () => { clearTimeout(timer); resolve(); }, { once: true });
-            });
-        }
+                catch {
+                    return false; /* incomplete/non-protocol peer output is not state */
+                }
+            },
+            onUnavailable: (reason) => options.emit(state.scope(scope, 'unavailable', reason)),
+        });
     });
     await Promise.all([local, ...peerTasks]);
 }

package/dist/lib/session/session-cache.d.ts

@@ -190,6 +190,15 @@ export declare function mergeSessionSummary(s: ActiveSession): ActiveSession;
  * the readiness flag is read on the read path, and it is memoized (PHNX-3939).
  */
 export declare function resolveStreamSummaryState(current: import('./types.js').SummaryState | undefined, nowMs?: number): import('./types.js').SummaryState;
+/**
+ * Merge the daemon-folded timeline (PHNX-3939) onto a live row from the
+ * transcript-keyed `session_timelines` cache. Sibling of
+ * {@link mergeSessionSummary} and the same contract: one indexed by-id read of
+ * the BOUNDED projection (never the fold's resume state), never a parse, never
+ * a model call. `runTimelinePass` in the daemon tick is the only producer.
+ * Best-effort — a DB error leaves the row untouched.
+ */
+export declare function mergeSessionTimeline(s: ActiveSession): ActiveSession;
 export declare function applyImmutableMemo(s: ActiveSession): ActiveSession;
 export interface LoadLocalActiveSessionsOptions {
     /** Skip the cache and re-gather (the force-refresh path). */