@phnx-labs/agents-cli 1.22.119 → 1.22.121

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

@@ -1,5 +1,5 @@
 import { type ActiveSession } from '../active.js';
-import { type SessionMeta } from '../types.js';
+import { type SessionMeta } from '@phnx-labs/sessions-cli/reader';
 import { readActiveSessionsCache } from '../session-cache.js';
 export declare const SESSION_WATCH_HEARTBEAT_MS = 15000;
 export type SessionWatchScopeStatus = 'available' | 'unavailable';
@@ -47,7 +47,6 @@ 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;
@@ -55,24 +54,10 @@ export interface SessionWatchRow extends Omit<ActiveSession, 'viewingIn' | 'cont
         viewingIn: string | null;
         provenance?: ActiveSession['provenance'];
     }[];
-    /** Flat durable branch for history rows that are not currently in a worktree. */
     branch?: string;
     rowKey: string;
     sourceDevice: string;
-    /**
-     * The registered project this session's working directory belongs to, or
-     * `null` when the association is not confirmed (PHNX-3999 F08/F09).
-     *
-     * This is what a UI groups by. It is deliberately not `project`: that field is
-     * a bucket KEY derived from the path (the basename of the cwd, so it always
-     * answers something), which is how a loose or unrelated directory became its
-     * own project group. `null` means Uncategorized — the row is still listed, it
-     * just is not filed under a project nobody bound it to. Resolved on the device
-     * that owns the path, since a definition's root is a local path.
-     */
     confirmedProject: string | null;
-    /** Durable index rows are kept on the stream under a distinct identity so a
-     * live row can replace/disappear without erasing its recoverable history. */
     previous: boolean;
     resumable: boolean;
     unwatched: boolean;
@@ -83,21 +68,15 @@ export interface SessionWatchRow extends Omit<ActiveSession, 'viewingIn' | 'cont
         cwd?: string;
     } | null;
 }
