@phnx-labs/agents-cli 1.22.46 → 1.22.49

package/dist/lib/session/discover.js

@@ -26,8 +26,8 @@ import { getConfigSymlinkVersion } from '../installations/shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
 import { buildClaudeAccountIndex, resolveClaudeAccount } from './claude-accounts.js';
-import { extractSessionTopic, extractSlashCommandName, extractSlashCommandFromToolInput } from './prompt.js';
-import { isSkillInvocation, extractSkills, extractSlashCommands } from './highlights.js';
+import { extractSessionTopic, extractSlashCommandName, extractSlashCommandFromToolInput, classifyUserPrompt } from './prompt.js';
+import { isBackgroundShellStart, isSkillInvocation, extractSkills, extractSlashCommands, isSubAgentTool } from './highlights.js';
 import { parseAntigravity, parseCursor, splitSessionFilePath } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { costOfUsage, costOfUsageNoCache } from '../pricing/index.js';
@@ -1215,7 +1215,9 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             accountKey: acct.key,
             accountOrg: acct.orgName ?? undefined,
             topic: scan.topic,
-            label,
+            // The live sessions metadata file contains only user `/rename` values;
+            // prefer it when present, then fall back to the title parsed from JSONL.
+            label: label || scan.label,
             messageCount: scan.messageCount,
             toolCallCount: scan.toolCallCount,
             tokenCount: scan.tokenCount,
@@ -1237,6 +1239,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             todos: scan.todos,
             recentDirectoriesTouched: scan.recentDirectoriesTouched,
             skillsUsed: scan.skillsUsed,
+            subAgentCount: scan.subAgentCount,
+            backgroundShellCount: scan.backgroundShellCount,
             slashCommandsUsed: scan.slashCommandsUsed,
         };
     }
@@ -1253,7 +1257,9 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             accountKey: acct.key,
             accountOrg: acct.orgName ?? undefined,
             model: scan.model,
-            label,
+            // Keep parsed ai-title/custom-title values even when the transcript has
+            // no timestamp and therefore takes this stat-backed fallback path.
+            label: label || scan.label,
             messageCount: scan.messageCount,
             toolCallCount: scan.toolCallCount,
             tokenCount: scan.tokenCount,
@@ -1276,6 +1282,8 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             todos: scan.todos,
             recentDirectoriesTouched: scan.recentDirectoriesTouched,
             skillsUsed: scan.skillsUsed,
+            subAgentCount: scan.subAgentCount,
+            backgroundShellCount: scan.backgroundShellCount,
             slashCommandsUsed: scan.slashCommandsUsed,
         };
     }
