@phnx-labs/agents-cli 1.22.82 → 1.22.84

package/dist/lib/feed/activity.js

@@ -119,7 +119,11 @@ export function appendActivityEvent(event, root) {
     };
     fs.appendFileSync(activityPath(dir, event.sessionId), `${JSON.stringify(record)}\n`, { mode: 0o644 });
 }
-function parseLine(line) {
+/**
+ * Parse one activity log line. Tolerant by design: a blank, corrupt, or
+ * half-written line is skipped rather than failing the whole read.
+ */
+export function parseActivityLine(line) {
     const trimmed = line.trim();
     if (!trimmed)
         return undefined;
@@ -160,6 +164,8 @@ function parseLine(line) {
         return undefined; // skip corrupt / partial lines (fail-open reader)
     }
 }
+/** Per-session byte budget for a bounded tail read of an activity log. */
+export const ACTIVITY_TAIL_BYTES = 256 * 1024;
 /** Read the tail of a file as UTF-8, bounded to the last `maxBytes`. */
 function readTail(file, maxBytes) {
     let fd;
@@ -181,24 +187,105 @@ function readTail(file, maxBytes) {
         return text;
     }
     catch {
-        return '';
+        return undefined;
     }
     finally {
         if (fd !== undefined)
             fs.closeSync(fd);
     }
 }
-/** Read all events for one session (bounded tail). */
-export function readSessionActivity(sessionId, root, maxBytes = 256 * 1024) {
-    const dir = root ?? getActivityDir();
-    const text = readTail(activityPath(dir, sessionId), maxBytes);
-    const out = [];
+// Process-local tail cache: bounded independently of the number of historical
+// sessions or directories a long-lived consumer visits. Never expose cached
+// objects: callers enrich and mutate returned events (including nested values).
+const ACTIVITY_CACHE_BYTES = 32 * 1024 * 1024;
+const ACTIVITY_CACHE_FILES = 1024;
+const activityTails = new Map();
+let activityTailBytes = 0;
+function forgetActivityTail(key) {
+    const old = activityTails.get(key);
+    if (old)
+        activityTailBytes -= old.weight;
+    activityTails.delete(key);
+}
+function activityStamp(file) {
+    // ctime catches same-size rewrites even when a producer restores mtime;
+    // device/inode catches atomic replacement. Nanoseconds avoid rounding away
+    // changes made between consecutive polls on high-resolution filesystems.
+    const st = fs.statSync(file, { bigint: true });
+    return `${st.dev}:${st.ino}:${st.size}:${st.mtimeNs}:${st.ctimeNs}`;
+}
+function readActivityTail(file, maxBytes, sinceMs = -Infinity) {
+    const key = `${path.resolve(file)}\0${maxBytes}`;
+    let stamp;
+    try {
+        stamp = activityStamp(file);
+    }
+    catch {
+        forgetActivityTail(key);
+        return { stamp: '', events: [], newestMs: -Infinity, weight: 0 };
+    }
+    const cached = activityTails.get(key);
+    if (cached?.stamp === stamp && (cached.events || cached.newestMs < sinceMs)) {
+        activityTails.delete(key);
+        activityTails.set(key, cached);
+        return cached;
+    }
+    forgetActivityTail(key);
+    const text = readTail(file, maxBytes);
+    // Transient I/O failure is not an empty file snapshot; retry next read.
+    if (text === undefined)
+        return { stamp, events: [], newestMs: -Infinity, weight: 0 };
+    const events = [];
+    let newestMs = -Infinity;
     for (const line of text.split('\n')) {
-        const ev = parseLine(line);
-        if (ev)
-            out.push(ev);
+        const event = parseActivityLine(line);
+        if (!event)
+            continue;
+        events.push(event);
+        try {
+            const ms = Date.parse(event.ts);
+            if (Number.isFinite(ms))
+                newestMs = Math.max(newestMs, ms);
+        }
+        catch {
+            // The tolerant parser historically accepts truthy non-string values.
+            // Do not introduce a conversion error before the caller's event filters
+            // (or into session reads, which never converted timestamps at all).
+            newestMs = Infinity;
+        }
     }
-    return out;
+    // Bound retained source-derived strings, objects, and entry overhead. Large
+    // one-off tails still read normally, but cannot displace the entire cache.
+    const weight = text.length * 2 + events.length * 1024 + key.length * 2 + 256;
+    const result = { stamp, events, newestMs, weight };
+    try {
+        // A writer racing the read must not pin a mixed snapshot as unchanged.
+        if (activityStamp(file) === stamp) {
+            if (activityTails.size >= ACTIVITY_CACHE_FILES)
+                forgetActivityTail(activityTails.keys().next().value);
+            const summaryWeight = key.length * 2 + 256;
+            const retained = weight <= ACTIVITY_CACHE_BYTES / 2 ? { ...result } : { ...result, events: undefined, weight: summaryWeight };
+            // Retain timestamp summaries even when parsed tails exceed the budget:
+            // otherwise a large historical corpus thrashes on every cursor poll.
+            for (const [oldKey, old] of activityTails) {
+                if (activityTailBytes + retained.weight <= ACTIVITY_CACHE_BYTES)
+                    break;
+                const summary = oldKey.length * 2 + 256;
+                activityTailBytes -= old.weight - summary;
+                old.events = undefined;
+                old.weight = summary;
+            }
+            activityTails.set(key, retained);
+            activityTailBytes += retained.weight;
+        }
+    }
+    catch { /* Deleted during the read: return this snapshot without caching. */ }
+    return result;
+}
+/** Read all events for one session (bounded tail). */
+export function readSessionActivity(sessionId, root, maxBytes = ACTIVITY_TAIL_BYTES) {
+    const dir = root ?? getActivityDir();
+    return structuredClone(readActivityTail(activityPath(dir, sessionId), maxBytes).events ?? []);
 }
 /** List session ids that have an activity log. */
 export function listActivitySessions(root) {
@@ -220,7 +307,10 @@ export function readRecentActivity(opts = {}) {
     const wanted = opts.events && opts.events.length > 0 ? new Set(opts.events) : null;
     const all = [];
     for (const sessionId of listActivitySessions(dir)) {
-        for (const ev of readSessionActivity(sessionId, dir, opts.maxBytesPerSession)) {
+        const tail = readActivityTail(activityPath(dir, sessionId), opts.maxBytesPerSession ?? ACTIVITY_TAIL_BYTES, sinceMs);
+        if (tail.newestMs < sinceMs)
+            continue;
+        for (const ev of tail.events ?? []) {
             if (wanted && !wanted.has(ev.event))
                 continue;
             if (opts.tier && ev.tier !== opts.tier)
@@ -231,7 +321,7 @@ export function readRecentActivity(opts = {}) {
         }
     }
     all.sort((a, b) => Date.parse(b.ts) - Date.parse(a.ts));
-    return typeof opts.limit === 'number' ? all.slice(0, opts.limit) : all;
+    return structuredClone(typeof opts.limit === 'number' ? all.slice(0, opts.limit) : all);
 }
 /**
  * Split a chronological event list into individual milestones plus a

package/dist/lib/feed/watch.d.ts

@@ -1,4 +1,4 @@
-import { type SessionWatchEnvelope, type SessionWatchRow, type SessionWatchScopeStatus } from '../session/watch.js';
+import { type SessionWatchEnvelope, type SessionWatchRow, type SessionWatchScopeStatus, type WatchLocalOptions } from '../session/watch.js';
 import { type AttentionItem } from './attention.js';
 import { type ActivityEvent } from './activity.js';
 export declare const FEED_WATCH_VERSION: 1;
@@ -48,12 +48,18 @@ export declare class FeedWatchState {
     emit(event: FeedWatchPayload): FeedWatchEnvelope;
 }
 export declare function projectSessionEnvelope(event: SessionWatchEnvelope, state: FeedWatchState): Promise<FeedWatchEnvelope[]>;
-export declare function watchLocalFeed(options: {
+export interface WatchLocalFeedOptions {
     scope: string;
     signal: AbortSignal;
     emit: (event: FeedWatchEnvelope) => void;
+    /** Activity drain cadence. */
     activityPollMs?: number;
-}): Promise<void>;
+    /** Attention reconcile cadence when nothing has announced a change. */
+    reconcileMs?: number;
+    /** Session-watch inputs, forwarded verbatim to {@link watchLocalSessions}. */
+    sessions?: Pick<WatchLocalOptions, 'readCache' | 'readPrevious' | 'journalPath' | 'journalPollMs' | 'heartbeatMs'>;
+}
+export declare function watchLocalFeed(options: WatchLocalFeedOptions): Promise<void>;
 export declare function watchFleetFeed(options: {
     signal: AbortSignal;
     emit: (event: FeedWatchEnvelope) => void;

package/dist/lib/feed/watch.js

@@ -1,16 +1,17 @@
 import { randomUUID } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { loadDevices, isDialableDevice } from '../devices/registry.js';
-import { deviceIdentityArgs, sshTargetFor } from '../devices/connect.js';
 import { machineId, normalizeHost } from '../machine-id.js';
-import { SSH_OPTS, controlOpts, shellQuote } from '../ssh-exec.js';
+import { shellQuote } from '../ssh-exec.js';
 import { buildWindowsAgentsCommand, remoteShellFor } from '../hosts/remote-cmd.js';
+import { getFeedDir } from '../state.js';
+import { streamFromPeer } from '../session/remote/peer-stream.js';
 import { watchLocalSessions } from '../session/watch.js';
 import { readBlock, readResolution, blockIdForSession } from './feed.js';
 import { reconcileAttention } from './attention.js';
-import { readRecentActivity } from './activity.js';
-import { readPullRequestStatus } from './pr-status.js';
+import { ActivityStream } from './activity-stream.js';
+import { PR_STATUS_TTL_MS, readPullRequestStatus } from './pr-status.js';
 export const FEED_WATCH_VERSION = 1;
 export class FeedWatchState {
     streamId;
@@ -64,8 +65,37 @@ export async function projectSessionEnvelope(event, state) {
         return [state.emit({ type: 'scope', capturedAt: event.capturedAt, scope: event.scope, status: event.status, ...(event.reason ? { reason: event.reason } : {}) })];
     return [state.emit({ type: 'heartbeat', capturedAt: event.capturedAt, scope: event.scope })];
 }
+/**
+ * Watch the feed dirs that can change attention without a session event: an
+ * `agents feed post --blocked` writes a block, `feed answer` writes a
+ * resolution. Both are external processes, so nothing on the session stream
+ * announces them — this is what lets the reconcile pass be event-driven instead
+ * of a poll over every row twice a second.
+ */
+function watchAttentionStores(onChange) {
+    const feedDir = getFeedDir();
+    const watchers = [];
+    for (const dir of [feedDir, path.join(feedDir, 'resolutions')]) {
+        try {
+            const watcher = fs.watch(dir, () => onChange());
+            // A directory that disappears must not take the watcher process down; the
+            // PR-status cadence below still reconciles on its own timer.
+            watcher.on('error', () => watcher.close());
+            watchers.push(watcher);
+        }
+        catch { /* the dir appears with the first block; the timed pass covers it */ }
+    }
+    return () => { for (const watcher of watchers)
+        watcher.close(); };
+}
 export async function watchLocalFeed(options) {
     const state = new FeedWatchState();
+    // The stream's opening scan registers every log past its own bytes, so the
+    // cursor has to be taken *after* it: a record appended while the scan was
+    // walking the directory is unreadable from the byte cursor, and only a
+    // timestamp taken after the scan classifies it as history rather than
+    // dropping it from a window the caller believes was covered.
+    const activity = new ActivityStream();
     let activityCursor = Date.now();
     const agents = new Map();
     const attention = new Map();
@@ -82,20 +112,34 @@ export async function watchLocalFeed(options) {
                 : state.emit({ type: 'attention.remove', scope: options.scope, rowKey }));
         }
     };
+    // Attention is reconciled when something can actually have changed it — a row
+    // moved, a block/resolution file was written — or when the PR-status TTL has
+    // expired and the cached verdicts are stale. Re-running it every 500 ms cost
+    // two file reads per row per tick and changed nothing.
+    const reconcileMs = options.reconcileMs ?? PR_STATUS_TTL_MS;
+    let attentionDirty = true;
+    let lastReconcileMs = 0;
+    const markAttentionDirty = () => { attentionDirty = true; };
+    const stopAttentionWatch = watchAttentionStores(markAttentionDirty);
     const activityTimer = setInterval(() => {
         pending = pending.then(async () => {
-            const events = readRecentActivity({ sinceMs: activityCursor + 1 }).reverse();
+            const nowMs = Date.now();
+            const events = activity.read(activityCursor + 1, nowMs).reverse();
             for (const event of events) {
                 activityCursor = Math.max(activityCursor, Date.parse(event.ts));
                 options.emit(state.emit({ type: 'activity.append', scope: options.scope, event }));
             }
+            if (!attentionDirty && nowMs - lastReconcileMs < reconcileMs)
+                return;
+            attentionDirty = false;
+            lastReconcileMs = nowMs;
             await reconcileRows();
         });
     }, options.activityPollMs ?? 500);
-    const stopActivity = () => clearInterval(activityTimer);
+    const stopActivity = () => { clearInterval(activityTimer); stopAttentionWatch(); activity.close(); };
     options.signal.addEventListener('abort', stopActivity, { once: true });
     try {
-        await watchLocalSessions({ scope: options.scope, signal: options.signal, emit: (event) => {
+        await watchLocalSessions({ ...options.sessions, scope: options.scope, signal: options.signal, emit: (event) => {
                 if (event.type === 'reset') {
                     agents.clear();
                     for (const row of event.rows)
@@ -156,35 +200,27 @@ export async function watchFleetFeed(options) {
     }
     const self = machineId();
     const peers = Object.values(devices).filter((device) => isDialableDevice(device) && normalizeHost(device.name) !== self && ['windows', 'linux', 'macos'].includes(device.platform));
-    const tasks = peers.map(async (device) => {
+    const tasks = peers.map((device) => {
         const scope = normalizeHost(device.name);
-        while (!options.signal.aborted) {
-            let target;
-            try {
-                target = sshTargetFor(device);
-            }
-            catch (error) {
-                options.emit(coordinator.emit({ type: 'scope', capturedAt: Date.now(), scope, status: 'unavailable', reason: String(error) }));
-                break;
-            }
-            const child = spawn('ssh', [...SSH_OPTS, ...controlOpts(), ...deviceIdentityArgs(device), target, remoteFeedWatchCommand(device.platform)], { stdio: ['ignore', 'pipe', 'ignore'] });
-            const stop = () => child.kill('SIGTERM');
-            options.signal.addEventListener('abort', stop, { once: true });
-            const reader = createInterface({ input: child.stdout });
-            reader.on('line', (line) => { try {
-                const event = JSON.parse(line);
-                if (event.v === 1)
+        return streamFromPeer({
+            device,
+            signal: options.signal,
+            command: remoteFeedWatchCommand(device.platform),
+            backoffBaseMs: options.reconnectMs,
+            onLine: (line) => {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.v !== 1)
+                        return false;
                     forward(event);
-            }
-            catch { /* protocol only */ } });
-            const code = await new Promise((resolve) => { child.once('error', () => resolve(null)); child.once('close', resolve); });
-            reader.close();
-            options.signal.removeEventListener('abort', stop);
-            if (options.signal.aborted)
-                break;
-            options.emit(coordinator.emit({ type: 'scope', capturedAt: Date.now(), scope, status: 'unavailable', reason: code == null ? 'ssh failed' : `ssh exited ${code}` }));
-            await new Promise((resolve) => { const timer = setTimeout(resolve, options.reconnectMs ?? 2_000); options.signal.addEventListener('abort', () => { clearTimeout(timer); resolve(); }, { once: true }); });
-        }
+                    return true;
+                }
+                catch {
+                    return false; /* protocol only */
+                }
+            },
+            onUnavailable: (reason) => options.emit(coordinator.emit({ type: 'scope', capturedAt: Date.now(), scope, status: 'unavailable', reason })),
+        });
     });
     await Promise.all([local, ...tasks]);
 }

package/dist/lib/fleet-shared-state.d.ts

@@ -34,6 +34,12 @@ export interface SessionMirrorRow {
     summaryChecklist?: import('./session/types.js').SessionChecklistItem[];
     /** Lifecycle of the daemon-computed summary (PHNX-3939). */
     summaryState?: import('./session/types.js').SummaryState;
+    /** Tidied latest user turn, so a peer row shows what the agent was asked (PHNX-3939). */
+    request?: import('./session/types.js').SessionRequest;
+    /** Bounded narration-anchored steps, so a peer row shows what the agent did. */
+    timeline?: import('./session/types.js').SessionTimeline;
+    /** Bounded file-change list for the peer row. */
+    files?: import('./session/types.js').SessionFiles;
     capturedAt: number;
 }
 export interface FleetSharedDeviceState {

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

@@ -3,7 +3,7 @@ import { type PidSessionEntry } from './pid-registry.js';
 import { type HookSessionIndex } from './hook-sessions.js';
 import { type UserPromptKind } from './prompt.js';
 import { type SessionState, type SessionActivity, type AwaitingReason, type StructuredQuestion, type TodoProgress, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
-import { type SessionAgentId, type SessionAttachment, type SessionMeta } from './types.js';
+import { type SessionAgentId, type SessionAttachment, type SessionFiles, type SessionMeta, type SessionRequest, type SessionTimeline } from './types.js';
 import { type SessionProvenance } from './provenance.js';
 import { type DeviceRegistry } from '../devices/registry.js';
 import { type Presence } from './detached.js';
@@ -55,7 +55,7 @@ export declare function attributedSetLostPids(prev: Set<number>, next: Set<numbe
 export declare function filterCachedUnattributed(sessions: ActiveSession[], attributed: Set<number>, alive: (pid: number, startedAtMs?: number) => boolean): ActiveSession[];
 type ActiveContext = 'terminal' | 'teams' | 'cloud' | 'headless';
 /** The SessionMeta fields the live-row backfill reads — the enrichment a running process cannot report. */
-export type BackfillMeta = Pick<SessionMeta, 'version' | 'account' | 'timestamp' | 'label' | 'firstUserMessage' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName' | 'harness' | 'tokenCount' | 'durationMs' | 'subAgentCount'>;
+export type BackfillMeta = Pick<SessionMeta, 'version' | 'account' | 'timestamp' | 'label' | 'firstUserMessage' | 'lastUserMessage' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName' | 'harness' | 'tokenCount' | 'durationMs' | 'subAgentCount'>;
 export declare function backfillActiveRowsFromMeta(sessions: ActiveSession[], metaById: Map<string, BackfillMeta>): void;
 export declare function backfillActiveRowsFromIndex(sessions: ActiveSession[]): void;
 export declare function isRunningLiveSession(s: ActiveSession): boolean;
@@ -140,6 +140,13 @@ export interface ActiveSession {
     topic?: string;
     /** Full, cleaned first genuine user turn, backfilled from the session index. */
     firstUserMessage?: string;
+    /**
+     * Full, cleaned LATEST genuine user turn, backfilled from the session index
+     * beside {@link firstUserMessage}. This is what {@link deriveSessionRecap}
+     * classifies — a `/continue`d or redirected session's real request is the last
+     * thing the user said, not the first (PHNX-3939).
+     */
+    lastUserMessage?: string;
     /**
      * The row's shown title — WHAT the session is, best-source-wins (RUSH-3011).
      * The ladder ({@link deriveSessionRecap}): a `/rename` or harness `label` →
@@ -207,6 +214,22 @@ export interface ActiveSession {
     spawnedTeam?: string;
     /** Files/screenshots attached to the session prompt. */
     attachments?: SessionAttachment[];
+    /**
+     * The session's operative request: the LATEST genuine user turn, tidied but
+     * never rewritten (PHNX-3939) — prose separated from screenshot paths, clip
+     * references, `@dir` mentions and pasted terminal echo. Folded by the daemon
+     * timeline pass and merged from the `session_timelines` cache; the sidebar's
+     * Request card reads it straight off the row.
+     */
+    request?: SessionRequest;
+    /**
+     * Narration-anchored steps — what the agent has been doing, in its own words
+     * (PHNX-3939). Last 8 in full plus a fold of everything older. Produced by the
+     * daemon's timeline pass, never on the request path.
+     */
+    timeline?: SessionTimeline;
+    /** Files the session created, modified or deleted; ≤ 8 rows plus a total. */
+    files?: SessionFiles;
     /** Total tokens and elapsed duration from the indexed transcript. */
     tokenCount?: number;
     durationMs?: number;
@@ -906,13 +929,24 @@ export declare function sessionProcessIsLocal(s: Pick<ActiveSession, 'machine' |
  */
 export declare function sessionProcessHost(s: Pick<ActiveSession, 'machine' | 'offloadedFrom'>, self: string): string | undefined;
 export declare function foldHostLink(rows: ActiveSession[]): void;
-/** Labels win, then the last assistant line, then the first-prompt topic. */
-export declare function deriveSessionRecap(row: Pick<ActiveSession, 'label' | 'topic' | 'tail'>): {
+/**
+ * Labels win, then the last assistant line, then the prompt.
+ *
+ * The prompt rung classifies the RAW latest genuine user turn, not the
+ * already-collapsed `topic` (PHNX-3939). Classifying `topic` was how a `/model`
+ * echo or a skill body became a session's displayed title: `extractSessionTopic`
+ * accepted text `cleanFirstUserMessage` rejected, and the recap then dressed up
+ * that scaffolding as the user's words. It also never saw the row's attachments,
+ * so an image-only turn could not be recognized. A row that has already been
+ * merged with a daemon-folded {@link ActiveSession.request} uses it directly.
+ */
+export declare function deriveSessionRecap(row: Pick<ActiveSession, 'label' | 'topic' | 'tail' | 'firstUserMessage' | 'lastUserMessage' | 'attachments' | 'request'>): {
     title?: string;
     recapSource?: RecapSource;
     userPromptClean?: string;
     userPromptKind?: UserPromptKind;
     lastAgentLine?: string;
+    request?: SessionRequest;
 };
 /** Fold the recap ladder onto every row (see {@link deriveSessionRecap}). */
 export declare function foldRecap(rows: ActiveSession[]): void;

package/dist/lib/session/active.js

@@ -30,7 +30,7 @@ import { loadHookSessionIndex, resolveHookSessionRecord, readStateSessionRecord
 import { buildClaudeLabelMap, getAgentSessionDirs } from './discover.js';
 import { buildRunNameMap } from './run-names.js';
 import { latestSessionFileForCwd, findSessionsByShortIds, findSessionMachinesByIds, getSessionById } from './db.js';
-import { extractSessionTopic, classifyUserPrompt } from './prompt.js';
+import { extractSessionTopic, classifyUserPrompt, tidyRequest } from './prompt.js';
 import { readSessionTailWithRaw } from './tail.js';
 import { parseSession } from './parse.js';
 import { computeTokPerSec } from './throughput.js';
@@ -151,6 +151,8 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
             s.label = m.label;
         if (!s.firstUserMessage && m.firstUserMessage)
             s.firstUserMessage = m.firstUserMessage;
+        if (!s.lastUserMessage && m.lastUserMessage)
+            s.lastUserMessage = m.lastUserMessage;
         if (!s.ticket && m.ticketId)
             s.ticket = { id: m.ticketId, url: linearIssueUrl(m.ticketId) };
         if (!s.pr && m.prUrl)
@@ -2101,10 +2103,31 @@ function recapLine(s, max = 120) {
         return undefined;
     return t.length > max ? t.slice(0, max - 1).trimEnd() + '…' : t;
 }
-/** Labels win, then the last assistant line, then the first-prompt topic. */
+/**
+ * Labels win, then the last assistant line, then the prompt.
+ *
+ * The prompt rung classifies the RAW latest genuine user turn, not the
+ * already-collapsed `topic` (PHNX-3939). Classifying `topic` was how a `/model`
+ * echo or a skill body became a session's displayed title: `extractSessionTopic`
+ * accepted text `cleanFirstUserMessage` rejected, and the recap then dressed up
+ * that scaffolding as the user's words. It also never saw the row's attachments,
+ * so an image-only turn could not be recognized. A row that has already been
+ * merged with a daemon-folded {@link ActiveSession.request} uses it directly.
+ */
 export function deriveSessionRecap(row) {
     const lastAgentLine = recapLine(row.tail?.length ? row.tail[row.tail.length - 1] : undefined);
-    const { clean: userPromptClean, kind: userPromptKind } = classifyUserPrompt(row.topic ?? '');
+    const raw = row.lastUserMessage ?? row.firstUserMessage ?? row.topic ?? '';
+    // No `turns` here on purpose: this tidy sees ONE turn, not the transcript, so
+    // it cannot count them. The daemon fold sets it (see SessionRequest.turns).
+    const tidied = row.request ?? tidyRequest(raw, { attachments: row.attachments });
+    // No genuine turn to show (a synthetic-only transcript, or nothing indexed
+    // yet): fall back to the legacy classifier over whatever `topic` holds rather
+    // than showing an empty prompt rung.
+    const fallback = tidied ? undefined : classifyUserPrompt(row.topic ?? '', {
+        hasImageAttachment: row.attachments?.some((a) => a.mediaType?.startsWith('image/')),
+    });
+    const userPromptClean = tidied?.headline ?? fallback?.clean;
+    const userPromptKind = tidied?.kind ?? fallback?.kind;
     const label = recapLine(row.label);
     const prompt = recapLine(userPromptClean || row.topic);
     let title;
@@ -2121,7 +2144,14 @@ export function deriveSessionRecap(row) {
         title = prompt;
         recapSource = 'prompt';
     }
-    return { title, recapSource, userPromptClean: recapLine(userPromptClean), userPromptKind, lastAgentLine };
+    return {
+        title,
+        recapSource,
+        userPromptClean: recapLine(userPromptClean),
+        userPromptKind,
+        lastAgentLine,
+        ...(tidied ? { request: tidied } : {}),
+    };
 }
 /** Fold the recap ladder onto every row (see {@link deriveSessionRecap}). */
 export function foldRecap(rows) {
@@ -2132,6 +2162,8 @@ export function foldRecap(rows) {
         s.userPromptClean = recap.userPromptClean;
         s.userPromptKind = recap.userPromptKind;
         s.lastAgentLine = recap.lastAgentLine;
+        if (recap.request)
+            s.request = recap.request;
     }
 }
 /**

package/dist/lib/session/bash-command.js

@@ -456,6 +456,16 @@ export function detectBashMilestone(command) {
         if (lower.includes('pr merge'))
             return { event: 'pr.merged', detail: 'gh pr merge' };
     }
+    // The repo's own toolchain: spawning a team and rendering an artifact are the
+    // two things an operator looks for in a session's history alongside a commit
+    // or a PR, and both are shell-driven (PHNX-3939).
+    if (info.tool === 'agents' && info.subcommand === 'teams'
+        && /\bteams\s+(create|add|start)\b/.test(lower)) {
+        return { event: 'team.spawned', detail: 'agents teams' };
+    }
+    if (/\bartifacts\s+render\b/.test(lower)) {
+        return { event: 'artifact.rendered', detail: 'artifacts render' };
+    }
     return null;
 }
 /**

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

@@ -7,13 +7,14 @@
  * BM25 ranking, and label-first search for /rename'd sessions.
  */
 import Database from '../sqlite.js';
-import type { SessionAgentId, SessionCheckpoint, SessionChecklistItem, SessionEvent, SessionMeta, SummaryState } from './types.js';
+import type { SessionAgentId, SessionCheckpoint, SessionChecklistItem, SessionEvent, SessionFiles, SessionMeta, SessionRequest, SessionTimeline, SummaryState } from './types.js';
 import { type IndexedToolCall } from './tool-calls.js';
 import { type ToolScanResumePoint } from './tool-store.js';
+import { type TimelineState } from './timeline.js';
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/sessions.md calls the constant the source of truth). */
-export declare const SCHEMA_VERSION = 47;
+export declare const SCHEMA_VERSION = 48;
 /**
  * Bump to force the content extractor (assistant-answer text, alongside the
  * user-prompt text every harness already accumulates) to re-derive on every
@@ -478,6 +479,46 @@ export declare function writeSessionSummary(entry: {
     fileSize: number | null;
     summary: SessionSummaryEntry;
 }): void;
+/**
+ * The daemon-computed timeline stored in `session_timelines` (PHNX-3939): the
+ * bounded projection a row merges, plus the request and files derived in the
+ * same fold.
+ */
+export interface SessionTimelineProjection {
+    timeline: SessionTimeline;
+    request?: SessionRequest;
+    files?: SessionFiles;
+}
+/** One folded timeline, as the pass produces it for writing. */
+export interface SessionTimelineEntry extends SessionTimelineProjection {
+    state: TimelineState;
+}
+/** One cached row as READ back: the folded entry plus when it was folded. */
+export interface SessionTimelineCacheRow extends SessionTimelineEntry {
+    /** Epoch ms this row was folded — the pass's re-parse rate limit reads it. */
+    computedAt: number;
+}
+/**
+ * Read the projection AND the resume state for one session, whatever the
+ * transcript stamp — the daemon pass's read, which needs the state to continue
+ * from and re-stats the file itself.
+ */
+export declare function readSessionTimelineEntry(id: string): SessionTimelineCacheRow | undefined;
+/**
+ * Read only the bounded projection for one session — the display merge, on the
+ * read path. Deliberately does NOT parse the resume state: a live row needs the
+ * 8 steps and the request, never the fold's bookkeeping.
+ */
+export declare function readSessionTimelineAny(id: string): SessionTimelineProjection | undefined;
+/** Persist a folded timeline against the exact transcript bytes it was folded to. */
+export declare function writeSessionTimeline(entry: {
+    id: string;
+    fileMtimeMs: number | null;
+    fileSize: number | null;
+    timeline: SessionTimelineEntry;
+    /** Fold time. Injected by the pass so its re-parse interval is testable without the wall clock. */
+    computedAtMs?: number;
+}): void;
 /** A local-origin session, projected to the compact fields the fleet mirror publishes. */
 export interface LocalMirrorSource {
     id: string;
@@ -495,6 +536,8 @@ export interface LocalMirrorSource {
     prUrl: string | null;
     /** Daemon-computed summary (PHNX-3939), so peers carry it without a transcript. */
     summary: SessionSummaryEntry | null;
+    /** Daemon-folded request/timeline/files (PHNX-3939), same reason as {@link summary}. */
+    timeline: SessionTimelineProjection | null;
 }
 /**
  * The most-recently-active sessions whose transcript is genuinely local to this
@@ -521,6 +564,8 @@ export interface MirrorSessionUpsert {
     prUrl?: string | null;
     /** Daemon-computed summary carried from the publishing peer (PHNX-3939). */
     summary?: SessionSummaryEntry | null;
+    /** Daemon-folded request/timeline/files carried from the publishing peer (PHNX-3939). */
+    timeline?: SessionTimelineProjection | null;
 }
 /**
  * Write one peer session's digest into the local `sessions` index as a mirror