@phnx-labs/agents-cli 1.22.112 → 1.22.114

package/dist/lib/session/projection.js

@@ -0,0 +1,101 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { normalizeHost } from '../machine-id.js';
+/** Device observations are not sessions: a launcher may observe a peer's run.
+ * Keep those observations separately and publish execution-owned state once. */
+export class SessionProjection {
+    observations = new Map();
+    projected = new Map();
+    selected = new Map();
+    sequence = 0;
+    streamId = randomUUID();
+    /** Only the selected observation may publish execution-owned attention. */
+    rowForObservation(scope, rowKey) {
+        const key = this.selected.get(`${normalizeHost(scope)}\0${rowKey}`);
+        return key ? this.projected.get(key) : undefined;
+    }
+    apply(event) {
+        const scope = normalizeHost(event.scope);
+        if (event.type === 'reset')
+            this.observations.set(scope, new Map(event.rows.map(row => [row.rowKey, row])));
+        if (event.type === 'upsert') {
+            if (!this.observations.has(scope))
+                this.observations.set(scope, new Map());
+            this.observations.get(scope).set(event.rowKey, event.row);
+        }
+        if (event.type === 'remove')
+            this.observations.get(scope)?.delete(event.rowKey);
+        const stamp = () => ({ version: 1, streamId: this.streamId, sequence: ++this.sequence, capturedAt: event.capturedAt });
+        if (event.type === 'scope' || event.type === 'heartbeat') {
+            // An unavailable owner retains its last observation until its next reset.
+            return [{ ...event, ...stamp(), scope }];
+        }
+        // A launch exists before a non-Claude harness mints its session id. Join an
+        // id-less placeholder only through an exact, unambiguous durable launch id.
+        const launchSessions = new Map();
+        for (const [observer, rows] of this.observations)
+            for (const row of rows.values()) {
+                if (!row.launchId || !row.sessionId)
+                    continue;
+                const owner = normalizeHost(row.machine || row.sourceDevice || observer);
+                const launch = `${owner}\0${row.kind}\0${row.launchId}`;
+                const ids = launchSessions.get(launch) ?? new Set();
+                ids.add(row.sessionId);
+                launchSessions.set(launch, ids);
+            }
+        const groups = new Map();
+        for (const [observer, rows] of this.observations)
+            for (const row of rows.values()) {
+                const owner = normalizeHost(row.machine || row.sourceDevice || observer);
+                const launchIds = row.launchId ? launchSessions.get(`${owner}\0${row.kind}\0${row.launchId}`) : undefined;
+                const sessionId = row.sessionId || (launchIds?.size === 1 ? [...launchIds][0] : undefined);
+                const identity = sessionId ? `${row.kind}\0${sessionId}` : `${observer}\0${row.rowKey}`;
+                const key = createHash('sha256').update(`${owner}\0${identity}`).digest('base64url').slice(0, 22);
+                const group = groups.get(key) ?? [];
+                group.push({ scope: observer, row });
+                groups.set(key, group);
+            }
+        const next = new Map();
+        const selected = new Map();
+        for (const [rowKey, observations] of groups) {
+            const owner = normalizeHost(observations[0].row.machine || observations[0].row.sourceDevice || observations[0].scope);
+            const authoritative = observations.filter(item => item.scope === owner);
+            // Once the owner has answered, its absence is authoritative too. A stale
+            // launcher/history mirror cannot resurrect a removed execution.
+            const candidates = authoritative.length ? authoritative : this.observations.has(owner) ? [] : observations;
+            candidates.sort((a, b) => Number(a.row.previous) - Number(b.row.previous)
+                || (b.row.lastActivityMs ?? b.row.startedAtMs ?? 0) - (a.row.lastActivityMs ?? a.row.startedAtMs ?? 0)
+                || a.row.rowKey.localeCompare(b.row.rowKey));
+            const candidate = candidates[0];
+            const chosen = candidate?.row;
+            if (!chosen)
+                continue;
+            selected.set(`${candidate.scope}\0${chosen.rowKey}`, rowKey);
+            const observerTerminals = observations.filter(item => !item.row.previous && (item.row.terminalId || item.row.viewingIn || item.row.provenance?.reply))
+                .map(({ scope: device, row }) => ({ device, terminalId: row.terminalId, launchId: row.launchId, viewingIn: row.viewingIn, provenance: row.provenance }))
+                .sort((a, b) => a.device.localeCompare(b.device) || (a.terminalId ?? '').localeCompare(b.terminalId ?? ''));
+            next.set(rowKey, {
+                ...chosen, rowKey, sourceDevice: owner, machine: owner,
+                observerTerminals,
+                recovery: chosen.resumable && chosen.sessionId
+                    ? { command: 'agents', args: ['sessions', 'resume', chosen.sessionId, '--device', owner], ...(chosen.cwd ? { cwd: chosen.cwd } : {}) }
+                    : null,
+            });
+        }
+        const result = [];
+        // A reset still replaces only its source scope. Cross-scope migrations are
+        // explicit removes/upserts, so existing clients converge without a new API.
+        if (event.type === 'reset')
+            result.push({ ...stamp(), type: 'reset', scope, rows: [...next.values()].filter(row => row.sourceDevice === scope) });
+        for (const [key, row] of this.projected)
+            if (!next.has(key) && !(event.type === 'reset' && row.sourceDevice === scope)) {
+                result.push({ ...stamp(), type: 'remove', scope: row.sourceDevice, rowKey: key });
+            }
+        for (const [key, row] of next)
+            if (!(event.type === 'reset' && row.sourceDevice === scope) && JSON.stringify(this.projected.get(key)) !== JSON.stringify(row)) {
+                result.push({ ...stamp(), type: 'upsert', scope: row.sourceDevice, rowKey: key, row });
+            }
+        this.projected = next;
+        this.selected = selected;
+        return result;
+    }
+}

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

