@phnx-labs/agents-cli 1.22.35 → 1.22.38

package/dist/lib/session/db.js

@@ -16,17 +16,18 @@ import { query as queryEvents, queryToolUsageForSessions } from '../events.js';
 import { machineForSessionFile } from './origin-machine.js';
 import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
 import { toolCallsFromEvents } from './tool-calls.js';
-import { persistToolCalls, purgeToolCalls, toolEvidenceSourcePath } from './tool-store.js';
+import { persistToolCalls, toolEvidenceSourcePath } from './tool-store.js';
 import { buildClaudeAccountIndex, resolveClaudeAccount } from './claude-accounts.js';
 import { extractSkills, extractSlashCommands } from './highlights.js';
 import { resolveResource } from '../resources.js';
 import { discoverPlugins } from '../plugins.js';
+import { machineId } from '../machine-id.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/05-sessions.md calls the constant the source of truth). */
-export const SCHEMA_VERSION = 37;
+ * then has to chase (docs/sessions.md calls the constant the source of truth). */
+export const SCHEMA_VERSION = 39;
 /**
  * Bump to force `agents sessions backfill resources` to re-derive every
  * session's skill/slash-command tallies on its next run (resource_scan_ledger
@@ -108,7 +109,14 @@ CREATE TABLE IF NOT EXISTS sessions (
   actor TEXT,
   initiated_by TEXT,
   used_browser INTEGER,
-  used_computer INTEGER
+  used_computer INTEGER,
+  -- Epoch ms of the first time a previously-scanned transcript was confirmed
+  -- gone from disk while its user-turn content still lives in session_text
+  -- (RUSH-2436). Non-NULL means "archived": the row is served/rendered from the
+  -- DB and flagged, instead of being dropped when the file vanishes. A row whose
+  -- file is missing but which has NO cached content is a phantom (a stale/moved
+  -- file_path), never stamped, still suppressed — see querySessions.
+  archived_at INTEGER
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
@@ -317,6 +325,69 @@ CREATE TABLE IF NOT EXISTS session_preview_cache (
   computed_at INTEGER NOT NULL,
   preview_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
+-- correct for live state and useless as history, which is why every finished task
+-- listed as "unlinked". This row is written once at task start and is never
+-- deleted, so the link from a capture back to the agent session that drove it
+-- survives the task, the daemon, and a reboot.
+--
+-- METADATA ONLY: capture bytes are never stored here. capture_dir points at the
+-- on-disk directory (.cache/browser/<profile>/sessions/<task>/) that already holds
+-- them, and the per-kind counts are what a listing needs to render a row without
+-- walking that tree. captures_remote is set only when the optional offload has
+-- copied them through the existing encrypted r2.backups sync.
+--
+-- session_id is the agent session (AGENT_SESSION_ID, which every agent carries);
+-- launch_id stays as the secondary join key for a caller that has only that. actor
+-- is the HUMAN/tailnet identity and is deliberately NOT an agent id -- resolveActor
+-- answers UNRESOLVED@<host> for any local run by design (lib/actor.ts).
+CREATE TABLE IF NOT EXISTS browser_sessions (
+  task TEXT NOT NULL,
+  profile TEXT NOT NULL,
+  session_id TEXT,
+  launch_id TEXT,
+  actor TEXT,
+  machine TEXT NOT NULL,
+  started_at INTEGER NOT NULL,
+  last_activity INTEGER,
+  screenshot_count INTEGER NOT NULL DEFAULT 0,
+  pdf_count INTEGER NOT NULL DEFAULT 0,
+  recording_count INTEGER NOT NULL DEFAULT 0,
+  download_count INTEGER NOT NULL DEFAULT 0,
+  capture_dir TEXT,
+  captures_remote TEXT,
+  PRIMARY KEY (profile, task)
+);
+CREATE INDEX IF NOT EXISTS idx_browser_sessions_session ON browser_sessions(session_id);
+CREATE INDEX IF NOT EXISTS idx_browser_sessions_started ON browser_sessions(started_at DESC);
+
+-- Durable metadata for one "agents computer" invocation (RUSH-2549). Computer-use
+-- already resolves identity correctly -- stampProvenance stamps AGENT_SESSION_ID
+-- straight onto each computer.action event -- but those events live in the bounded
+-- audit ledger, which prunes at 7 days / 50 MiB (events.ts). So a run's history
+-- silently vanished on day 8. This row carries the same identity into the durable
+-- store; the ledger is untouched and remains the audit log, with no second pruner.
+--
+-- Keyed on invocation_id, the id emitComputerAction stamps once per emitting CLI
+-- process: one explicit verb is one row, and a whole "computer run" observe/act
+-- loop is also one row. task_preview is already bounded by events.ts truncate()
+-- before it is ever written, and typed-text content is never captured at all.
+CREATE TABLE IF NOT EXISTS computer_sessions (
+  invocation_id TEXT PRIMARY KEY,
+  session_id TEXT,
+  launch_id TEXT,
+  actor TEXT,
+  machine TEXT NOT NULL,
+  started_at INTEGER NOT NULL,
+  last_activity INTEGER,
+  action_count INTEGER NOT NULL DEFAULT 0,
+  task_preview TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_computer_sessions_session ON computer_sessions(session_id);
+CREATE INDEX IF NOT EXISTS idx_computer_sessions_started ON computer_sessions(started_at DESC);
 `;
 /**
  * Bumping this invalidates every cached facet row without touching the schema
@@ -912,6 +983,60 @@ function migrateSchema(db, fromVersion) {
         if (!cols.has('cost_usd_nocache'))
             db.exec(`ALTER TABLE sessions ADD COLUMN cost_usd_nocache REAL`);
     }
+    if (fromVersion < 38) {
+        // v37 -> v38: archived_at (RUSH-2436). Makes the local DB authoritative for
+        // content: a session whose transcript file is gone but whose user turns still
+        // live in session_text is kept (flagged archived) instead of dropped from
+        // listings. New nullable column, so no ledger flush — it is populated lazily
+        // by querySessions the first time it confirms a scanned file is gone.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some((c) => c.name === 'archived_at'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN archived_at INTEGER`);
+    }
+    if (fromVersion < 39) {
+        // v38 -> v39: durable tool-session metadata (RUSH-2549). Browser task identity
+        // lived only in the daemon's tasks.json, which is rewritten from the live task
+        // map -- so stopping a task erased the link to the agent session that drove it
+        // and every finished task listed as "unlinked". Computer-use had the identity
+        // right but wrote it to the 7-day event ledger, so its history expired instead.
+        // Both now persist metadata here. Pure additions, so no ledger flush: nothing
+        // already indexed is invalidated, and the tables populate going forward.
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS browser_sessions (
+        task TEXT NOT NULL,
+        profile TEXT NOT NULL,
+        session_id TEXT,
+        launch_id TEXT,
+        actor TEXT,
+        machine TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        last_activity INTEGER,
+        screenshot_count INTEGER NOT NULL DEFAULT 0,
+        pdf_count INTEGER NOT NULL DEFAULT 0,
+        recording_count INTEGER NOT NULL DEFAULT 0,
+        download_count INTEGER NOT NULL DEFAULT 0,
+        capture_dir TEXT,
+        captures_remote TEXT,
+        PRIMARY KEY (profile, task)
+      );
+      CREATE INDEX IF NOT EXISTS idx_browser_sessions_session ON browser_sessions(session_id);
+      CREATE INDEX IF NOT EXISTS idx_browser_sessions_started ON browser_sessions(started_at DESC);
+
+      CREATE TABLE IF NOT EXISTS computer_sessions (
+        invocation_id TEXT PRIMARY KEY,
+        session_id TEXT,
+        launch_id TEXT,
+        actor TEXT,
+        machine TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        last_activity INTEGER,
+        action_count INTEGER NOT NULL DEFAULT 0,
+        task_preview TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_computer_sessions_session ON computer_sessions(session_id);
+      CREATE INDEX IF NOT EXISTS idx_computer_sessions_started ON computer_sessions(started_at DESC);
+    `);
+    }
 }
 /**
  * Stamp `account_key` / `account_org` / `account` on every Claude row from its
@@ -2134,6 +2259,11 @@ function rowToMeta(row) {
         // instead of trusting a false "never used browser/computer".
         usedBrowser: row.used_browser === null ? undefined : row.used_browser === 1,
         usedComputer: row.used_computer === null ? undefined : row.used_computer === 1,
+        // A stamped archived_at means the transcript file is gone but the session's
+        // user turns still live in session_text — the row is served from the DB and
+        // flagged, never dropped (RUSH-2436). NULL leaves both undefined (live row).
+        archivedAt: row.archived_at ?? undefined,
+        archived: row.archived_at != null ? true : undefined,
     };
 }
 function isSessionRunMode(value) {
@@ -2399,23 +2529,61 @@ export function querySessions(options = {}) {
         const trimmed = options.limit ? rows.slice(0, options.limit) : rows;
         return trimmed.map(rowToMeta);
     }
-    // Belt-and-suspenders: drop rows whose JSONL no longer exists on disk. The
-    // authoritative fix is to keep file_path in sync (see updateSessionFilePaths
-    // callers), but skipping vanished rows here prevents phantom sessions from
-    // surfacing in the Factory UI if any code path forgets to rewrite (#136).
-    // Synthetic rows (OpenClaw channels/cron — see scanOpenClawIncremental) carry
-    // an empty file_path and are exempt; they're keyed by CLI output, not files.
+    // A row whose transcript file is gone from disk is one of two things, and the
+    // local DB is now authoritative for telling them apart (RUSH-2436):
+    //   - ARCHIVED — its user turns still live in session_text. The session is
+    //     real; the file was just removed (agents remove trash, a manual rm, a
+    //     .history rotation, a box reimage). Keep it, stamped `archived`, so it
+    //     still lists and renders from the DB instead of silently vanishing.
+    //   - PHANTOM — a stale/moved file_path with NO cached content (#136), e.g. a
+    //     path a scan forgot to rewrite. There is nothing durable to serve, so it
+    //     stays suppressed exactly as before.
+    // We NO LONGER purge tool-call evidence here: merely listing a file-gone
+    // session used to DELETE its redacted tool calls (purgeToolCalls), destroying
+    // durable data on a read. Synthetic rows (OpenClaw channels/cron — see
+    // scanOpenClawIncremental) carry an empty file_path and are exempt.
     const missingPaths = findMissingFilePaths(rows.map(r => r.file_path).filter((p) => !!p));
     const missing = rows.filter(r => r.file_path && missingPaths.has(r.file_path));
+    const missingIds = new Set(missing.map(r => r.id));
+    const phantomIds = new Set();
     if (missing.length > 0) {
-        const purge = db.transaction(() => {
-            for (const row of missing)
-                purgeToolCalls(db, row.id);
+        const readContent = db.prepare(`SELECT content FROM session_text WHERE session_id = ?`);
+        const markArchived = db.prepare(`UPDATE sessions SET archived_at = ? WHERE id = ? AND archived_at IS NULL`);
+        const now = Date.now();
+        const classify = db.transaction(() => {
+            for (const row of missing) {
+                const content = readContent.get(row.id)?.content;
+                if (content && content.trim() !== '') {
+                    // Genuine archived session: stamp archived_at the first time we confirm
+                    // the file is gone, and reflect it on the in-memory row we return.
+                    if (row.archived_at == null) {
+                        markArchived.run(now, row.id);
+                        row.archived_at = now;
+                    }
+                }
+                else {
+                    phantomIds.add(row.id);
+                }
+            }
         });
-        purge();
+        classify();
+    }
+    // Un-archive a row whose file came back (a recoverable-trash restore, a re-sync):
+    // it is present on disk now, so it must not keep reporting `archived` to a
+    // machine consumer reading the --json listing. Rare, so the write only fires when
+    // such a row actually exists (RUSH-2436).
+    const resurrected = rows.filter(r => r.archived_at != null && !missingIds.has(r.id));
+    if (resurrected.length > 0) {
+        const clearArchived = db.prepare(`UPDATE sessions SET archived_at = NULL WHERE id = ?`);
+        const clear = db.transaction(() => {
+            for (const row of resurrected) {
+                clearArchived.run(row.id);
+                row.archived_at = null;
+            }
+        });
+        clear();
     }
-    const missingIds = new Set(missing.map((row) => row.id));
-    const live = rows.filter(r => !r.file_path || !missingIds.has(r.id));
+    const live = rows.filter(r => !phantomIds.has(r.id));
     const trimmed = options.limit ? live.slice(0, options.limit) : live;
     return trimmed.map(rowToMeta);
 }
@@ -2534,6 +2702,47 @@ export function writeSessionPreviewCache(entry) {
       preview_json = excluded.preview_json
   `).run(entry.id, entry.fileMtimeMs, entry.fileSize, PREVIEW_EXTRACTOR_VERSION, Date.now(), JSON.stringify(entry.preview));
 }
+/**
+ * The session's durable user-turn text, as stored in the `session_text` FTS
+ * `content` column at scan time (all harnesses, keyed by session_id). This is
+ * the content that survives the transcript file being deleted (RUSH-2436): the
+ * render path reads it so a file-gone session still shows its user prompts, and
+ * querySessions uses its presence to tell a genuine archived session (has
+ * content) from a phantom (a stale/moved file_path with none). Returns undefined
+ * when no row exists; an empty string when a row exists but carried no content.
+ */
+export function readSessionContent(id) {
+    const row = getDB().prepare(`SELECT content FROM session_text WHERE session_id = ?`).get(id);
+    return row?.content;
+}
+/**
+ * Read the last-computed preview digest for a session by id, validated against
+ * the session row's OWN stored file stamp rather than a live `fs.stat` — the
+ * transcript file is gone, so there is nothing on disk to stat, but the preview
+ * cache was written with the same `file_mtime_ms`/`file_size` the sessions row
+ * still records, so the join re-establishes that stamp. Backs the file-gone
+ * render/preview path (RUSH-2436). Returns undefined when no cached digest
+ * survives for this session.
+ */
+export function readArchivedSessionPreview(id) {
+    const row = getDB().prepare(`
+    SELECT pc.preview_json AS previewJson
+    FROM session_preview_cache pc
+    JOIN sessions s ON s.id = pc.session_id
+    WHERE pc.session_id = ?
+      AND pc.extractor_version = ?
+      AND pc.file_mtime_ms IS s.file_mtime_ms
+      AND pc.file_size IS s.file_size
+  `).get(id, PREVIEW_EXTRACTOR_VERSION);
+    if (!row)
+        return undefined;
+    try {
+        return JSON.parse(row.previewJson);
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Plugin provenance already indexed for resources used by one session. */
 export function getSessionPlugins(id) {
     const rows = getDB().prepare(`
@@ -2862,7 +3071,38 @@ export function topSessionsByCost(n, options = {}) {
     // Over-fetch a small buffer to survive the on-disk liveness filter below.
     const sql = `SELECT * FROM sessions ${whereCost} ORDER BY cost_usd DESC, timestamp DESC LIMIT ${limit + 16}`;
     const rows = db.prepare(sql).all(...params);
-    const live = rows.filter(r => !r.file_path || fs.existsSync(sessionFilePathContainer(r.file_path)));
+    // Keep a row whose file is present OR whose transcript is already archived
+    // (file gone but user turns still in session_text) — an expensive, real
+    // session must not drop out of the cost rollup just because its file was
+    // removed (RUSH-2436). A file-gone row with no durable content (a phantom) is
+    // still excluded. archived_at is the persisted signal; stamp it here too (once)
+    // so a session first surfaced through the cost rollup reports `archived`
+    // consistently with the listing path.
+    const readContent = db.prepare(`SELECT content FROM session_text WHERE session_id = ?`);
+    const markArchived = db.prepare(`UPDATE sessions SET archived_at = ? WHERE id = ? AND archived_at IS NULL`);
+    const now = Date.now();
+    const toStamp = [];
+    const live = rows.filter(r => {
+        if (!r.file_path || fs.existsSync(sessionFilePathContainer(r.file_path)))
+            return true;
+        if (r.archived_at != null)
+            return true;
+        const content = readContent.get(r.id)?.content;
+        if (!!content && content.trim() !== '') {
+            toStamp.push(r);
+            return true;
+        }
+        return false;
+    });
+    if (toStamp.length > 0) {
+        const stamp = db.transaction(() => {
+            for (const r of toStamp) {
+                markArchived.run(now, r.id);
+                r.archived_at = now;
+            }
+        });
+        stamp();
+    }
     return live.slice(0, limit).map(r => ({
         meta: rowToMeta(r),
         costUsd: r.cost_usd ?? 0,
@@ -2870,6 +3110,39 @@ export function topSessionsByCost(n, options = {}) {
     }));
 }
 /** Look up a single session by its unique ID. */
+/**
+ * Batch-resolve session ids to the machine each one runs on, in ONE indexed
+ * query. `getActiveSessions` needs only this column for every live row, and
+ * `getSessionById` would re-`prepare` a `SELECT *` and materialize a full
+ * `SessionMeta` per id to read it — mirrors {@link findSessionsByShortIds}'s
+ * single-round-trip pattern. Ids absent from the index are simply absent from
+ * the map. Best-effort: an unavailable DB yields an empty map, so the live view
+ * still renders (the caller then leaves rows attributed to this box).
+ */
+export function findSessionMachinesByIds(ids) {
+    const out = new Map();
+    const uniq = [...new Set(ids.filter(Boolean))];
+    if (uniq.length === 0)
+        return out;
+    try {
+        const db = getDB();
+        const CHUNK = 500; // stay well under SQLite's default 999-variable limit
+        for (let i = 0; i < uniq.length; i += CHUNK) {
+            const batch = uniq.slice(i, i + CHUNK);
+            const placeholders = batch.map(() => '?').join(',');
+            const rows = db
+                .prepare(`SELECT id, machine FROM sessions WHERE id IN (${placeholders})`)
+                .all(...batch);
+            for (const r of rows)
+                if (r.machine)
+                    out.set(r.id, r.machine);
+        }
+    }
+    catch {
+        /* index read is best-effort — an unavailable DB leaves rows un-attributed */
+    }
+    return out;
+}
 export function getSessionById(id) {
     const db = getDB();
     const row = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
@@ -2882,6 +3155,12 @@ export function getSessionById(id) {
  * short id. An exact hit short-circuits so a complete id never also drags in its
  * prefix siblings. `scope` narrows by agent / version / project (cwd) so an
  * ambiguous prefix disambiguates against the caller's context.
+ *
+ * Routes through the full querySessions existence check (NOT skipExistenceCheck)
+ * on purpose (RUSH-2436): that check now KEEPS a file-gone session whose user
+ * turns still live in session_text (flagged archived) and only suppresses a
+ * contentless phantom — so `agents sessions <id>` resolves an archived session
+ * instead of failing with "No session found", while a phantom id still misses.
  */
 export function findSessionsById(idQuery, scope = {}) {
     const q = idQuery.trim();
@@ -3100,3 +3379,191 @@ export function updateSessionFilePaths(oldPrefix, newPrefix) {
     txn();
     return rows.length;
 }
+/**
+ * Upsert one browser task's durable metadata.
+ *
+ * Called at task START. This executes INSIDE the browser daemon (daemon.ts
+ * constructs BrowserService; ipc.ts dispatches `start` to it), which makes the
+ * shared daemon a writer of this DB — but the identity it writes is RESOLVED IN
+ * THE CALLING CLI PROCESS and forwarded over IPC, never resolved here. That
+ * distinction is the whole fix: resolving it daemon-side would attribute every
+ * task to the daemon's own actor (the RUSH-2020 bug).
+ *
+ * `agents browser stop` deliberately does NOT delete this row: the whole point
+ * is that the link outlives the task.
+ *
+ * Identity fields are only ever widened, never blanked. A later capture-count
+ * update carries no session id, and `COALESCE(excluded.…, browser_sessions.…)`
+ * keeps the one recorded at start rather than overwriting it with NULL --
+ * otherwise the second write would undo exactly what the first was for.
+ */
+export function recordBrowserSession(record) {
+    const db = getDB();
+    const now = Date.now();
+    db.prepare(`
+    INSERT INTO browser_sessions (
+      task, profile, session_id, launch_id, actor, machine,
+      started_at, last_activity,
+      screenshot_count, pdf_count, recording_count, download_count,
+      capture_dir, captures_remote
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(profile, task) DO UPDATE SET
+      session_id       = COALESCE(excluded.session_id, browser_sessions.session_id),
+      launch_id        = COALESCE(excluded.launch_id, browser_sessions.launch_id),
+      actor            = COALESCE(excluded.actor, browser_sessions.actor),
+      last_activity    = excluded.last_activity,
+      screenshot_count = excluded.screenshot_count,
+      pdf_count        = excluded.pdf_count,
+      recording_count  = excluded.recording_count,
+      download_count   = excluded.download_count,
+      capture_dir      = COALESCE(excluded.capture_dir, browser_sessions.capture_dir),
+      captures_remote  = COALESCE(excluded.captures_remote, browser_sessions.captures_remote)
+  `).run(record.task, record.profile, record.sessionId ?? null, record.launchId ?? null, record.actor ?? null, record.machine ?? machineId(), record.startedAt ?? now, record.lastActivity ?? now, record.counts?.screenshot ?? 0, record.counts?.pdf ?? 0, record.counts?.recording ?? 0, record.counts?.download ?? 0, record.captureDir ?? null, record.capturesRemote ?? null);
+}
+/**
+ * Upsert one computer-use invocation's durable metadata.
+ *
+ * `action_count` accumulates: a `computer run` loop emits many actions under one
+ * invocation id, and each arrives as its own call, so the count is incremented
+ * rather than replaced. Identity is widened-only, for the same reason as above.
+ */
+export function recordComputerSession(record) {
+    const db = getDB();
+    const now = Date.now();
+    db.prepare(`
+    INSERT INTO computer_sessions (
+      invocation_id, session_id, launch_id, actor, machine,
+      started_at, last_activity, action_count, task_preview
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(invocation_id) DO UPDATE SET
+      session_id    = COALESCE(excluded.session_id, computer_sessions.session_id),
+      launch_id     = COALESCE(excluded.launch_id, computer_sessions.launch_id),
+      actor         = COALESCE(excluded.actor, computer_sessions.actor),
+      last_activity = excluded.last_activity,
+      action_count  = computer_sessions.action_count + excluded.action_count,
+      task_preview  = COALESCE(excluded.task_preview, computer_sessions.task_preview)
+  `).run(record.invocationId, record.sessionId ?? null, record.launchId ?? null, record.actor ?? null, record.machine ?? machineId(), record.startedAt ?? now, record.lastActivity ?? now, record.actionCount ?? 1, record.taskPreview ?? null);
+}
+function toStoredBrowserSession(row) {
+    return {
+        task: row.task,
+        profile: row.profile,
+        sessionId: row.session_id ?? undefined,
+        launchId: row.launch_id ?? undefined,
+        actor: row.actor ?? undefined,
+        machine: row.machine,
+        startedAt: row.started_at,
+        lastActivity: row.last_activity ?? undefined,
+        counts: {
+            screenshot: row.screenshot_count,
+            pdf: row.pdf_count,
+            recording: row.recording_count,
+            download: row.download_count,
+        },
+        captureDir: row.capture_dir ?? undefined,
+        capturesRemote: row.captures_remote ?? undefined,
+    };
+}
+/**
+ * Stored browser tasks, newest first; optionally scoped to one profile.
+ *
+ * A PROFILE-SCOPED read is deliberately unbounded. These rows are the identity
+ * for capture dirs that still exist on disk, and dropping the oldest ones would
+ * silently regress exactly those tasks to `unlinked` — the symptom this whole
+ * change removes, reappearing at a higher threshold. The row count is already
+ * bounded by the tasks that profile has ever run, and each row is a short
+ * metadata record. Only the unscoped read (every profile, used for overviews)
+ * takes a ceiling, since that one has no natural bound.
+ */
+export function listBrowserSessionRecords(profile, opts = {}) {
+    const db = getDB();
+    const rows = (profile
+        ? db.prepare(`SELECT * FROM browser_sessions WHERE profile = ? ORDER BY started_at DESC`).all(profile)
+        : db.prepare(`SELECT * FROM browser_sessions ORDER BY started_at DESC LIMIT ?`)
+            .all(opts.limit ?? TOOL_SESSION_LIST_LIMIT));
+    return rows.map(toStoredBrowserSession);
+}
+/** One stored browser task by its (profile, task) key, or null. */
+export function getBrowserSessionRecord(profile, task) {
+    const db = getDB();
+    const row = db
+        .prepare(`SELECT * FROM browser_sessions WHERE profile = ? AND task = ?`)
+        .get(profile, task);
+    return row ? toStoredBrowserSession(row) : null;
+}
+/**
+ * Retention for the tool-session tables.
+ *
+ * These are the durable answer to a ledger that prunes at 7 days, so they are
+ * deliberately long-lived — but "durable" is not "unbounded". `computer_sessions`
+ * takes one row per `agents computer` CLI PROCESS (`COMPUTER_INVOCATION_ID` is
+ * minted per process), and an agent driving a desktop invokes that hundreds of
+ * times a day, so an unbounded table would grow without limit and be read in
+ * full on every listing.
+ */
+export const TOOL_SESSION_MAX_AGE_DAYS = 365;
+/** Default ceiling on rows one listing will read. */
+export const TOOL_SESSION_LIST_LIMIT = 2000;
+/**
+ * Drop tool-session rows past {@link TOOL_SESSION_MAX_AGE_DAYS}.
+ *
+ * Called from the listing path, never from the write hot path: an
+ * `agents computer` action must not pay for a table sweep (see the fail-soft
+ * note on `recordComputerSession`'s caller). Returns rows deleted.
+ */
+export function pruneToolSessions(maxAgeDays = TOOL_SESSION_MAX_AGE_DAYS) {
+    const db = getDB();
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    // Cheap indexed guard first, so the common case is one lookup rather than a
+    // write transaction (the same shape as the account repair below). Every
+    // listing calls this, and on any table younger than the retention window
+    // there is nothing to delete — but a bare DELETE still opens a write
+    // transaction, which under `busy_timeout = 30000` can make a read-only
+    // listing wait on the session indexer for no reason at all.
+    const stale = db.prepare(`
+    SELECT 1 FROM computer_sessions WHERE started_at < ?
+    UNION ALL
+    SELECT 1 FROM browser_sessions WHERE started_at < ?
+    LIMIT 1
+  `).get(cutoff, cutoff);
+    if (!stale)
+        return 0;
+    const computer = db.prepare(`DELETE FROM computer_sessions WHERE started_at < ?`).run(cutoff);
+    const browser = db.prepare(`DELETE FROM browser_sessions WHERE started_at < ?`).run(cutoff);
+    return Number(computer.changes ?? 0) + Number(browser.changes ?? 0);
+}
+/**
+ * Stored computer-use invocations, newest first, bounded.
+ *
+ * The limit is a real ceiling, not a nicety: `--json` serializes whatever this
+ * returns, so an unbounded read would dump the entire table on every call.
+ */
+export function listComputerSessionRecords(opts = {}) {
+    const db = getDB();
+    const limit = opts.limit ?? TOOL_SESSION_LIST_LIMIT;
+    // `startedBeforeMs` selects the COMPLEMENT of the caller's other source
+    // rather than the newest N. The caller that recovers pruned runs already
+    // holds every recent invocation from the event ledger and discards any row
+    // it has seen — so a bare newest-N read hands it 2000 rows it is guaranteed
+    // to throw away, and returns nothing at all once the table passes that size.
+    // Bounding by "older than the ledger reaches" truncates the TAIL of
+    // recoverable history instead of deleting all of it.
+    const rows = (opts.startedBeforeMs === undefined
+        ? db
+            .prepare(`SELECT * FROM computer_sessions ORDER BY started_at DESC LIMIT ?`)
+            .all(limit)
+        : db
+            .prepare(`SELECT * FROM computer_sessions WHERE started_at < ? ORDER BY started_at DESC LIMIT ?`)
+            .all(opts.startedBeforeMs, limit));
+    return rows.map((row) => ({
+        invocationId: row.invocation_id,
+        sessionId: row.session_id ?? undefined,
+        launchId: row.launch_id ?? undefined,
+        actor: row.actor ?? undefined,
+        machine: row.machine,
+        startedAt: row.started_at,
+        lastActivity: row.last_activity ?? undefined,
+        actionCount: row.action_count,
+        taskPreview: row.task_preview ?? undefined,
+    }));
+}

package/dist/lib/session/discover.js

@@ -36,7 +36,7 @@ export { machineForSessionFile } from './origin-machine.js';
 import { mapBounded } from '../concurrency.js';
 import { getDB, getScanStampByPath, getScanStampsForPaths, getParserStatesForPaths, getDirLedgerForPaths, recordDirScans, recordScans, syncLabels, seedLabelsFromNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, cacheLinearProject, } from './db.js';
 import { buildRunNameMap } from './run-names.js';
-import { resolveLinearApiKey } from '../auto-dispatch-linear.js';
+import { resolveLinearApiKey } from '../linear-cache.js';
 import { ToolCallCollector, collectClaudeToolCalls, collectCodexToolCalls, } from './tool-calls.js';
 import { purgeMissingToolCallsInDirectory } from './tool-store.js';
 const HOME = os.homedir();
@@ -187,8 +187,19 @@ export async function queryIndexedSessions(options, indexedOptions = {}) {
     const sessions = querySessions(buildQueryOptions({ ...options, skipExistenceCheck: indexedOptions.skipExistenceCheck ?? true }, agents, { includeLimit: true }));
     if (indexedOptions.resolveLinear !== false)
         await resolveLinearProjects(sessions);
-    for (const s of sessions)
-        s.machine = machineForSessionFile(s.filePath, s.agent);
+    for (const s of sessions) {
+        // A non-empty transcript path is authoritative for origin (a live-home file
+        // is this box; `backups/<agent>/<machine>/…` names that peer), so derive
+        // there. An EMPTY file_path carries no such signal — `machineForSessionFile`
+        // falls back to THIS box — so keep the machine the row was recorded with
+        // instead: a host dispatch stamps the EXECUTION host on its empty-file index
+        // row (`registerHostSession`), and re-deriving re-attributed the dispatcher's
+        // own pool row to itself, splitting it from the executing peer's fan-out row
+        // and making resume-by-id read as "ambiguous (2 sessions)" (RUSH-2486 /
+        // RUSH-2479 criterion 2). A recorded-less empty-file row still falls back.
+        if (s.filePath || !s.machine?.trim())
+            s.machine = machineForSessionFile(s.filePath, s.agent);
+    }
     return scopeToManaged(sessions, agents, options);
 }
 const linearProjectCache = new Map();
@@ -760,7 +771,7 @@ export function getAgentSessionDirs(agent, subdir) {
  * The (agent, subdir) pairs `discoverSessions` walks for JSONL transcripts —
  * the single source of truth for which directories hold live session files.
  * `getSessionRoots` expands each pair to its concrete directories so a consumer
- * (the Factory extension's fs.watch, see issue #741) can configure its watcher
+ * (AGI EXT's fs.watch, see issue #741) can configure its watcher
  * from the CLI instead of hardcoding `~/.claude|.codex|.gemini`. Adding a new
  * on-disk agent here makes every consumer watch it automatically.
  */
@@ -3568,6 +3579,18 @@ export function applyCodexLine(state, parsed) {
         state.model = payload.model || state.model;
         return;
     }
+    // Codex rollouts put per-turn metadata (including the model) on
+    // `turn_context` events. Use them as a fallback when session_meta itself
+    // does not carry the field, otherwise `agents sessions` shows blank model
+    // info for Codex.
+    if (parsed.type === 'turn_context') {
+        const payload = parsed.payload || {};
+        if (!state.model && typeof payload.model === 'string')
+            state.model = payload.model;
+        if (!state.cwd && typeof payload.cwd === 'string')
+            state.cwd = payload.cwd;
+        return;
+    }
     if (parsed.type === 'response_item' && parsed.payload?.type === 'message') {
         const role = parsed.payload.role === 'user' || parsed.payload.role === 'developer'
             ? 'user'

package/dist/lib/session/hook-sessions.js

@@ -17,8 +17,8 @@
  * This module lets `sessions --active` reconcile a `ps`-discovered pid to that
  * authoritative id. It is deliberately a small hand-rolled reader — the CLI does
  * NOT import the session-tracker package (a separate, workspace-less package;
- * see packages/session-tracker/CLAUDE.md) — mirroring the Factory extension's own
- * hand-copied reader in apps/factory/src/core/liveSession.ts. It only READS the
+ * see packages/session-tracker/CLAUDE.md) — mirroring AGI EXT's own
+ * hand-copied reader in apps/ext/src/core/liveSession.ts. It only READS the
  * existing dir/schema; it never writes or moves anything, so it is safe across a
  * fleet where old hooks and a new CLI coexist.
  *

package/dist/lib/session/host-link.d.ts

@@ -33,8 +33,8 @@ export type HostLink =
  | 'host-gone';
 /**
  * How long an IDE window's registry slice may go without a refresh before we
- * treat that window as gone. The Factory extension force-republishes its slice
- * every 4 minutes (`KEEPALIVE_FORCE_MS` in `apps/factory/src/vscode/foreman.registry.ts`)
+ * treat that window as gone. AGI EXT force-republishes its slice
+ * every 4 minutes (`KEEPALIVE_FORCE_MS` in `apps/ext/src/vscode/foreman.registry.ts`)
  * and on every terminal open/close, so a slice this old means the window is no
  * longer running — it is not merely quiet. Deliberately the same 10 minutes the
  * extension itself uses to garbage-collect a peer window's slice, so the CLI and