-/** 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;
-/** 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, accounts?: import("../../account-registry.js").NativeAccount[]): SessionWatchRow;
-/** Stream-local sequencer and convergent row diff. */
 export declare class SessionWatchState {
     readonly streamId: string;
     private sequence;
     private readonly rows;
     constructor(streamId?: string);
     private base;
-    /** Keep one visible Previous row per session and the newest bounded window.
-     * Returns removed keys so delta callers can converge already-connected clients. */
     private prunePrevious;
     reset(scope: string, sourceRows: ActiveSession[], indexedRows?: SessionMeta[]): SessionWatchEnvelope;
     update(scope: string, sourceRows: ActiveSession[]): SessionWatchEnvelope[];
@@ -116,24 +95,12 @@ export interface WatchLocalOptions {
     journalPath?: string;
     journalPollMs?: number;
 }
-/** One bounded index read when the watch starts. The stream then owns this
- * projection: active rows update through the journal, and removals demote into
- * Previous rows without another transcript/index poll. */
 export declare function readPreviousSessionsForWatch(scope: string): SessionMeta[];
-/**
- * Keep one local subscription alive. Startup reads one canonical reset snapshot;
- * steady state tails the canonical writer journal and never invokes a gather.
- */
 export declare function watchLocalSessions(options: WatchLocalOptions): Promise<void>;
 interface WatchFleetOptions {
     signal: AbortSignal;
     emit: (event: SessionWatchEnvelope) => void;
     reconnectMs?: number;
 }
-/**
- * Subscribe to every dialable compute device with one persistent SSH process.
- * A peer disconnect emits `scope: unavailable` but no removes; reconnecting
- * 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

@@ -12,24 +12,19 @@ import { isReapableOrphan, sessionAccountLabel } from '../active.js';
 import { listNativeAccounts } from '../../account-registry.js';
 import { readMeta } from '../../state.js';
 import { querySessions, readSessionSummaryAny, readSessionTimelineAny } from '../db.js';
-import { linearIssueUrl } from '../linear.js';
+import { linearIssueUrl } from '@phnx-labs/sessions-cli/reader';
 import { sessionAgentSupportsResume } from '../recovery.js';
-import { SESSION_AGENTS } from '../types.js';
+import { SESSION_AGENTS } from '@phnx-labs/sessions-cli/reader';
 import { activeSessionsJournalPath, activeSessionJournalIdentity, readActiveSessionsCache, noteActiveSessionsJournalReader, resolveStreamSummaryState, } from '../session-cache.js';
 const SESSION_WATCH_VERSION = 1;
 export const SESSION_WATCH_HEARTBEAT_MS = 15_000;
 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);
     return createHash('sha256').update(`${scope}\0${identity}`).digest('base64url').slice(0, 22);
 }
 export function toSessionWatchRow(scope, row) {
     const rowKey = sessionWatchRowKey(scope, row);
-    // 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 previous = row.status === 'closed'
         || row.status === 'crashed'
@@ -39,14 +34,7 @@ export function toSessionWatchRow(scope, row) {
         : null;
     return {
         ...row,
-        // The summarizer's per-row state is delivered on the stream: a live row with
-        // no computed summary reads `pending` when the summarizer is on, `skipped`
-        // when it is off (PHNX-3939). goal/checkpoints/summaryChecklist rode `...row`.
         summaryState: resolveStreamSummaryState(row.summaryState),
-        // The CONFIRMED project this work belongs to, or null for Uncategorized
-        // (PHNX-3999 F08/F09). Only a registered project definition counts — a
-        // consumer must never group by a directory basename, which is how unrelated
-        // and unbound directories became their own "projects".
         confirmedProject: confirmedProjectForCwd(row.cwd) ?? null,
         rowKey,
         sourceDevice: scope,
@@ -63,24 +51,12 @@ function epochMs(value) {
     const parsed = value ? Date.parse(value) : Number.NaN;
     return Number.isFinite(parsed) ? parsed : 0;
 }
-/** 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. */
 function previousSessionWatchRowKey(scope, sessionId) {
     return createHash('sha256').update(`${scope}\0previous\0${sessionId}`).digest('base64url').slice(0, 22);
 }
-/**
- * The headline for a durable history row, on the same ladder a live row uses
- * ({@link deriveSessionRecap}): an explicit `/rename` label, then the
- * daemon-generated title (PHNX-3797), then the daemon-folded request headline
- * (`request.headline` — the user's own sentence with attachment noise pulled
- * out, PHNX-3939) when the transcript cache has one, else the raw `topic`.
- */
 function previousRowTitle(session, foldedHeadline) {
     return session.label || session.generatedTitle || foldedHeadline || session.topic || undefined;
 }
-/** 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 function toPreviousSessionWatchRow(scope, session, accounts = listNativeAccounts(readMeta())) {
     const resumable = sessionAgentSupportsResume(session.agent);
     const sourceDevice = normalizeHost(session.machine ?? scope);
@@ -89,10 +65,6 @@ export function toPreviousSessionWatchRow(scope, session, accounts = listNativeA
     const worktree = session.worktreeSlug && session.cwd
         ? { slug: session.worktreeSlug, path: session.cwd, ...(session.gitBranch ? { branch: session.gitBranch } : {}) }
         : undefined;
-    // Project the daemon-computed summary (PHNX-3939) onto the history row from the
-    // transcript-keyed cache — the same store the live merge reads, so a closed or
-    // fleet-mirrored session carries its goal/checkpoints/checklist with no
-    // transcript re-parse and no model call. Prefer a value already on the meta row.
     const summary = session.goal !== undefined || session.summaryState !== undefined
         ? {
             goal: session.goal,
@@ -101,9 +73,6 @@ export function toPreviousSessionWatchRow(scope, session, accounts = listNativeA
             summaryState: session.summaryState,
         }
         : readSessionSummaryAny(session.id);
-    // Project the daemon-folded timeline onto the history row from the same
-    // transcript-keyed cache the live merge reads (PHNX-3939), so a closed session
-    // still shows the request it was given and what the agent did — no re-parse.
     const folded = readSessionTimelineAny(session.id);
     const title = previousRowTitle(session, folded?.request?.headline);
     return {
@@ -112,14 +81,8 @@ export function toPreviousSessionWatchRow(scope, session, accounts = listNativeA
         ...(session.harness ? { harness: session.harness } : {}),
         sessionId: session.id,
         ...(session.cwd ? { cwd: session.cwd } : {}),
-        // `project` stays the historical bucket KEY rows are joined on; the grouping a
-        // person sees comes from the confirmed association (PHNX-3999 F08/F09).
         ...(session.project ? { project: session.project } : {}),
         confirmedProject: confirmedProjectForCwd(session.cwd) ?? null,
-        // Same headline ladder as a live row (`deriveSessionRecap`, PHNX-3797):
-        // `/rename` label → the daemon-generated title → `request.headline` (the
-        // user's own sentence with attachment noise pulled out, PHNX-3939) →
-        // the raw `topic`. See {@link previousRowTitle}.
         ...(session.label ? { label: session.label } : {}),
         ...(session.generatedTitle ? { generatedTitle: session.generatedTitle } : {}),
         ...(title ? { title } : {}),
@@ -144,6 +107,12 @@ export function toPreviousSessionWatchRow(scope, session, accounts = listNativeA
         ...(folded?.request ? { request: folded.request } : {}),
         ...(folded?.timeline ? { timeline: folded.timeline } : {}),
         ...(folded?.files ? { files: folded.files } : {}),
+        ...(folded?.model ? { model: folded.model } : {}),
+        ...(folded?.failures ? { failures: folded.failures } : {}),
+        ...(folded?.activityHistogram ? { activityHistogram: folded.activityHistogram } : {}),
+        ...(folded?.userTurns ? { userTurns: folded.userTurns } : {}),
+        ...(folded?.attachments ? { attachments: folded.attachments } : {}),
+        ...(folded?.subagents ? { subagents: folded.subagents.map(agent => ({ ...agent, status: agent.status === 'running' ? 'done' : agent.status })), subAgentCount: folded.subagents.length } : {}),
         startedAtMs,
         lastActivityMs,
         status: 'closed',
@@ -188,7 +157,6 @@ function rowRecency(row) {
 function sameRow(a, b) {
     return JSON.stringify(a) === JSON.stringify(b);
 }
-/** Stream-local sequencer and convergent row diff. */
 export class SessionWatchState {
     streamId;
     sequence = 0;
@@ -197,8 +165,6 @@ export class SessionWatchState {
     base(type) {
         return { version: SESSION_WATCH_VERSION, type, streamId: this.streamId, sequence: ++this.sequence, capturedAt: Date.now() };
     }
-    /** Keep one visible Previous row per session and the newest bounded window.
-     * Returns removed keys so delta callers can converge already-connected clients. */
     prunePrevious(scope, rows) {
         const removed = [];
         const bySession = new Map();
@@ -307,26 +273,16 @@ export class SessionWatchState {
         return events;
     }
     scope(scope, status, reason) {
-        // Deliberately retain rows while unavailable. A reconnecting scope replaces
-        // them with a reset; transient fleet loss must not look like session death.
         return { ...this.base('scope'), scope, status, ...(reason ? { reason } : {}) };
     }
     heartbeat(scope, capturedAt = Date.now()) {
         return { ...this.base('heartbeat'), scope, capturedAt };
     }
 }
-/** One bounded index read when the watch starts. The stream then owns this
- * projection: active rows update through the journal, and removals demote into
- * Previous rows without another transcript/index poll. */
 export function readPreviousSessionsForWatch(scope) {
     try {
         return querySessions({
             machine: normalizeHost(scope),
-            // Every harness that writes a discoverable transcript. The list used to be
-            // four, so a Kimi/Grok/Cursor/Droid session simply never appeared as a
-            // Previous row — and after PHNX-3939 it would also have been the only rows
-            // with no request/timeline. Kept explicit (not `SESSION_AGENTS`) so
-            // `openclaw`, which has no transcript to project, stays out.
             agents: SESSION_AGENTS.filter((agent) => agent !== 'openclaw'),
             sinceMs: Date.now() - 7 * 24 * 60 * 60 * 1000,
             excludeTeamOrigin: true,
@@ -338,10 +294,6 @@ export function readPreviousSessionsForWatch(scope) {
         return [];
     }
 }
-/**
- * Keep one local subscription alive. Startup reads one canonical reset snapshot;
- * steady state tails the canonical writer journal and never invokes a gather.
- */
 export async function watchLocalSessions(options) {
     const state = new SessionWatchState();
     const readCache = options.readCache ?? readActiveSessionsCache;
@@ -352,17 +304,12 @@ export async function watchLocalSessions(options) {
     try {
         offset = fs.statSync(journal).size;
     }
-    catch { /* first publication */ }
+    catch { }
     const initial = readCache('local');
     options.emit(state.reset(options.scope, initial?.sessions ?? [], readPrevious(options.scope)));
-    // 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 = '';
@@ -397,14 +344,14 @@ export async function watchLocalSessions(options) {
                                 options.emit(event);
                             options.emit(state.scope(options.scope, 'available'));
                         }
-                        catch { /* partial/corrupt journal lines are not state */ }
+                        catch { }
                     }
                 }
                 finally {
                     fs.closeSync(fd);
                 }
             }
-            catch { /* journal may not exist until the first publisher write */ }
+            catch { }
             finally {
                 reading = false;
             }
@@ -418,8 +365,6 @@ export async function watchLocalSessions(options) {
         }, 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
-        // startup offset is captured but before watchFile is registered.
         readAppended();
     });
 }
@@ -429,11 +374,6 @@ function remoteWatchCommand(os) {
         ? buildWindowsAgentsCommand({ args })
         : `bash -lc ${shellQuote(`agents ${args.map(shellQuote).join(' ')}`)}`;
 }
-/**
- * Subscribe to every dialable compute device with one persistent SSH process.
- * A peer disconnect emits `scope: unavailable` but no removes; reconnecting
- * peer resets only its own scope. There is no recurring fleet list command.
- */
 export async function watchFleetSessions(options) {
     const projection = new SessionProjection();
     const emit = (event) => { for (const projected of projection.apply(event))
@@ -468,7 +408,7 @@ export async function watchFleetSessions(options) {
                     return true;
                 }
                 catch {
-                    return false; /* incomplete/non-protocol peer output is not state */
+                    return false;
                 }
             },
             onUnavailable: (reason) => emit(state.scope(scope, 'unavailable', reason)),

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

@@ -1,49 +1,14 @@
 import type { ActiveSession } from './active.js';
-/**
- * Recursion guard, passed as an env var (not a CLI flag) so an OLDER remote
- * `agents` that predates this feature ignores it harmlessly instead of erroring
- * on an unknown option. A remote new enough to fan out reads it and stays local.
- */
 export declare const NO_FANOUT_ENV = "AGENTS_SESSIONS_LOCAL";
-/**
- * Parse a peer's `--active --json` stdout into active sessions, tagging each
- * with `machine`. Defensive against version skew / partial output: non-JSON or
- * a non-array yields `[]`, and non-object entries are dropped rather than
- * throwing. `viewingIn` arrives as a display string from a current peer and as
- * an `{app, tab}` object from one that predates the flattening, so it is
- * normalized here — the single boundary where a foreign row becomes internal.
- * Exported for unit testing without a live tailnet.
- */
 export declare function parseRemoteActive(stdout: string, machine: string): ActiveSession[];
 interface RemoteActiveResult {
     sessions: ActiveSession[];
-    /** How many peer machines we attempted to reach (drives the empty-fleet tip). */
     deviceCount: number;
-    /**
-     * Peer device names that were unreachable, timed out, or lacked the CLI —
-     * distinct from a peer that answered with zero sessions. Named so an empty
-     * fleet-wide result can say WHICH peers went unheard rather than reading
-     * identical to "the fleet is genuinely idle" (RUSH-2507).
-     */
     skipped: string[];
-    /** True when the device list itself could not be loaded — no peer was even attempted. */
     discoveryFailed: boolean;
 }
-/**
- * Gather active sessions from other machines. With an explicit `hosts` list
- * (from `--device`), fan out to exactly those. Otherwise sweep the registered,
- * online devices from `ag devices`, excluding this machine and any without an
- * address. Results from all peers run in parallel and are flattened.
- * `opts.quiet` suppresses the per-device stderr line for callers that report
- * skipped peers once, compactly, themselves.
- */
 export declare function gatherRemoteActive(hosts?: string[], opts?: {
     quiet?: boolean;
-    /**
-     * Opt-in first-hit abort. Omitted by default so `--active`, projects, and
-     * `focus` with no id keep all-settle. Detach/stop pass this for a unique
-     * live id so a reachable hit does not wait out sleeping peers.
-     */
     earlyExit?: {
         isDefinitive: (item: ActiveSession, machine: string) => boolean;
     };

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

@@ -1,36 +1,6 @@
-/**
- * Cross-machine fan-out for `agents sessions --active`.
- *
- * A single `getActiveSessions()` only sees the local machine. To show the whole
- * fleet in one view, we run `agents sessions --active --json --local` on each
- * peer over SSH and merge the parsed results, tagging every row with the machine
- * it came from so the renderer can bucket by computer.
- *
- * Peers are the registered, online devices from `ag devices` (or an explicit
- * `--device` list). `--local` on the remote invocation is critical: it stops the
- * peer from fanning out to *its* devices, so the sweep never recurses.
- *
- * A dead or slow host is skipped with a stderr note, never fatal — one asleep
- * laptop must not blank the whole view. SSH runs are async + parallel (a fresh
- * `spawn`, not the sync `sshExec`) so N peers cost one round-trip, not N.
- */
 import { gatherRemoteAgentsJson } from '../remote-agents-json.js';
 import { parseViewingIn } from './viewing-in.js';
-/**
- * Recursion guard, passed as an env var (not a CLI flag) so an OLDER remote
- * `agents` that predates this feature ignores it harmlessly instead of erroring
- * on an unknown option. A remote new enough to fan out reads it and stays local.
- */
 export const NO_FANOUT_ENV = 'AGENTS_SESSIONS_LOCAL';
-/**
- * Parse a peer's `--active --json` stdout into active sessions, tagging each
- * with `machine`. Defensive against version skew / partial output: non-JSON or
- * a non-array yields `[]`, and non-object entries are dropped rather than
- * throwing. `viewingIn` arrives as a display string from a current peer and as
- * an `{app, tab}` object from one that predates the flattening, so it is
- * normalized here — the single boundary where a foreign row becomes internal.
- * Exported for unit testing without a live tailnet.
- */
 export function parseRemoteActive(stdout, machine) {
     let parsed;
     try {
@@ -44,16 +14,6 @@ export function parseRemoteActive(stdout, machine) {
     const out = [];
     for (const x of parsed) {
         if (x && typeof x === 'object' && !Array.isArray(x)) {
-            // The dialed machine still wins by default. That is deliberate: the peer
-            // reports `machineId()` (its hostname) while we key on the REGISTERED
-            // device name, and stamping ours is the only thing reconciling the two —
-            // drop it and a device whose registered name differs from its hostname
-            // silently answers a `--device <name>` scope with zero rows.
-            //
-            // The one row that must keep its own answer is an offloaded run, whose
-            // execution host is a THIRD box, not the peer we dialed
-            // (foldExecutionMachine, RUSH-2479). `offloadedFrom` marks exactly that
-            // row, so it is the discriminator rather than "the peer said something".
             const reported = x;
             const row = {
                 ...reported,
@@ -65,14 +25,6 @@ export function parseRemoteActive(stdout, machine) {
     }
     return out;
 }
-/**
- * Gather active sessions from other machines. With an explicit `hosts` list
- * (from `--device`), fan out to exactly those. Otherwise sweep the registered,
- * online devices from `ag devices`, excluding this machine and any without an
- * address. Results from all peers run in parallel and are flattened.
- * `opts.quiet` suppresses the per-device stderr line for callers that report
- * skipped peers once, compactly, themselves.
- */
 export async function gatherRemoteActive(hosts, opts) {
     const result = await gatherRemoteAgentsJson({
         args: ['sessions', '--active', '--json'],

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

@@ -1,3 +1 @@
-// Moved to ./remote/remote-bundle.ts (move 4 of the core-module refactor).
-// Kept as a re-export shim so existing importers don't break.
 export * from './remote/remote-bundle.js';

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

@@ -1,3 +1 @@
-// Moved to ./remote/remote-list.ts (move 4 of the core-module refactor).
-// Kept as a re-export shim so existing importers don't break.
 export * from './remote/remote-list.js';

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

@@ -1,4 +1,3 @@
-/** Bounded, single-owner preview fetch with a durable requester cache and cross-process coalescing. */
 import { fetchPeerPreviewEnvelope } from './remote/remote-list.js';
 export type RemotePreviewCacheState = 'fresh' | 'stale-offline' | 'stale-error' | 'no-cache-offline' | 'no-cache-error' | 'invalid-id';
 export interface RemotePreviewOutcome {
@@ -12,13 +11,7 @@ export interface RemotePreviewOutcome {
         reason: string | null;
     };
 }
-/** A changed caller cursor invalidates a good copy; failed attempts preserve both its content and cursor. */
 export interface RemotePreviewDeps {
-    /** Defaults to the real bounded SSH transport ({@link fetchPeerPreviewEnvelope}).
-     * Overridable so the cache/backoff/revision/lease STATE MACHINE can be tested
-     * against a real SQLite DB without a live peer — this repo has no fleet in
-     * CI, and the actual bounded-transport behavior (timeout, byte cap) is
-     * already covered where `fetchPeerPreviewEnvelope`/`sshCapture` are defined. */
     fetchEnvelope: typeof fetchPeerPreviewEnvelope;
 }
 export declare function getRemoteSessionPreview(sessionId: string, device: string, opts?: {