@@ -66,7 +66,7 @@ export declare function cleanSessionPrompt(raw: string): string;
  * path, a pasted shell line, or a skill's install directory.
  */
 export type UserPromptKind = 'text' | 'image' | 'command' | 'skill';
-export interface ClassifiedPrompt {
+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
@@ -132,7 +132,7 @@ export declare function extractSessionTopic(raw: string): string | undefined;
  * dropped in, or an `@path` directory reference. `name` is the basename (or the
  * `@ref` verbatim) — the sidebar renders these as chips beside the request text.
  */
-export interface RequestAttachmentRef {
+interface RequestAttachmentRef {
     kind: 'image' | 'file' | 'dir';
     name: string;
 }
@@ -194,3 +194,4 @@ export declare function firstSentence(text: string, cap?: number): string;
 export declare function tidyRequest(raw: string | undefined, opts?: {
     attachments?: SessionAttachment[];
 }, depth?: number): TidyRequest | undefined;
+export {};

package/dist/lib/session/prompt.js

@@ -193,7 +193,7 @@ export function cleanSessionPrompt(raw) {
     let text = stripTeamWrappers(raw).replace(/\r/g, '').trim();
     if (!text)
         return '';
-    text = text.replace(/<\/?[a-z_][a-z0-9_-]*>/gi, '');
+    text = stripXmlLikeTags(text);
     const meaningful = text
         .split('\n')
         .map(line => line.trim())
@@ -201,6 +201,43 @@ export function cleanSessionPrompt(raw) {
         .filter(line => !NOISE_LINE_PATTERNS.some(pattern => pattern.test(line)));
     return meaningful.join('\n').trim();
 }
+/**
+ * Remove XML-like tags in one pass, including nested fragments such as
+ * `<scr<b>ipt>`. A candidate starts only with a valid tag-name prefix, so
+ * ordinary comparisons such as `1 < 2 > 0` remain prose.
+ */
+function stripXmlLikeTags(text) {
+    const chunks = [];
+    let plainStart = 0;
+    let tagStart = -1;
+    let depth = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (depth === 0) {
+            if (char !== '<')
+                continue;
+            const firstNameIndex = text[index + 1] === '/' ? index + 2 : index + 1;
+            if (!/[a-z_]/i.test(text[firstNameIndex] ?? ''))
+                continue;
+            chunks.push(text.slice(plainStart, index));
+            tagStart = index;
+            depth = 1;
+            continue;
+        }
+        if (char === '<') {
+            depth += 1;
+        }
+        else if (char === '>' && --depth === 0) {
+            plainStart = index + 1;
+            tagStart = -1;
+        }
+    }
+    if (tagStart !== -1)
+        chunks.push(text.slice(tagStart));
+    else
+        chunks.push(text.slice(plainStart));
+    return chunks.join('');
+}
 /**
  * A skill invocation injects a system line naming the skill's install directory:
  *   "Base directory for this skill: /home/.../skills/<name>"

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,12 @@ 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;
 /**
  * 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 {
+interface PeerStreamOptions {
     /** The device to subscribe to. */
     device: DeviceProfile;
     /** Remote command to run over ssh, already shell-quoted for the peer's OS. */
@@ -45,3 +41,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

@@ -35,9 +35,9 @@ 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;
+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}.

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;
@@ -49,6 +47,14 @@ export type SessionWatchEnvelope = {
 };
 export interface SessionWatchRow extends Omit<ActiveSession, 'viewingIn' | 'context'> {
     context: ActiveSession['context'] | 'recent';
+    /** Observer-local terminal/reply facts; never overwrite execution-owner state. */
+    observerTerminals?: {
+        device: string;
+        terminalId?: string;
+        launchId?: string;
+        viewingIn: string | null;
+        provenance?: ActiveSession['provenance'];
+    }[];
     /** Flat durable branch for history rows that are not currently in a worktree. */
     branch?: string;
     rowKey: string;
@@ -68,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;
@@ -111,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;
@@ -122,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

@@ -1,3 +1,4 @@
+import { SessionProjection } from '../projection.js';
 import { createHash, randomUUID } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -12,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);
@@ -57,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);
 }
 /**
@@ -421,7 +422,10 @@ function remoteWatchCommand(os) {
  * peer resets only its own scope. There is no recurring fleet list command.
  */
 export async function watchFleetSessions(options) {
-    const local = watchLocalSessions({ scope: machineId(), signal: options.signal, emit: options.emit });
+    const projection = new SessionProjection();
+    const emit = (event) => { for (const projected of projection.apply(event))
+        options.emit(projected); };
+    const local = watchLocalSessions({ scope: machineId(), signal: options.signal, emit });
     let devices;
     try {
         devices = await loadDevices();
@@ -447,14 +451,14 @@ export async function watchFleetSessions(options) {
                     const event = JSON.parse(line);
                     if (event.version !== SESSION_WATCH_VERSION || typeof event.sequence !== 'number')
                         return false;
-                    options.emit(event);
+                    emit(event);
                     return true;
                 }
                 catch {
                     return false; /* incomplete/non-protocol peer output is not state */
                 }
             },
-            onUnavailable: (reason) => options.emit(state.scope(scope, 'unavailable', reason)),
+            onUnavailable: (reason) => emit(state.scope(scope, 'unavailable', reason)),
         });
     });
     await Promise.all([local, ...peerTasks]);

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 {};