@phnx-labs/agents-cli 1.22.83 → 1.22.85

package/dist/lib/secrets-types.js

@@ -0,0 +1,24 @@
+/**
+ * Wire-shared types for the standalone `secrets` CLI (PHNX-3989).
+ *
+ * The standalone engine (`@phnx-labs/secrets-cli`, extracted from what used to
+ * be `cli/src/lib/secrets/**`) owns every one of these shapes; this module only
+ * re-declares them so `secrets-client.ts` and its consumers keep exact static
+ * types across the process-client boundary with no runtime dependency on the
+ * (now deleted) in-repo engine. Keep byte-for-byte in sync with
+ * `secrets-cli/src/schema.ts` / `src/core/bundles.ts` — this is the one seam
+ * both sides legitimately re-declare rather than share a package for (see the
+ * `secrets-client.ts` docblock).
+ */
+// --- bundle document ---------------------------------------------------
+export const SECRET_TYPES = [
+    'api-key',
+    'token',
+    'password',
+    'url',
+    'database-url',
+    'ssh-key',
+    'certificate',
+    'webhook',
+    'note',
+];

package/dist/lib/service-manifest.js

@@ -27,10 +27,9 @@
  * module is the single place both rules live, so a new manifest has one obvious
  * thing to call.
  *
- * It is not yet the only consumer of the identifier rule: `lib/secrets/agent.ts`
- * keeps a literal `SERVICE_LABEL` for its `bootout`. That path is retire-only —
- * it detects and removes a plist an older version installed and generates none
- * of its own — so it has no HOME to bake and was deliberately left alone.
+ * A third consumer that used to keep its own literal `SERVICE_LABEL` for a
+ * retire-only `bootout` — the in-repo secrets broker's launchd cleanup — moved
+ * out of this repo entirely with the standalone `secrets` engine (PHNX-3989).
  */
 import * as crypto from 'crypto';
 import * as os from 'os';

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
@@ -772,6 +817,22 @@ export declare function buildFtsQuery(input: string): {
  * so "higher = better" is consistent across all tiers.
  */
 export declare function ftsSearch(input: string, limit?: number): FtsHit[];
+/**
+ * Rewrite file_path for sessions whose path starts with any of `moves.from`,
+ * replacing that prefix with `moves.to` and clearing the matching scan_ledger
+ * entries so the next scan re-indexes from the new location.
+ *
+ * One transaction for the whole batch (PHNX-3940 T7): a migration that moves
+ * several homes into slots and several version dirs into trash must not leave
+ * the index half-rewritten. Longest `from` wins when prefixes nest, and each
+ * session row is rewritten at most once.
+ *
+ * Returns the number of session rows updated.
+ */
+export declare function reindexMovedSessionPaths(moves: ReadonlyArray<{
+    from: string;
+    to: string;
+}>): number;
 /**
  * Rewrite file_path for all sessions whose path starts with oldPrefix, replacing
  * it with newPrefix + the unchanged suffix. Also clears the matching scan_ledger
@@ -782,6 +843,8 @@ export declare function ftsSearch(input: string, limit?: number): FtsHit[];
  * Returns the number of session rows updated.
  */
 export declare function updateSessionFilePaths(oldPrefix: string, newPrefix: string): number;
+/** Count indexed sessions whose transcript path sits under `prefix`. */
+export declare function countSessionsWithFilePrefix(prefix: string): number;
 /** Per-kind capture tallies for a browser task. Counts only -- never the bytes. */
 interface BrowserCaptureCounts {
     screenshot: number;

package/dist/lib/session/db.js

@@ -22,13 +22,14 @@ import { extractBackgroundShells, extractSkills, extractSlashCommands, harnessTr
 import { resolveResource } from '../resources.js';
 import { discoverPlugins } from '../plugins/plugins.js';
 import { machineId } from '../machine-id.js';
-import { firstUserMessageFromEvents } from './prompt.js';
+import { firstUserMessageFromEvents, lastUserMessageFromEvents } from './prompt.js';
+import { emptyTimelineState, TIMELINE_EXTRACTOR_VERSION } from './timeline.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** 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 const SCHEMA_VERSION = 47;
+export 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
@@ -103,6 +104,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   git_branch TEXT,
   topic TEXT,
   first_user_message TEXT,
+  last_user_message TEXT,
   label TEXT,
   message_count INTEGER,
   token_count INTEGER,
@@ -420,6 +422,27 @@ CREATE TABLE IF NOT EXISTS session_summaries (
   summary_json TEXT NOT NULL
 );
 
+-- Daemon-computed narration-anchored timeline (PHNX-3939). Same lazy,
+-- stamp-validated cache shape as session_summaries, with one addition: the fold
+-- is INCREMENTAL, so the row carries both the bounded projection the display
+-- path reads and the resume state the pass folds the next appended bytes onto.
+--
+-- Two columns rather than one on purpose. projection_json is small and bounded
+-- (8 steps + counters + the tidied request + 8 file rows) and is what a session
+-- row merges on the read path; state_json holds the whole TimelineState (byte
+-- offset, open step, pending call ids, per-path file ledger) and is read ONLY by
+-- the daemon pass. Folding one blob would make every row merge parse the resume
+-- state it has no use for.
+CREATE TABLE IF NOT EXISTS session_timelines (
+  session_id TEXT PRIMARY KEY,
+  file_mtime_ms INTEGER,
+  file_size INTEGER,
+  extractor_version INTEGER NOT NULL,
+  computed_at INTEGER NOT NULL,
+  projection_json TEXT NOT NULL,
+  state_json TEXT NOT NULL
+);
+
 -- Durable metadata for one browser task (RUSH-2549). The browser daemon's
 -- tasks.json is LIVE state: saveTaskState writes the in-memory task map, so
 -- stopping a task drops its entry and a daemon restart empties the file. That is
@@ -1286,6 +1309,25 @@ function migrateSchema(db, fromVersion) {
         // The idx_sessions_mirror_synced index is created unconditionally after this
         // block (fresh DBs skip migrations), alongside idx_sessions_last_activity.
     }
+    if (fromVersion < 48) {
+        // v47 -> v48: retain the LATEST genuine user turn beside the first
+        // (PHNX-3939). For a /continue, a redirect, or an interrupted-and-restated
+        // session the operative request is the last thing the user said, and the row
+        // title / sidebar Request card show that.
+        //
+        // Deliberately WITHOUT a CONTENT_INDEX_VERSION bump, unlike the v45
+        // first_user_message column. That bump forces a re-parse of every indexed
+        // transcript on the next scan; measured on this fleet it pinned the daemon
+        // long enough to blow the session-index and session-state tick deadlines and
+        // park both services. It also buys nothing here: the value can only CHANGE
+        // when the transcript changes, so the ordinary incremental scan fills it in
+        // for exactly the sessions where it matters, and the sidebar's request comes
+        // from the daemon-folded `session_timelines` projection rather than this
+        // column. An old row simply keeps NULL until its next write.
+        const cols = new Set(db.prepare(`PRAGMA table_info(sessions)`).all().map((c) => c.name));
+        if (!cols.has('last_user_message'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN last_user_message TEXT`);
+    }
     if (fromVersion < 47) {
         // v46 -> v47: carry the actor's Phoenix id (PHNX-3798). Additive, write-once
         // launch metadata joined from the actor sidecar — never transcript-derived,
@@ -1842,7 +1884,7 @@ const upsertSessionStmt = (db) => db.prepare(`
   INSERT INTO sessions (
     id, short_id, agent, harness, origin, routine_name, routine_run_id,
     version, account, account_key, account_org, mode, timestamp, last_activity,
-    project, cwd, git_branch, topic, first_user_message, label, message_count, token_count,
+    project, cwd, git_branch, topic, first_user_message, last_user_message, label, message_count, token_count,
     output_tokens, input_tokens, cache_read_tokens, cache_write_tokens,
     cost_usd, cost_usd_nocache, duration_ms, model, tool_call_count,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
@@ -1853,7 +1895,7 @@ const upsertSessionStmt = (db) => db.prepare(`
   ) VALUES (
     @id, @short_id, @agent, @harness, @origin, @routine_name, @routine_run_id,
     @version, @account, @account_key, @account_org, @mode, @timestamp, @last_activity,
-    @project, @cwd, @git_branch, @topic, @first_user_message, @label, @message_count, @token_count,
+    @project, @cwd, @git_branch, @topic, @first_user_message, @last_user_message, @label, @message_count, @token_count,
     @output_tokens, @input_tokens, @cache_read_tokens, @cache_write_tokens,
     @cost_usd, @cost_usd_nocache, @duration_ms, @model, @tool_call_count,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
@@ -1891,6 +1933,10 @@ const upsertSessionStmt = (db) => db.prepare(`
     git_branch = excluded.git_branch,
     topic = excluded.topic,
     first_user_message = COALESCE(excluded.first_user_message, sessions.first_user_message),
+    -- Unlike the first turn, the LATEST one moves: a new turn must replace the
+    -- stored value, so this is excluded-wins with a COALESCE only to keep a
+    -- known value when a rescan cannot re-derive one.
+    last_user_message = COALESCE(excluded.last_user_message, sessions.last_user_message),
     -- Never let an empty/placeholder incoming label clobber a good stored one.
     -- A real incoming label (non-empty after trim) still wins; a blank one keeps
     -- the label seeded by --name (seedLabelsFromNames) or refined by an agent
@@ -2110,6 +2156,7 @@ function enrichMetaFromEvents(meta, events) {
     return {
         ...meta,
         firstUserMessage: meta.firstUserMessage ?? firstUserMessageFromEvents(events),
+        lastUserMessage: meta.lastUserMessage ?? lastUserMessageFromEvents(events),
         todos: extractTodoProgressFromEvents(events),
         recentDirectoriesTouched: extractRecentDirectoriesTouched(events, meta.cwd),
         ...fanOutCounts(events, meta.agent),
@@ -2201,6 +2248,7 @@ export function upsertSession(meta, content, scan, assistantContent = '') {
         git_branch: meta.gitBranch ?? null,
         topic: meta.topic ?? null,
         first_user_message: meta.firstUserMessage ?? null,
+        last_user_message: meta.lastUserMessage ?? null,
         label: meta.label ?? null,
         message_count: meta.messageCount ?? null,
         token_count: meta.tokenCount ?? null,
@@ -2441,6 +2489,7 @@ export function upsertSessionsBatch(entries) {
                     git_branch: meta.gitBranch ?? null,
                     topic: meta.topic ?? null,
                     first_user_message: meta.firstUserMessage ?? null,
+                    last_user_message: meta.lastUserMessage ?? null,
                     label: meta.label ?? null,
                     message_count: meta.messageCount ?? null,
                     token_count: meta.tokenCount ?? null,
@@ -2690,6 +2739,7 @@ function rowToMeta(row) {
         mode: isSessionRunMode(row.mode) ? row.mode : undefined,
         topic: row.topic ?? undefined,
         firstUserMessage: row.first_user_message ?? undefined,
+        lastUserMessage: row.last_user_message ?? undefined,
         label: row.label ?? undefined,
         isTeamOrigin: row.is_team_origin === 1,
         prUrl: row.pr_url ?? undefined,
@@ -3417,6 +3467,68 @@ export function writeSessionSummary(entry) {
       summary_json = excluded.summary_json
   `).run(entry.id, entry.fileMtimeMs, entry.fileSize, SESSION_SUMMARY_EXTRACTOR_VERSION, Date.now(), JSON.stringify(entry.summary));
 }
+function parseTimelineProjection(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 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 function readSessionTimelineEntry(id) {
+    const row = getDB().prepare(`
+    SELECT projection_json AS projectionJson, state_json AS stateJson, computed_at AS computedAt
+    FROM session_timelines
+    WHERE session_id = ? AND extractor_version = ?
+  `).get(id, TIMELINE_EXTRACTOR_VERSION);
+    if (!row)
+        return undefined;
+    const projection = parseTimelineProjection(row.projectionJson);
+    if (!projection)
+        return undefined;
+    try {
+        return { ...projection, state: JSON.parse(row.stateJson), computedAt: row.computedAt };
+    }
+    catch {
+        return 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 function readSessionTimelineAny(id) {
+    const row = getDB().prepare(`
+    SELECT projection_json AS projectionJson
+    FROM session_timelines
+    WHERE session_id = ? AND extractor_version = ?
+  `).get(id, TIMELINE_EXTRACTOR_VERSION);
+    if (!row)
+        return undefined;
+    return parseTimelineProjection(row.projectionJson);
+}
+/** Persist a folded timeline against the exact transcript bytes it was folded to. */
+export function writeSessionTimeline(entry) {
+    const { state, ...projection } = entry.timeline;
+    getDB().prepare(`
+    INSERT INTO session_timelines
+      (session_id, file_mtime_ms, file_size, extractor_version, computed_at, projection_json, state_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(session_id) DO UPDATE SET
+      file_mtime_ms = excluded.file_mtime_ms,
+      file_size = excluded.file_size,
+      extractor_version = excluded.extractor_version,
+      computed_at = excluded.computed_at,
+      projection_json = excluded.projection_json,
+      state_json = excluded.state_json
+  `).run(entry.id, entry.fileMtimeMs, entry.fileSize, TIMELINE_EXTRACTOR_VERSION, entry.computedAtMs ?? Date.now(), JSON.stringify(projection), JSON.stringify(state));
+}
 /**
  * The most-recently-active sessions whose transcript is genuinely local to this
  * box — a real `file_path`, not a peer mirror — for publishing to the fleet
@@ -3444,6 +3556,7 @@ export function queryLocalOriginSessionsForMirror(self, limit) {
         // Ride the daemon-computed summary alongside the digest so a peer renders it
         // without a transcript (PHNX-3939); only a summarized session carries one.
         summary: readSessionSummaryAny(r.id) ?? null,
+        timeline: readSessionTimelineAny(r.id) ?? null,
     }));
 }
 /**
@@ -3525,6 +3638,18 @@ export function upsertMirrorSession(row, source, syncedAt) {
     if (row.summary) {
         writeSessionSummary({ id: row.id, fileMtimeMs: null, fileSize: null, summary: row.summary });
     }
+    // Same for the peer's folded timeline (PHNX-3939): the projection is what a row
+    // renders, and the resume state is deliberately EMPTY — this box never folds a
+    // peer's transcript (it does not have one), so storing a foreign byte offset
+    // would be a resume point into a file that is not here.
+    if (row.timeline) {
+        writeSessionTimeline({
+            id: row.id,
+            fileMtimeMs: null,
+            fileSize: null,
+            timeline: { ...row.timeline, state: emptyTimelineState() },
+        });
+    }
     return true;
 }
 /**
@@ -3542,12 +3667,14 @@ export function pruneMirrorSessions(cutoffMs) {
     const delText = db.prepare(`DELETE FROM session_text WHERE session_id = ?`);
     const delPreview = db.prepare(`DELETE FROM session_preview_cache WHERE session_id = ?`);
     const delSummary = db.prepare(`DELETE FROM session_summaries WHERE session_id = ?`);
+    const delTimeline = db.prepare(`DELETE FROM session_timelines WHERE session_id = ?`);
     const txn = db.transaction(() => {
         for (const { id } of stale) {
             delRow.run(id);
             delText.run(id);
             delPreview.run(id);
             delSummary.run(id);
+            delTimeline.run(id);
         }
     });
     txn();
@@ -4190,6 +4317,44 @@ export function ftsSearch(input, limit = 200) {
     hits.sort((a, b) => b.score - a.score);
     return hits.slice(0, limit);
 }
+/**
+ * Rewrite file_path for sessions whose path starts with any of `moves.from`,
+ * replacing that prefix with `moves.to` and clearing the matching scan_ledger
+ * entries so the next scan re-indexes from the new location.
+ *
+ * One transaction for the whole batch (PHNX-3940 T7): a migration that moves
+ * several homes into slots and several version dirs into trash must not leave
+ * the index half-rewritten. Longest `from` wins when prefixes nest, and each
+ * session row is rewritten at most once.
+ *
+ * Returns the number of session rows updated.
+ */
+export function reindexMovedSessionPaths(moves) {
+    const usable = moves.filter((m) => m.from && m.from !== m.to);
+    if (usable.length === 0)
+        return 0;
+    const db = getDB();
+    const sorted = [...usable].sort((a, b) => b.from.length - a.from.length);
+    return db.transaction(() => {
+        let n = 0;
+        const seen = new Set();
+        const update = db.prepare(`UPDATE sessions SET file_path = ? WHERE id = ?`);
+        const dropLedger = db.prepare(`DELETE FROM scan_ledger WHERE file_path = ?`);
+        const select = db.prepare(`SELECT id, file_path FROM sessions WHERE file_path LIKE ?`);
+        for (const { from, to } of sorted) {
+            const rows = select.all(from + '%');
+            for (const { id, file_path } of rows) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                update.run(to + file_path.slice(from.length), id);
+                dropLedger.run(canonicalLedgerKey(file_path));
+                n++;
+            }
+        }
+        return n;
+    })();
+}
 /**
  * Rewrite file_path for all sessions whose path starts with oldPrefix, replacing
  * it with newPrefix + the unchanged suffix. Also clears the matching scan_ledger
@@ -4200,21 +4365,16 @@ export function ftsSearch(input, limit = 200) {
  * Returns the number of session rows updated.
  */
 export function updateSessionFilePaths(oldPrefix, newPrefix) {
-    const db = getDB();
-    const rows = db
-        .prepare(`SELECT id, file_path FROM sessions WHERE file_path LIKE ?`)
-        .all(oldPrefix + '%');
-    if (rows.length === 0)
+    return reindexMovedSessionPaths([{ from: oldPrefix, to: newPrefix }]);
+}
+/** Count indexed sessions whose transcript path sits under `prefix`. */
+export function countSessionsWithFilePrefix(prefix) {
+    if (!prefix)
         return 0;
-    const txn = db.transaction(() => {
-        for (const { id, file_path } of rows) {
-            const newPath = newPrefix + file_path.slice(oldPrefix.length);
-            db.prepare(`UPDATE sessions SET file_path = ? WHERE id = ?`).run(newPath, id);
-            db.prepare(`DELETE FROM scan_ledger WHERE file_path = ?`).run(canonicalLedgerKey(file_path));
-        }
-    });
-    txn();
-    return rows.length;
+    const row = getDB()
+        .prepare(`SELECT COUNT(*) AS c FROM sessions WHERE file_path LIKE ?`)
+        .get(prefix + '%');
+    return row.c;
 }
 /**
  * Upsert one browser task's durable metadata.

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

@@ -26,6 +26,11 @@ export declare const SESSION_MIRROR_MAX_ROWS = 200;
 export declare const SESSION_MIRROR_SNIPPET_MAX = 280;
 /** Mirror rows older than this since their last sync are pruned (staleness/size ceiling). */
 export declare const SESSION_MIRROR_MAX_AGE_MS: number;
+/** Caps for the timeline block on a published mirror row. */
+export declare const SESSION_MIRROR_MAX_STEPS = 8;
+export declare const SESSION_MIRROR_STEP_TEXT_MAX = 160;
+export declare const SESSION_MIRROR_REQUEST_MAX = 2000;
+export declare const SESSION_MIRROR_MAX_FILES = 8;
 export interface PublishSessionMirrorOptions {
     userAgentsDir?: string;
     device?: string;