@phnx-labs/agents-cli 1.22.113 → 1.22.115

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

@@ -10,7 +10,7 @@ export interface RecoveryAccount {
     label: string;
     email: string | null;
 }
-export interface SessionRecoverySelection {
+interface SessionRecoverySelection {
     /** Installed binary only; account homes retain their own context label. */
     executableVersion?: string;
     /** Explicit account selector resolved against the local candidate pool. */
@@ -38,7 +38,7 @@ export type SessionRecoveryTarget = {
     account?: RecoveryAccount;
     reason: string;
 };
-export type NativeResumeInspection = {
+type NativeResumeInspection = {
     available: true;
     cwd?: string;
 } | {
@@ -92,3 +92,4 @@ export declare function resolveSessionRecovery(session: SessionMeta, collect?: (
  * the recovery resolver above; callers must not native-resume another version's
  * isolated home themselves. */
 export declare function sessionRecoveryRunArgs(session: Pick<SessionMeta, 'id'>): string[];
+export {};

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

@@ -5,16 +5,30 @@ export declare const PEER_BACKOFF_BASE_MS = 2000;
 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;
+/**
+ * Consecutive failed spawns before the peer is RETIRED — the capped 60 s ladder
+ * gives way to {@link PEER_RETIRED_RECHECK_MS}.
+ *
+ * The cap alone bounds the delay but not the total work: a box that is off for a
+ * weekend was dialed every 60 s for two days, ~2,880 ssh children per watcher
+ * per peer, each one already known to fail. Ten consecutive failures is well
+ * past any transient network event, so past that point the peer is treated as
+ * genuinely absent and re-dialed on the slow cadence instead.
+ */
+export declare const PEER_RETIRE_AFTER_FAILURES = 10;
+/**
+ * Re-dial cadence for a retired peer. Still bounded rather than never, because a
+ * box can come back without anything touching the device registry — waiting
+ * only on a registry change would leave it unreachable until an operator acted.
+ */
+export declare const PEER_RETIRED_RECHECK_MS: number;
 /**
  * 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}.
+ * peer, then {@link PEER_BACKOFF_BASE_MS} doubling to {@link PEER_BACKOFF_CAP_MS},
+ * and {@link PEER_RETIRED_RECHECK_MS} once the peer is retired.
  */
-export declare function peerBackoffDelayMs(failures: number, base?: number, cap?: number): number;
-export interface PeerStreamOptions {
+export declare function peerBackoffDelayMs(failures: number, base?: number, cap?: number, retireAfter?: number, retiredMs?: number): number;
+interface PeerStreamOptions {
     /** The device to subscribe to. */
     device: DeviceProfile;
     /** Remote command to run over ssh, already shell-quoted for the peer's OS. */
@@ -33,6 +47,10 @@ export interface PeerStreamOptions {
     backoffCapMs?: number;
     /** Override the park threshold (tests). */
     parkAfterFailures?: number;
+    /** Override the retire threshold (tests). */
+    retireAfterFailures?: number;
+    /** Override the retired re-dial cadence (tests). */
+    retiredRecheckMs?: number;
     /** Override the ssh binary (tests). */
     sshBin?: string;
     /** Override the parked peer's registry re-check cadence (tests). */
@@ -45,3 +63,4 @@ export interface PeerStreamOptions {
  * backoff. Resolves when the signal aborts or the peer cannot be addressed.
  */
 export declare function streamFromPeer(options: PeerStreamOptions): Promise<void>;
+export {};

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

@@ -19,6 +19,9 @@
  * - 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;
+ * - a peer that fails {@link PEER_RETIRE_AFTER_FAILURES} in a row RETIRED — the
+ *   capped 60 s ladder is itself unbounded in total work, so past that point the
+ *   re-dial drops to {@link PEER_RETIRED_RECHECK_MS};
  * - abort listeners removed per iteration, so a watcher open for hours does not
  *   accumulate one per reconnect on the caller's AbortSignal.
  */
@@ -34,17 +37,37 @@ export const PEER_BACKOFF_BASE_MS = 2_000;
 export const PEER_BACKOFF_CAP_MS = 60_000;
 /** Consecutive failed spawns before the peer is parked. */
 export const PEER_PARK_AFTER_FAILURES = 3;
+/**
+ * Consecutive failed spawns before the peer is RETIRED — the capped 60 s ladder
+ * gives way to {@link PEER_RETIRED_RECHECK_MS}.
+ *
+ * The cap alone bounds the delay but not the total work: a box that is off for a
+ * weekend was dialed every 60 s for two days, ~2,880 ssh children per watcher
+ * per peer, each one already known to fail. Ten consecutive failures is well
+ * past any transient network event, so past that point the peer is treated as
+ * genuinely absent and re-dialed on the slow cadence instead.
+ */
+export const PEER_RETIRE_AFTER_FAILURES = 10;
+/**
+ * Re-dial cadence for a retired peer. Still bounded rather than never, because a
+ * box can come back without anything touching the device registry — waiting
+ * only on a registry change would leave it unreachable until an operator acted.
+ */
+export const PEER_RETIRED_RECHECK_MS = 15 * 60_000;
 /** Bytes of a peer's stderr retained for the `unavailable` reason. */
-export const PEER_STDERR_BYTES = 2_048;
+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;
+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}.
+ * peer, then {@link PEER_BACKOFF_BASE_MS} doubling to {@link PEER_BACKOFF_CAP_MS},
+ * and {@link PEER_RETIRED_RECHECK_MS} once the peer is retired.
  */
-export function peerBackoffDelayMs(failures, base = PEER_BACKOFF_BASE_MS, cap = PEER_BACKOFF_CAP_MS) {
+export function peerBackoffDelayMs(failures, base = PEER_BACKOFF_BASE_MS, cap = PEER_BACKOFF_CAP_MS, retireAfter = PEER_RETIRE_AFTER_FAILURES, retiredMs = PEER_RETIRED_RECHECK_MS) {
     if (failures <= 0)
         return 0;
+    if (failures >= retireAfter)
+        return retiredMs;
     return Math.min(cap, base * 2 ** (failures - 1));
 }
 /** Bounded tail of a child's stderr, kept for the unavailable reason. */
@@ -133,10 +156,14 @@ export async function streamFromPeer(options) {
         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));
+        const retireAfter = options.retireAfterFailures ?? PEER_RETIRE_AFTER_FAILURES;
+        const retired = failures >= retireAfter;
+        const delay = peerBackoffDelayMs(failures, options.backoffBaseMs, options.backoffCapMs, retireAfter, options.retiredRecheckMs);
+        options.onUnavailable(retired
+            ? `${reasonFor(exit, stderr)} — retired after ${failures} failed connections, re-dialing in ${Math.round(delay / 60_000)}min or on a device refresh`
+            : 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/remote-bundle.d.ts

@@ -1,5 +1,5 @@
 import { type ParsedBundle } from '../bundle.js';
-export interface RemotePullResult {
+interface RemotePullResult {
     bundles: ParsedBundle[];
     errors: string[];
 }
@@ -10,3 +10,4 @@ export interface RemotePullResult {
  * `exportArgs` must NOT contain --device (the remote export runs for itself only).
  */
 export declare function pullBundlesFromHosts(hosts: string[], exportArgs: string[]): Promise<RemotePullResult>;
+export {};

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

@@ -4,7 +4,7 @@ import type { SessionMeta } from '../types.js';
 import { type ToolProgramCountEnvelope, type ToolSearchEnvelope } from '../tool-index.js';
 export { REMOTE_STDOUT_MAX_BYTES, RemoteUtf8Accumulator } from '../../ssh-exec.js';
 export declare const REMOTE_TOOL_AGGREGATE_MAX_BYTES: number;
-export interface RemoteToolByteBudget {
+interface RemoteToolByteBudget {
     remainingBytes: number;
     exhausted: boolean;
 }
@@ -44,7 +44,7 @@ export declare function sshCapture(target: string, remoteCmd: string, timeoutMs:
     stdout: string;
     aggregateBudgetExceeded?: boolean;
 }>;
-export interface RemoteListResult {
+interface RemoteListResult {
     sessions: SessionMeta[];
     /** How many peer machines we attempted to reach (drives the empty-fleet tip). */
     deviceCount: number;
@@ -65,7 +65,7 @@ export declare function isAutomaticSessionPeer(d: DeviceProfile, self: string):
  * address. `forwardedArgs` are the caller's own sessions args (query + filters,
  * already `--json`) so every peer returns the same slice this machine asked for.
  */
-export interface GatherRemoteListOptions {
+interface GatherRemoteListOptions {
     /**
      * Opt-in early-exit for a globally-unique id lookup (a full UUID): the first
      * peer to return the matching row resolves the fan-out and cancels the rest.
@@ -77,7 +77,7 @@ export interface GatherRemoteListOptions {
     timeoutMs?: number;
 }
 export declare function gatherRemoteList(forwardedArgs: string[], hosts?: string[], opts?: GatherRemoteListOptions): Promise<RemoteListResult>;
-export interface RemoteToolSearchResult {
+interface RemoteToolSearchResult {
     envelopes: Array<{
         machine: string;
         envelope: ToolSearchEnvelope;
@@ -86,7 +86,7 @@ export interface RemoteToolSearchResult {
     unreachable: string[];
     truncated: string[];
 }
-export interface RemoteToolProgramCountResult {
+interface RemoteToolProgramCountResult {
     envelopes: Array<{
         machine: string;
         envelope: ToolProgramCountEnvelope;

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

@@ -42,7 +42,7 @@ export declare function ensureWholeIndex(forwardedArgs: string[]): string[];
  */
 export declare function buildRemoteCommand(forwardedArgs: string[], columns?: number, os?: string): string;
 /** The four outcomes of one `ssh <host> agents sessions …` invocation. */
-export type SshOutcome = 'ok' | 'unreachable' | 'query-failed' | 'spawn-error';
+type SshOutcome = 'ok' | 'unreachable' | 'query-failed' | 'spawn-error';
 /**
  * Classify an ssh `spawnSync` result. ssh(1) reserves exit 255 for its own
  * connection-layer failures (host down, timeout, refused, auth, changed host
@@ -71,7 +71,7 @@ export declare function remoteCachePath(host: string, forwardedArgs: string[]):
  * skips SSH only while this returns true; unreachable fallback ignores age.
  */
 export declare function isRemoteCacheFresh(mtimeMs: number, nowMs: number, maxAgeMs?: number): boolean;
-export interface RemoteCacheHit {
+interface RemoteCacheHit {
     output: string;
     mtimeMs: number;
 }
@@ -105,7 +105,7 @@ export declare function serveWarmRemoteCache(host: string, forwardedArgs: string
  * stderr (so a piped stdout stays exactly the cached rows); returns false when
  * nothing is cached for this exact (host, query). */
 export declare function replayRemoteCache(host: string, forwardedArgs: string[]): boolean;
-export interface RunRemoteSessionsOptions {
+interface RunRemoteSessionsOptions {
     /** Skip warm cache and SSH every host (force-refresh). */
     forceRefresh?: boolean;
     /** Override freshness window for the warm path. */
@@ -130,3 +130,4 @@ export interface RunRemoteSessionsOptions {
  * imperceptible; `maxBuffer` is generous for the rare large `--markdown <id>` dump.
  */
 export declare function runRemoteSessions(hosts: string[], argv?: string[], opts?: RunRemoteSessionsOptions): void;
+export {};

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

@@ -1,9 +1,7 @@
 import { type ActiveSession } from '../active.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;
-export declare const SESSION_WATCH_PREVIOUS_LIMIT = 50;
 export type SessionWatchScopeStatus = 'available' | 'unavailable';
 export type SessionWatchEnvelope = {
     version: 1;
@@ -76,10 +74,6 @@ export interface SessionWatchRow extends Omit<ActiveSession, 'viewingIn' | 'cont
 /** Stable, opaque identity for one row within one device scope. */
 export declare function sessionWatchRowKey(scope: string, row: ActiveSession): string;
 export declare function toSessionWatchRow(scope: string, row: ActiveSession): SessionWatchRow;
-/** Stable identity for a durable Previous row. It is deliberately distinct
- * from the live row key for the same session id: both may coexist on the one
- * stream, and the presentation layer lets the live row win while it exists. */
-export declare function previousSessionWatchRowKey(scope: string, sessionId: string): string;
 /** Project one durable indexed session into the same canonical watch contract
  * as live sessions. This is the only history backfill consumed by AGI EXT. */
 export declare function toPreviousSessionWatchRow(scope: string, session: SessionMeta): SessionWatchRow;
@@ -119,7 +113,7 @@ export declare function readPreviousSessionsForWatch(scope: string): SessionMeta
  * steady state tails the canonical writer journal and never invokes a gather.
  */
 export declare function watchLocalSessions(options: WatchLocalOptions): Promise<void>;
-export interface WatchFleetOptions {
+interface WatchFleetOptions {
     signal: AbortSignal;
     emit: (event: SessionWatchEnvelope) => void;
     reconnectMs?: number;
@@ -130,3 +124,4 @@ export interface WatchFleetOptions {
  * peer resets only its own scope. There is no recurring fleet list command.
  */
 export declare function watchFleetSessions(options: WatchFleetOptions): Promise<void>;
+export {};

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

@@ -13,9 +13,9 @@ 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;
+const SESSION_WATCH_VERSION = 1;
 export const SESSION_WATCH_HEARTBEAT_MS = 15_000;
-export const SESSION_WATCH_PREVIOUS_LIMIT = 50;
+const SESSION_WATCH_PREVIOUS_LIMIT = 50;
 /** Stable, opaque identity for one row within one device scope. */
 export function sessionWatchRowKey(scope, row) {
     const identity = activeSessionJournalIdentity(row);
@@ -58,7 +58,7 @@ function epochMs(value) {
 /** Stable identity for a durable Previous row. It is deliberately distinct
  * from the live row key for the same session id: both may coexist on the one
  * stream, and the presentation layer lets the live row win while it exists. */
-export function previousSessionWatchRowKey(scope, sessionId) {
+function previousSessionWatchRowKey(scope, sessionId) {
     return createHash('sha256').update(`${scope}\0previous\0${sessionId}`).digest('base64url').slice(0, 22);
 }
 /**

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

@@ -15,7 +15,7 @@ export declare const NO_FANOUT_ENV = "AGENTS_SESSIONS_LOCAL";
  * Exported for unit testing without a live tailnet.
  */
 export declare function parseRemoteActive(stdout: string, machine: string): ActiveSession[];
-export interface RemoteActiveResult {
+interface RemoteActiveResult {
     sessions: ActiveSession[];
     /** How many peer machines we attempted to reach (drives the empty-fleet tip). */
     deviceCount: number;
@@ -48,3 +48,4 @@ export declare function gatherRemoteActive(hosts?: string[], opts?: {
         isDefinitive: (item: ActiveSession, machine: string) => boolean;
     };
 }): Promise<RemoteActiveResult>;
+export {};

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

@@ -82,7 +82,7 @@ export declare function renderSummaryHeader(stats: SessionStats): string;
  */
 export declare function renderSummary(events: SessionEvent[], cwd?: string): string;
 /** Allowed values for --include/--exclude role filters. */
-export declare const VALID_ROLE_VALUES: readonly ["user", "assistant", "thinking", "tools"];
+declare const VALID_ROLE_VALUES: readonly ["user", "assistant", "thinking", "tools"];
 /** A single role filter value derived from VALID_ROLE_VALUES. */
 export type RoleFilter = typeof VALID_ROLE_VALUES[number];
 /** Options for filtering session events by role and turn range. */
@@ -108,7 +108,7 @@ export declare function filterEvents(events: SessionEvent[], opts: FilterOptions
  * order so reasoning sits where it actually occurred relative to the assistant
  * reply.
  */
-export interface RenderConversationMarkdownOptions {
+interface RenderConversationMarkdownOptions {
     redact?: boolean;
     knownSecrets?: readonly string[];
     reasoning?: 'omit' | 'fold' | 'include';

package/dist/lib/session/render.js

@@ -809,7 +809,7 @@ export function renderSummary(events, cwd) {
 }
 // ── Event filters ─────────────────────────────────────────────────────────────
 /** Allowed values for --include/--exclude role filters. */
-export const VALID_ROLE_VALUES = ['user', 'assistant', 'thinking', 'tools'];
+const VALID_ROLE_VALUES = ['user', 'assistant', 'thinking', 'tools'];
 /**
  * Parse a comma-separated role list (e.g. "user,assistant") into typed values.
  * Throws with a clear message listing valid values on any unknown entry.

package/dist/lib/session/resume-owner.d.ts

@@ -20,7 +20,7 @@
  * remote session resumed in whatever directory the user happened to be in.
  *
  * Callers act on the answer differently, and the difference is deliberate:
- * `agents sessions resume` and `agents sessions attach` HOP to the owner over SSH, while
+ * `agents sessions resume` HOPS to the owner over SSH, while
  * `resumeSessionInPlace` — the local takeover every routed caller reaches only
  * after deciding — REFUSES. The batch `sessions resume` needs no check of its
  * own: each of its tabs runs the canonical `agents sessions resume <id>`

package/dist/lib/session/resume-owner.js

@@ -20,7 +20,7 @@
  * remote session resumed in whatever directory the user happened to be in.
  *
  * Callers act on the answer differently, and the difference is deliberate:
- * `agents sessions resume` and `agents sessions attach` HOP to the owner over SSH, while
+ * `agents sessions resume` HOPS to the owner over SSH, while
  * `resumeSessionInPlace` — the local takeover every routed caller reaches only
  * after deciding — REFUSES. The batch `sessions resume` needs no check of its
  * own: each of its tabs runs the canonical `agents sessions resume <id>`

package/dist/lib/session/run-names.d.ts

@@ -13,7 +13,7 @@
  * Mirrors the host-task sidecar convention (`~/.agents/.cache/hosts/<id>.json`),
  * one small JSON per run under `~/.agents/.cache/run-names/`.
  */
-export interface RunNameRecord {
+interface RunNameRecord {
     sessionId: string;
     name: string;
     agent: string;
@@ -32,3 +32,4 @@ export declare function recordRunName(rec: Omit<RunNameRecord, 'ts'>): void;
  * map when the dir doesn't exist yet.
  */
 export declare function buildRunNameMap(): Map<string, string | null>;
+export {};

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

@@ -8,7 +8,7 @@ import { type ActiveSession } from './active.js';
 export declare const DEFAULT_ACTIVE_CACHE_MAX_AGE_MS = 15000;
 /** Snapshot scope: this host only, or a fleet-wide merge written by a reader. */
 export type ActiveCacheScope = 'local' | 'fleet';
-export interface ActiveSessionsSnapshot {
+interface ActiveSessionsSnapshot {
     version: 1;
     scope: ActiveCacheScope;
     /** Epoch ms the sessions array was captured. */
@@ -30,7 +30,7 @@ export declare function activeSessionJournalIdentity(row: ActiveSession): string
  * transcript mtime so a rewrite invalidates them. Live status is intentionally
  * absent — see {@link LIVE_STATUS_KEYS}.
  */
-export interface ImmutableSessionFields {
+interface ImmutableSessionFields {
     topic?: string;
     firstUserMessage?: string;
     label?: string;
@@ -76,8 +76,6 @@ export declare function setActiveSessionsSnapshotPathForTest(p: string | null):
 export declare function clearActiveSnapshotMemoryForTest(): void;
 /** Test seam: redirect the immutable-memo file. Returns the previous override. */
 export declare function setImmutableMemoPathForTest(p: string | null): string | null;
-/** Test seam: redirect the append-only live-state journal. */
-export declare function setActiveSessionsJournalPathForTest(p: string | null): string | null;
 /** Test seam: redirect the reader-presence file. Returns the previous override. */
 export declare function setActiveSessionsReaderPresencePathForTest(p: string | null): string | null;
 export declare function activeSessionsJournalPath(): string;
@@ -99,8 +97,6 @@ export declare function noteActiveSessionsJournalReader(nowMs?: number): void;
  * {@link noteActiveSessionsJournalReader} and the following tick gathers.
  */
 export declare function isActiveSessionsJournalReaderRecent(nowMs?: number, idleWindowMs?: number): boolean;
-/** Default poll cadence for {@link watchActiveSessionsReaderPresence}. */
-export declare const ACTIVE_SESSIONS_READER_TRANSITION_POLL_MS = 1000;
 /**
  * Watch for a reader going from absent/idle to present and fire `onConnect`
  * out of band, instead of waiting for the next scheduled warm tick (RUSH-2484).
@@ -166,22 +162,6 @@ export declare function assertNoLiveStatusFields(fields: Record<string, unknown>
  * refill identity fields without re-deriving them.
  */
 export declare function updateImmutableMemos(sessions: ReadonlyArray<ActiveSession>, nowMs?: number): void;
-/**
- * Fill missing immutable fields on a live row from the memo when the transcript
- * mtime matches. Never overwrites a field the live gather already set, and
- * never copies live-status keys.
- */
-/**
- * Merge the daemon-computed session summary (PHNX-3939) onto a live row from the
- * transcript-keyed `session_summaries` cache. This is the low-cost display merge:
- * one indexed by-id read, NEVER a model call — the background
- * SessionSummarizerService is the only producer. It fills only what the cache
- * holds; the `pending`/`skipped` default for a row with no summary yet is applied
- * at the watch-stream boundary ({@link resolveStreamSummaryState}), so a
- * non-stream ActiveSession consumer is unaffected. Best-effort: a DB error leaves
- * the row untouched.
- */
-export declare function mergeSessionSummary(s: ActiveSession): ActiveSession;
 /**
  * The `summaryState` a watch-stream row carries when the merge left it unset:
  * `pending` while the summarizer is READY (enabled AND has an endpoint, so a
@@ -200,7 +180,7 @@ export declare function resolveStreamSummaryState(current: import('./types.js').
  */
 export declare function mergeSessionTimeline(s: ActiveSession): ActiveSession;
 export declare function applyImmutableMemo(s: ActiveSession): ActiveSession;
-export interface LoadLocalActiveSessionsOptions {
+interface LoadLocalActiveSessionsOptions {
     /** Skip the cache and re-gather (the force-refresh path). */
     forceRefresh?: boolean;
     /** Freshness window; defaults to {@link DEFAULT_ACTIVE_CACHE_MAX_AGE_MS}. */
@@ -216,7 +196,7 @@ export interface LoadLocalActiveSessionsOptions {
     readCache?: typeof readActiveSessionsCache;
     writeCache?: typeof writeActiveSessionsCache;
 }
-export interface LoadLocalActiveSessionsResult {
+interface LoadLocalActiveSessionsResult {
     sessions: ActiveSession[];
     /** True when the row set came from the warm snapshot, not a live gather. */
     servedFromCache: boolean;
@@ -228,7 +208,7 @@ export interface LoadLocalActiveSessionsResult {
  * re-gathers and rewrites the cache.
  */
 export declare function loadLocalActiveSessions(opts?: LoadLocalActiveSessionsOptions): Promise<LoadLocalActiveSessionsResult>;
-export interface LoadFleetActiveSessionsOptions {
+interface LoadFleetActiveSessionsOptions {
     forceRefresh?: boolean;
     maxAgeMs?: number;
     nowMs?: number;
@@ -244,7 +224,7 @@ export interface LoadFleetActiveSessionsOptions {
     readCache?: typeof readActiveSessionsCache;
     writeCache?: typeof writeActiveSessionsCache;
 }
-export interface LoadFleetActiveSessionsResult {
+interface LoadFleetActiveSessionsResult {
     sessions: ActiveSession[];
     remoteDeviceCount: number;
     servedFromCache: boolean;
@@ -275,3 +255,4 @@ export declare function publishLocalActiveSessions(opts?: {
     sessions: ActiveSession[];
     capturedAt: number;
 }>;
+export {};

package/dist/lib/session/session-cache.js

@@ -131,12 +131,6 @@ export function setImmutableMemoPathForTest(p) {
     immutablePathOverride = p;
     return prev;
 }
-/** Test seam: redirect the append-only live-state journal. */
-export function setActiveSessionsJournalPathForTest(p) {
-    const prev = journalPathOverride;
-    journalPathOverride = p;
-    return prev;
-}
 /** Test seam: redirect the reader-presence file. Returns the previous override. */
 export function setActiveSessionsReaderPresencePathForTest(p) {
     const prev = readerPresencePathOverride;
@@ -194,7 +188,7 @@ export function isActiveSessionsJournalReaderRecent(nowMs = Date.now(), idleWind
     }
 }
 /** Default poll cadence for {@link watchActiveSessionsReaderPresence}. */
-export const ACTIVE_SESSIONS_READER_TRANSITION_POLL_MS = 1_000;
+const ACTIVE_SESSIONS_READER_TRANSITION_POLL_MS = 1_000;
 /**
  * Watch for a reader going from absent/idle to present and fire `onConnect`
  * out of band, instead of waiting for the next scheduled warm tick (RUSH-2484).
@@ -439,7 +433,7 @@ export function updateImmutableMemos(sessions, nowMs = Date.now()) {
  * non-stream ActiveSession consumer is unaffected. Best-effort: a DB error leaves
  * the row untouched.
  */
-export function mergeSessionSummary(s) {
+function mergeSessionSummary(s) {
     if (!s.sessionId)
         return s;
     try {

package/dist/lib/session/share-html.d.ts

@@ -1,5 +1,5 @@
 import type { SessionMeta } from './types.js';
-export interface SessionHtmlOptions {
+interface SessionHtmlOptions {
     /** Whether the Markdown was rendered with redaction on — shown in the footer. */
     redacted?: boolean;
 }
@@ -9,26 +9,6 @@ interface Chip {
     value: string;
 }
 export declare function escapeHtml(text: string): string;
-/**
- * Lift every folded reasoning block out of the Markdown, leaving a sentinel.
- *
- * `renderer.html` escapes raw HTML unconditionally — the transcript body is model
- * and tool output, so nothing in it may round-trip as markup. That also escaped
- * the `<details>` wrapper `--reasoning fold` emits, which is why the disclosure
- * element has to be reconstructed here instead of allowlisted through.
- *
- * Allowlisting was tried twice and is the wrong shape: marked hands the same
- * markup over as several different raw strings depending on context (a whole-token
- * gate passed the opening tag and escaped the closing one in a real document), and
- * a bare `<details>` in ordinary prose is a complete INLINE html token — so prose
- * that merely mentions the tag would emit a live, unclosed element that swallows
- * every later turn into it. Reconstructing both ends here makes the pairing
- * structural: it cannot be unbalanced by anything the transcript contains.
- */
-export declare function liftFoldBlocks(markdown: string): {
-    text: string;
-    blocks: string[];
-};
 /** Human duration — "13 minutes", never "12m 49s". */
 export declare function formatDuration(ms: number): string;
 /**

package/dist/lib/session/share-html.js

@@ -75,7 +75,7 @@ const FOLD_BLOCK = /<details>\n<summary>Reasoning<\/summary>\n\n([\s\S]*?)\n\n<\
  * every later turn into it. Reconstructing both ends here makes the pairing
  * structural: it cannot be unbalanced by anything the transcript contains.
  */
-export function liftFoldBlocks(markdown) {
+function liftFoldBlocks(markdown) {
     const blocks = [];
     // A transcript that literally contains the sentinel must not be able to forge a
     // disclosure element, so break any occurrence before inserting our own.

package/dist/lib/session/shell-programs.d.ts

@@ -1,5 +1,5 @@
 import { type Word } from 'unbash';
-export interface ShellProgramExtraction {
+interface ShellProgramExtraction {
     programs: string[];
     occurrences: ShellProgramOccurrence[];
     diagnostics: string[];
@@ -30,3 +30,4 @@ export declare function isShellExecTool(tool: string | undefined): boolean;
 export declare function staticShellWord(word: Word | undefined): string | undefined;
 /** Parse Bash without executing it and return every statically identifiable program. */
 export declare function extractShellPrograms(source: string, depth?: number): ShellProgramExtraction;
+export {};

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

@@ -49,9 +49,22 @@ export interface QuestionOption {
  * {@link AwaitingReason}; `options` is present when the agent offered discrete choices.
  */
 export interface StructuredQuestion {
+    /**
+     * The question itself — the trailing ask, not the whole message. For a prose
+     * question this is the extracted trailing question block (see
+     * {@link extractProseQuestion}); for a structured harness question it is the
+     * agent-supplied question text, unchanged.
+     */
     text: string;
     reason: AwaitingReason;
     options?: QuestionOption[];
+    /**
+     * Optional preceding prose for a prose question — the report/explanation that
+     * came BEFORE the trailing ask, with its Markdown and newlines preserved so a
+     * consumer can render it as context under the question. Absent for a structured
+     * harness question and when a prose question carries no preceding context.
+     */
+    context?: string;
 }
 export interface DetectedPr {
     url: string;
@@ -139,7 +152,7 @@ export interface SessionState {
     /** Displayable files/screenshots attached to the session prompt. */
     attachments?: SessionAttachment[];
 }
-export interface StateContext {
+interface StateContext {
     /** Session file mtime; drives running-vs-stale. */
     mtimeMs?: number;
     cwd?: string;
@@ -196,13 +209,6 @@ export declare function isTicketCreateTool(name?: string, command?: string): boo
  * take `#<number>`. Returns undefined when neither shape is present.
  */
 export declare function extractCreatedTicket(text?: string): string | undefined;
-/**
- * Pull the plan markdown out of an `ExitPlanMode` tool_use event's args. The
- * Claude tool schema is `{ plan: string }`; the transcript parser already
- * lifts `input` onto `event.args`. Returns undefined for a missing/empty plan
- * so consumers can rely on `plan?: string` truthiness.
- */
-export declare function extractPlanText(args?: Record<string, any>): string | undefined;
 /**
  * Structured question from a Claude `AskUserQuestion` tool call. Its input is
  * `{ questions: [{ question, header, options: [{label, description}] }] }` and the
@@ -212,6 +218,33 @@ export declare function extractPlanText(args?: Record<string, any>): string | un
  * 1-based selection digit as `key`.
  */
 export declare function structuredQuestionFromAsk(args?: Record<string, any>): StructuredQuestion | undefined;
+/** The separated question the CLI shows: the trailing ask + optional preceding context. */
+export interface ProseQuestion {
+    /** The trailing ask, with its original Markdown and line breaks. */
+    text: string;
+    /** The preceding report/explanation, Markdown + newlines preserved; absent when none. */
+    context?: string;
+}
+/**
+ * Split a run of prose into its trailing QUESTION and the CONTEXT before it,
+ * instead of flattening a whole report into one line (the old `oneLine(content)`
+ * that copied a merged report and lost its Markdown). Returns undefined when the
+ * text has no real trailing ask.
+ *
+ * Rules, each pinned by a test:
+ *   - The ask must be TRAILING: the last eligible non-empty line is the question,
+ *     or the search stops (a report line after the question means it isn't the ask).
+ *   - A `?` that lives ONLY inside a fenced code block, an inline `code` span, or a
+ *     `>` blockquote does NOT count — those lines are ineligible to end the ask
+ *     (they still ride along in `context`).
+ *   - Multiple/multiline related asks are kept together (a contiguous run of
+ *     question / list-item / `:`-lead-in lines), never dropped.
+ *   - When the ask shares ONE line with preceding prose, the leading non-question
+ *     sentences peel into `context` and only the trailing question sentence(s) stay
+ *     in `text`.
+ *   - Both fields preserve newlines and Markdown.
+ */
+export declare function extractProseQuestion(raw: string): ProseQuestion | undefined;
 /**
  * Infer live activity + a preview from a chronological event slice. `pr` /
  * `ticket` / `worktree` are attached by `inferSessionState`; this focuses on the