@@ -2992,6 +3000,8 @@ function extractDroidMessageText(content) {
 /** Zero-value accumulator for a fresh (from-byte-0) Claude parse. */
 export function initClaudeParseState() {
     return {
+        subAgents: 0,
+        backgroundShells: 0,
         timestamp: undefined,
         cwd: undefined,
         gitBranch: undefined,
@@ -3040,6 +3050,14 @@ function foldDerivedToolState(state, event) {
     // from a full re-parse (see session/db.ts's writeResourceUsage doc comment).
     if (isSkillInvocation(event))
         state.skillEvents.push(event);
+    // Fan-out tallies (RUSH-3091/3095): counted, not held — we need the number,
+    // and a heavy orchestrator session can spawn hundreds of each.
+    if (state.subAgents !== undefined && isSubAgentTool(event.tool ?? '', event.command ?? '')) {
+        state.subAgents += 1;
+    }
+    if (state.backgroundShells !== undefined && isBackgroundShellStart(event)) {
+        state.backgroundShells += 1;
+    }
     if (event.tool === 'SlashCommand') {
         const slashCommand = extractSlashCommandFromToolInput(event.args);
         if (slashCommand)
@@ -3247,9 +3265,18 @@ export function finalizeClaudeScan(state) {
     const durationMs = state.firstTsMs !== undefined && state.lastTsMs !== undefined && state.lastTsMs > state.firstTsMs
         ? state.lastTsMs - state.firstTsMs
         : undefined;
-    // Prefer an explicit session title (user `/rename` > Claude auto-title) over
-    // the first-prompt topic.
-    const resolvedTopic = state.customTitle || state.aiTitle || state.topic;
+    // A topic is the first meaningful prompt. Harness-owned names travel in the
+    // separate label field so consumers can replace an early topic once Claude's
+    // generated title (or a later `/rename`) arrives.
+    // Claude's generated `ai-title` is derived from the first turn, so a session
+    // opened with a skill gets named after the injected "Base directory for this
+    // skill: …" line instead of its task — and that name then wins on every
+    // surface for the session's whole life. `classifyUserPrompt` reports `skill`
+    // only for that injected line, so collapse it to `/<skill>`. A `/rename`
+    // (`custom-title`) is the user's own words and is never rewritten.
+    const generated = classifyUserPrompt(state.aiTitle ?? '');
+    const label = state.customTitle
+        || (generated.kind === 'skill' ? generated.clean : state.aiTitle);
     const worktree = detectWorktree(state.cwd, state.gitBranch);
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
@@ -3258,7 +3285,8 @@ export function finalizeClaudeScan(state) {
         gitBranch: state.gitBranch,
         version: state.version,
         model: state.model,
-        topic: resolvedTopic,
+        topic: state.topic,
+        label,
         entrypoint: state.entrypoint,
         messageCount: state.messageCount,
         toolCallCount: state.toolCallCount,
@@ -3283,6 +3311,8 @@ export function finalizeClaudeScan(state) {
         recentDirectoriesTouched: state.recentDirectoriesTouched.length ? state.recentDirectoriesTouched : undefined,
         skillsUsed: state.skillEvents.length ? extractSkills(state.skillEvents) : undefined,
         slashCommandsUsed: state.slashCommandEvents.length ? extractSlashCommands(state.slashCommandEvents) : undefined,
+        subAgentCount: state.subAgents,
+        backgroundShellCount: state.backgroundShells,
     };
 }
 /** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
@@ -3324,7 +3354,9 @@ export function serializeClaudeParserState(state, offset, jsonlDroppingOversized
         : allIds;
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
-        v: 3,
+        v: 4,
+        subAgents: state.subAgents,
+        backgroundShells: state.backgroundShells,
         offset,
         jsonlDroppingOversizedLine: jsonlDroppingOversizedLine || undefined,
         timestamp: state.timestamp,
@@ -3396,6 +3428,8 @@ export function hydrateClaudeParseState(prior) {
         seen.add(`pad:${pad++}`);
     }
     return {
+        subAgents: prior.subAgents,
+        backgroundShells: prior.backgroundShells,
         timestamp: prior.timestamp,
         cwd: prior.cwd,
         gitBranch: prior.gitBranch,
@@ -3563,7 +3597,7 @@ function parsePriorClaudeState(row) {
         return null;
     try {
         const parsed = JSON.parse(row.parserState);
-        if (parsed?.v !== 3 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
+        if (parsed?.v !== 4 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
             return null;
         return parsed;
     }

package/dist/lib/session/highlights.d.ts

@@ -10,7 +10,7 @@
  * bounded `.git` walk over a handful of candidate dirs) and is the only
  * non-pure function here.
  */
-import type { SessionEvent } from './types.js';
+import type { SessionAgentId, SessionEvent } from './types.js';
 import { type FileChange } from './digest.js';
 export interface SkillUse {
     name: string;
@@ -100,3 +100,51 @@ export declare function extractArtifacts(changes: FileChange[]): ProducedArtifac
  * happens to run in, which is a wrong answer, not a degraded one.
  */
 export declare function extractRepos(events: SessionEvent[], cwd?: string): string[];
+/**
+ * True when this harness records backgrounded shells at all. Callers MUST gate
+ * on this before rendering a count: for a harness that cannot report it, "0" is
+ * a lie ("none running") where the truth is "unknown", so the segment is omitted
+ * entirely — the same way the Hooks line renders for Claude only.
+ */
+export declare function harnessTracksBackgroundShells(agent: SessionAgentId): boolean;
+/**
+ * True for a tool_use event that starts a background shell. Exported for the
+ * same reason {@link isSkillInvocation} is: the incremental parser can select
+ * matching events while streaming instead of re-reading the transcript.
+ */
+export declare function isBackgroundShellStart(e: SessionEvent): boolean;
+export interface BackgroundShell {
+    /** The command line as invoked, trimmed for display. */
+    command: string;
+    timestamp: string;
+}
+/**
+ * Shells the session started in the background, oldest first.
+ *
+ * This is "started", NOT "still running". A transcript records the start and
+ * never the death, and inferring liveness from its absence is the same trap
+ * `agents devices ps` documents — a killed process leaves no marker, so a naive
+ * reader reports "running" forever. Live status belongs to `sessions --active`,
+ * which resolves real pids.
+ */
+export declare function extractBackgroundShells(events: SessionEvent[]): BackgroundShell[];
+/**
+ * True for a tool call that spawns another agent. Deliberately counts BOTH
+ * shapes, because both are fan-out the operator needs to see:
+ *
+ *   in-process   an `Agent` / `Task` tool call inside this transcript
+ *   shelled-out  a Bash command that invokes `agents run`, `agents cloud run`,
+ *                or `agents teams add|start`
+ *
+ * Moved here from `commands/sessions-picker.ts` so BOTH preview body paths (the
+ * digest body and `formatMetaOnlyBody`) share one definition instead of
+ * drifting apart. Semantics are unchanged: session f045b577 counts 23
+ * in-process + 30 shelled-out = 53.
+ *
+ * The full summary's `Subagents (N)` section (`render.ts`) deliberately does NOT
+ * use this. It builds a described ROSTER, so it needs `args.description` /
+ * `args.prompt` and is necessarily limited to in-process `Agent`/`Task` calls —
+ * a shelled-out `agents run` carries no such description. Different question,
+ * different answer; do not "unify" them.
+ */
+export declare function isSubAgentTool(tool: string, command: string): boolean;

package/dist/lib/session/highlights.js

@@ -294,3 +294,98 @@ export function extractRepos(events, cwd) {
     }
     return repos;
 }
+// ── Background shells ─────────────────────────────────────────────────────────
+/**
+ * Per-harness shape of "start this shell command in the background", keyed the
+ * same way {@link SKILL_TOOL_NAME_BY_AGENT} is: one table entry per harness that
+ * has the capability, so adding a harness is a row and never another `else if`.
+ *
+ * An absent entry means "this harness cannot report it", which the renders must
+ * show as ABSENCE, never as a count of zero. Every absence below was probed
+ * against that harness's real transcripts on this fleet rather than assumed:
+ *
+ *   codex        0 of 176 session files carry any background marker; its `exec` /
+ *                `exec_command` record only `cmd` + `workdir`, no shell handle.
+ *   droid        0 of 126 session files.
+ *   antigravity  0 of 54 session files.
+ *   opencode     0 of 79 session files.
+ *   cursor       stores no tool calls locally at all — only `meta.json` and
+ *                `prompt_history.json`; the calls live server-side.
+ *
+ * Not probed, because no version home is installed on this fleet to probe:
+ * `muse`, `rush`, `hermes`, `openclaw`, `gemini`. They are absent for lack of
+ * evidence, NOT on a verified negative — add a row once one is confirmed, and
+ * until then absence renders as "unknown", which is the safe direction.
+ */
+const BACKGROUND_SHELL_BY_AGENT = {
+    claude: { tool: 'Bash', flag: 'run_in_background' },
+    kimi: { tool: 'Bash', flag: 'run_in_background' },
+    grok: { tool: 'run_terminal_command', flag: 'background' },
+};
+/**
+ * True when this harness records backgrounded shells at all. Callers MUST gate
+ * on this before rendering a count: for a harness that cannot report it, "0" is
+ * a lie ("none running") where the truth is "unknown", so the segment is omitted
+ * entirely — the same way the Hooks line renders for Claude only.
+ */
+export function harnessTracksBackgroundShells(agent) {
+    return BACKGROUND_SHELL_BY_AGENT[agent] !== undefined;
+}
+/**
+ * True for a tool_use event that starts a background shell. Exported for the
+ * same reason {@link isSkillInvocation} is: the incremental parser can select
+ * matching events while streaming instead of re-reading the transcript.
+ */
+export function isBackgroundShellStart(e) {
+    if (e.type !== 'tool_use' || e._local)
+        return false;
+    const spec = BACKGROUND_SHELL_BY_AGENT[e.agent];
+    return !!spec && e.tool === spec.tool && e.args?.[spec.flag] === true;
+}
+/**
+ * Shells the session started in the background, oldest first.
+ *
+ * This is "started", NOT "still running". A transcript records the start and
+ * never the death, and inferring liveness from its absence is the same trap
+ * `agents devices ps` documents — a killed process leaves no marker, so a naive
+ * reader reports "running" forever. Live status belongs to `sessions --active`,
+ * which resolves real pids.
+ */
+export function extractBackgroundShells(events) {
+    const out = [];
+    for (const e of events) {
+        if (!isBackgroundShellStart(e))
+            continue;
+        const raw = e.command ?? e.args?.command;
+        out.push({
+            command: typeof raw === 'string' ? raw.trim() : '',
+            timestamp: e.timestamp,
+        });
+    }
+    return out;
+}
+// ── Sub-agents ────────────────────────────────────────────────────────────────
+/**
+ * True for a tool call that spawns another agent. Deliberately counts BOTH
+ * shapes, because both are fan-out the operator needs to see:
+ *
+ *   in-process   an `Agent` / `Task` tool call inside this transcript
+ *   shelled-out  a Bash command that invokes `agents run`, `agents cloud run`,
+ *                or `agents teams add|start`
+ *
+ * Moved here from `commands/sessions-picker.ts` so BOTH preview body paths (the
+ * digest body and `formatMetaOnlyBody`) share one definition instead of
+ * drifting apart. Semantics are unchanged: session f045b577 counts 23
+ * in-process + 30 shelled-out = 53.
+ *
+ * The full summary's `Subagents (N)` section (`render.ts`) deliberately does NOT
+ * use this. It builds a described ROSTER, so it needs `args.description` /
+ * `args.prompt` and is necessarily limited to in-process `Agent`/`Task` calls —
+ * a shelled-out `agents run` carries no such description. Different question,
+ * different answer; do not "unify" them.
+ */
+export function isSubAgentTool(tool, command) {
+    if (/^(Agent|Task)$/i.test(tool))
+        return true;
+    return /\b(?:agents|ag)\b[^\n;&|]*\b(?:run|cloud\s+run|teams\s+(?:add|start))\b/.test(command);
+}

package/dist/lib/session/host-link.d.ts

@@ -25,12 +25,26 @@
  */
 /** How a session is connected to the client that should be driving it. */
 export type HostLink = 
-/** A client is attached, or nothing indicates otherwise. The normal case. */
+/** A client is attached — positively established, not assumed. */
 'connected'
 /** Alive, but nothing is viewing it — the host window is gone and the agent outlived it. */
  | 'no-client'
 /** The host window is gone AND the agent process died with it — an unclean exit. */
- | 'host-gone';
+ | 'host-gone'
+/**
+ * Alive, and we have NO usable signal either way — no window owns it and it is
+ * not tmux-hosted, so neither input this function keys on exists.
+ *
+ * This case used to return `connected`, which reads as "verified fine" when the
+ * truth is "nobody looked". That is the wrong default for a detector: the rows
+ * it silently blesses are precisely the ones with no observer — a bare terminal,
+ * a team spawn, a cloud task, or any session whose pane lives on another
+ * machine (this function's inputs are all local, so a `--device` session is
+ * structurally unobservable from the launching box).
+ *
+ * Callers MUST NOT render this as healthy. It means the question is open.
+ */
+ | 'unknown';
 /**
  * How long an IDE window's registry slice may go without a refresh before we
  * treat that window as gone. AGI EXT force-republishes its slice

package/dist/lib/session/host-link.js

@@ -60,5 +60,11 @@ export function classifyHostLink(input) {
     // that owned it is gone. The agent outlived its editor.
     if (windowGone)
         return 'no-client';
-    return 'connected';
+    // Positive evidence of a client: tmux counted at least one attached client, or
+    // a window is refreshing its registry slice. Either is a real observation.
+    if (input.tmuxClients !== undefined || input.windowHeartbeatMs !== undefined)
+        return 'connected';
+    // Neither input exists, so nothing here observed anything. Say so rather than
+    // reporting the healthy answer by default — see {@link HostLink}'s `unknown`.
+    return 'unknown';
 }

package/dist/lib/session/parse.js

@@ -11,7 +11,7 @@ import { sanitizeForTerminal } from '../redact.js';
 import * as path from 'path';
 import Database from '../sqlite.js';
 import { isSyntheticUserMessage, extractSlashCommandName, extractSlashCommandFromToolInput } from './prompt.js';
-import { structuredToolResult } from './tool-calls.js';
+import { structuredToolResult, commandsFromCodexExec } from './tool-calls.js';
 /**
  * Largest session file we will load into memory. Above this we throw a clean
  * error instead of OOMing or hitting V8's ERR_STRING_TOO_LONG. Aligns with
@@ -270,6 +270,15 @@ export function summarizeToolUse(tool, args) {
         // Codex tools
         case 'exec_command':
             return `Bash: ${truncate(String(args.command || args.cmd || '').replace(/\n/g, ' ').trim(), 120)}`;
+        // Newer Codex JS-cell shell wrapper: prefer the unwrapped command (set at parse
+        // time), else the extracted command, else the raw cell code.
+        case 'exec': {
+            const cmd = args.command || codexExecCommand(String(args.input || ''));
+            if (cmd)
+                return `Bash: ${truncate(String(cmd).replace(/\n/g, ' ').trim(), 120)}`;
+            const code = String(args.input || '').replace(/\n/g, ' ').trim();
+            return code ? `exec: ${truncate(code, 100)}` : 'exec';
+        }
         case 'read_file':
             return `Read ${shortenPath(args.file_path || args.path || '')}`;
         case 'write_file':
@@ -573,6 +582,23 @@ export function applyPatchTargetPaths(input) {
 function applyPatchTargetPath(input) {
     return applyPatchTargetPaths(input)[0];
 }
+/**
+ * Newer Codex (gpt-5.6-sol / codex >=~0.145) runs every shell command inside a JS
+ * cell: a `custom_tool_call` named `exec` whose `input` is code like
+ * `const r = await tools.exec_command({cmd:"git status", "workdir":"…"});`. The real
+ * shell command(s) are buried in those `cmd:"…"` literals. Reuse the canonical
+ * acorn-based extractor (`commandsFromCodexExec` in `tool-calls.ts`, already used by
+ * the tool-call index): it walks the whole AST — so a cell that runs several via
+ * `Promise.all([tools.exec_command(...), tools.exec_command(...)])` yields every
+ * command, not just the first — and matches only real `tools.exec_command` calls,
+ * so a `cmd:"…"` string mentioned in a comment or docstring is never mistaken for an
+ * invocation. Returns `undefined` for a non-shell cell (`tools.view_image(...)`, a
+ * raw JS computation) so it stays labeled by its code, not faked into a shell step.
+ */
+function codexExecCommand(input) {
+    const commands = commandsFromCodexExec(input);
+    return commands.length > 0 ? commands.join('\n') : undefined;
+}
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized
  * events. Split from `parseCodex` so the tail reader can parse just the last
@@ -706,6 +732,9 @@ export function parseCodexContent(content) {
                 const rawName = payload.name || 'unknown';
                 const input = typeof payload.input === 'string' ? payload.input : '';
                 const isApplyPatch = rawName === 'apply_patch';
+                // Newer Codex wraps shell in a JS `exec` cell — unwrap the real command so
+                // the step reads by its program instead of a bare "exec" (see extractor).
+                const execCommand = rawName === 'exec' ? codexExecCommand(input) : undefined;
                 // Multi-file patches: one tool_use per file so artifact discovery sees
                 // every path (RUSH-1410). Single-file / non-patch keep one event.
                 const patchPaths = isApplyPatch ? applyPatchTargetPaths(input) : [];
@@ -715,6 +744,8 @@ export function parseCodexContent(content) {
                     const args = { input: truncatedInput };
                     if (patchPath)
                         args.file_path = patchPath;
+                    if (execCommand)
+                        args.command = execCommand;
                     const callId = payload.call_id || payload.id;
                     if (callId)
                         callMap.set(callId, { name: tool, args });
@@ -725,6 +756,7 @@ export function parseCodexContent(content) {
                         tool,
                         callId,
                         args,
+                        command: execCommand,
                         path: patchPath,
                     });
                 };

package/dist/lib/session/prompt.d.ts

@@ -34,5 +34,40 @@ export declare function extractSlashCommandFromToolInput(toolInput: Record<strin
 export declare const HEADLESS_PLAN_MODE_PREFIX = "You are running in HEADLESS PLAN MODE.";
 /** Strip framework noise from a raw session prompt, returning only meaningful user text. */
 export declare function cleanSessionPrompt(raw: string): string;
+/**
+ * How a session's first user turn reads once its framework noise is stripped —
+ * so a UI row can show `[image]` / `$ cmd` / `/skill` instead of a screenshot
+ * path, a pasted shell line, or a skill's install directory.
+ */
+export type UserPromptKind = 'text' | 'image' | 'command' | 'skill';
+export interface ClassifiedPrompt {
+    /**
+     * The one-line, display-ready form of the prompt — never a bare path. NOT
+     * length-capped: the recap card shows it in full; row consumers cap it
+     * themselves (`deriveSessionRecap`).
+     */
+    clean: string;
+    kind: UserPromptKind;
+}
+/**
+ * Classify a raw first user turn into a display-ready `{ clean, kind }`, so a
+ * Fleet/session row shows the user's actual intent rather than path noise:
+ *
+ *   - `skill`   — a `/skill` invocation's injected "Base directory for this
+ *                 skill: …" line collapses to `/<name>`.
+ *   - `command` — a `$ `-prefixed shell paste keeps only the first command.
+ *   - `image`   — a screenshot/image path standing alone, or an image
+ *                 attachment with no real accompanying text, becomes `[image]`.
+ *   - `text`    — everything else: wrapper tags stripped (via
+ *                 {@link cleanSessionPrompt}) and any inline image path replaced
+ *                 with `[image]` so a mixed prompt still drops the path.
+ *
+ * Pure and cross-harness (text markers, no per-agent branch). `hasImageAttachment`
+ * lets a caller that only has an already-extracted topic line still detect an
+ * image-only turn from the row's attachment list.
+ */
+export declare function classifyUserPrompt(raw: string | undefined, opts?: {
+    hasImageAttachment?: boolean;
+}): ClassifiedPrompt;
 /** Extract a one-line topic from a raw user message, or undefined if the message is pure noise. */
 export declare function extractSessionTopic(raw: string): string | undefined;

package/dist/lib/session/prompt.js

@@ -145,6 +145,62 @@ export function cleanSessionPrompt(raw) {
         .filter(line => !NOISE_LINE_PATTERNS.some(pattern => pattern.test(line)));
     return meaningful.join('\n').trim();
 }
+/**
+ * A skill invocation injects a system line naming the skill's install directory:
+ *   "Base directory for this skill: /home/.../skills/<name>"
+ * which collapses to "/<name>" so a row shows the skill, not the path. Anchored
+ * to that exact injected line — a bare `.../skills/<name>` mention in ordinary
+ * prose is NOT a skill invocation and must keep its real text.
+ */
+const SKILL_BASEDIR_RE = /Base directory for this skill:\s*\S*[\/\\]skills[\/\\]([\w.-]+)/i;
+/**
+ * An explicit shell-prompt paste (`$ cmd`). Only the command survives. Deliberately
+ * `$`-only: a leading `>` is a markdown blockquote far more often than a shell
+ * prompt, so matching it misread quoted prose as a command.
+ */
+const COMMAND_PREFIX_RE = /^\$\s+(\S.*)$/;
+/**
+ * A filesystem path (absolute or `~`-rooted) ending in an image extension —
+ * matched even across the spaces a CleanShot filename carries. Used both to
+ * detect an image-only prompt and to drop the path from a mixed one.
+ */
+const IMAGE_PATH_RE = /[\/~][^\n]*?\.(?:png|jpe?g|gif|webp|heic|bmp|svg)\b/i;
+/**
+ * Classify a raw first user turn into a display-ready `{ clean, kind }`, so a
+ * Fleet/session row shows the user's actual intent rather than path noise:
+ *
+ *   - `skill`   — a `/skill` invocation's injected "Base directory for this
+ *                 skill: …" line collapses to `/<name>`.
+ *   - `command` — a `$ `-prefixed shell paste keeps only the first command.
+ *   - `image`   — a screenshot/image path standing alone, or an image
+ *                 attachment with no real accompanying text, becomes `[image]`.
+ *   - `text`    — everything else: wrapper tags stripped (via
+ *                 {@link cleanSessionPrompt}) and any inline image path replaced
+ *                 with `[image]` so a mixed prompt still drops the path.
+ *
+ * Pure and cross-harness (text markers, no per-agent branch). `hasImageAttachment`
+ * lets a caller that only has an already-extracted topic line still detect an
+ * image-only turn from the row's attachment list.
+ */
+export function classifyUserPrompt(raw, opts = {}) {
+    const text = (raw ?? '').replace(/\r/g, '').trim();
+    const skill = text.match(SKILL_BASEDIR_RE);
+    if (skill)
+        return { clean: `/${skill[1]}`, kind: 'skill' };
+    const firstLine = text.split('\n').map(line => line.trim()).find(Boolean) ?? '';
+    const cmd = firstLine.match(COMMAND_PREFIX_RE);
+    if (cmd)
+        return { clean: `$ ${cmd[1]}`.trim(), kind: 'command' };
+    const cleaned = cleanSessionPrompt(text);
+    const cleanedFirst = cleaned.split('\n').map(line => line.trim()).find(Boolean) ?? '';
+    const imgMatch = firstLine.match(IMAGE_PATH_RE);
+    const imageOnly = !!imgMatch && firstLine.replace(imgMatch[0], '').replace(/[^\w]/g, '').length <= 8;
+    if (imageOnly || (opts.hasImageAttachment && !cleanedFirst)) {
+        return { clean: '[image]', kind: 'image' };
+    }
+    const display = (cleanedFirst || firstLine).replace(IMAGE_PATH_RE, '[image]').trim();
+    return { clean: display, kind: 'text' };
+}
 /** Extract a one-line topic from a raw user message, or undefined if the message is pure noise. */
 export function extractSessionTopic(raw) {
     if (!raw.trim())

package/dist/lib/session/remote/remote-list.d.ts

@@ -141,8 +141,17 @@ export declare function fetchPeerPreviewDigest(sessionId: string, machine: strin
  * that would inherit it for its whole life — `agents browser start` inside it
  * would then be refused as a cross-machine drive. A one-shot `--device` command
  * can carry the marker; a session cannot.
+ *
+ * `opts.sessionId` (with `tty`) prints the session id and resume command when
+ * the SSH hop ends, so OpenSSH's `Shared connection … closed.` is not the last
+ * thing on the local shell (RUSH-3227). Omit it for one-shot non-TTY renders.
  */
+export declare function peerHopCloseNotice(opts: {
+    tty?: boolean;
+    sessionId?: string;
+}, machine: string, code: number | null): string | undefined;
 export declare function runOnPeer(args: string[], machine: string, opts?: {
     tty?: boolean;
     env?: Record<string, string>;
+    sessionId?: string;
 }): Promise<'ok' | 'no-target'>;

package/dist/lib/session/remote/remote-list.js

@@ -15,7 +15,8 @@
  */
 import { spawn } from 'child_process';
 import chalk from 'chalk';
-import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote, REMOTE_STDOUT_MAX_BYTES, RemoteUtf8Accumulator, } from '../../ssh-exec.js';
+import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote, SSH_CONN_FAILURE_CODE, REMOTE_STDOUT_MAX_BYTES, RemoteUtf8Accumulator, } from '../../ssh-exec.js';
+import { connectionEndedNotice } from '../../hosts/reconnect.js';
 import { sshTargetFor } from '../../devices/connect.js';
 import { resolveExplicitTargetSet } from '../../devices/resolve-target.js';
 import { loadDevices, isDialableDevice } from '../../devices/registry.js';
@@ -577,7 +578,16 @@ export async function fetchPeerPreviewDigest(sessionId, machine, timeoutMs = PEE
  * that would inherit it for its whole life — `agents browser start` inside it
  * would then be refused as a cross-machine drive. A one-shot `--device` command
  * can carry the marker; a session cannot.
+ *
+ * `opts.sessionId` (with `tty`) prints the session id and resume command when
+ * the SSH hop ends, so OpenSSH's `Shared connection … closed.` is not the last
+ * thing on the local shell (RUSH-3227). Omit it for one-shot non-TTY renders.
  */
+export function peerHopCloseNotice(opts, machine, code) {
+    if (!opts.tty || !opts.sessionId)
+        return undefined;
+    return connectionEndedNotice({ kind: 'session', id: opts.sessionId }, machine, { dropped: code === SSH_CONN_FAILURE_CODE });
+}
 export async function runOnPeer(args, machine, opts = {}) {
     const peer = await resolvePeerTarget(machine);
     if (!peer)
@@ -602,6 +612,13 @@ export async function runOnPeer(args, machine, opts = {}) {
             process.stderr.write(chalk.red(`Failed to reach ${machine}: ${err?.message ?? 'ssh failed to launch'}\n`));
             resolve('ok');
         });
-        child.on('close', () => resolve('ok'));
+        child.on('close', (code) => {
+            // Interactive TTY hop: OpenSSH prints "Shared connection … closed." and
+            // nothing else. Leave the session id on the local shell (RUSH-3227).
+            const notice = peerHopCloseNotice(opts, machine, code);
+            if (notice)
+                process.stderr.write(notice);
+            resolve('ok');
+        });
     });
 }

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

@@ -1,4 +1,4 @@
-import type { ActiveSession } from '../active.js';
+import { type ActiveSession } from '../active.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

@@ -8,7 +8,8 @@ import { deviceIdentityArgs, sshTargetFor } from '../../devices/connect.js';
 import { machineId, normalizeHost } from '../../machine-id.js';
 import { SSH_OPTS, controlOpts, shellQuote } from '../../ssh-exec.js';
 import { buildWindowsAgentsCommand, remoteShellFor } from '../../hosts/remote-cmd.js';
-import { activeSessionsJournalPath, activeSessionJournalIdentity, readActiveSessionsCache, } from '../session-cache.js';
+import { isReapableOrphan } from '../active.js';
+import { activeSessionsJournalPath, activeSessionJournalIdentity, readActiveSessionsCache, noteActiveSessionsJournalReader, } from '../session-cache.js';
 export const SESSION_WATCH_VERSION = 1;
 export const SESSION_WATCH_HEARTBEAT_MS = 15_000;
 /** Stable, opaque identity for one row within one device scope. */
@@ -18,7 +19,11 @@ export function sessionWatchRowKey(scope, row) {
 }
 export function toSessionWatchRow(scope, row) {
     const rowKey = sessionWatchRowKey(scope, row);
-    const resumable = Boolean(row.sessionId);
+    // A dead, days-stale crash-orphan is folded OUT of the reconnectable set — it
+    // is not resumable, so the "Needs reconnecting" list stops ballooning with
+    // leaked --device tunnel sessions (RUSH-3011 / issue #3b). A live or
+    // recently-exited session stays resumable.
+    const resumable = Boolean(row.sessionId) && !isReapableOrphan(row);
     const viewingIn = row.viewingIn
         ? [row.viewingIn.app, row.viewingIn.tab ? `tab ${row.viewingIn.tab}` : undefined].filter(Boolean).join(' ')
         : null;
@@ -111,9 +116,15 @@ export async function watchLocalSessions(options) {
     catch { /* first publication */ }
     const initial = readCache('local');
     options.emit(state.reset(options.scope, initial?.sessions ?? []));
+    // Known gap (out of scope for RUSH-2484): a present cache alone marks
+    // 'available' with no staleness/age check, so a reconnect can briefly render
+    // a stale snapshot as live before the out-of-band gather this file triggers
+    // (see watchActiveSessionsReaderPresence in session-cache.ts) replaces it.
     options.emit(state.scope(options.scope, initial ? 'available' : 'unavailable', initial ? undefined : 'awaiting publisher'));
     if (options.signal.aborted)
         return;
+    // Signal the daemon that a consumer is live so it does not skip the gather.
+    noteActiveSessionsJournalReader();
     await new Promise((resolve) => {
         let partial = '';
         let reading = false;
@@ -162,7 +173,10 @@ export async function watchLocalSessions(options) {
         fs.mkdirSync(path.dirname(journal), { recursive: true });
         const journalListener = () => readAppended();
         fs.watchFile(journal, { interval: options.journalPollMs ?? 250 }, journalListener);
-        const heartbeatTimer = setInterval(() => options.emit(state.heartbeat(options.scope)), heartbeatMs);
+        const heartbeatTimer = setInterval(() => {
+            noteActiveSessionsJournalReader();
+            options.emit(state.heartbeat(options.scope));
+        }, heartbeatMs);
         const stop = () => { fs.unwatchFile(journal, journalListener); clearInterval(heartbeatTimer); resolve(); };
         options.signal.addEventListener('abort', stop, { once: true });
         // Close the offset/read/watch handoff: a publisher may append after the