@phnx-labs/agents-cli 1.22.35 → 1.22.38

package/dist/lib/browser/service.d.ts

@@ -1,5 +1,6 @@
 import { type ResolvedDomainSkill } from './domain-skills.js';
-import { type TabInfo, type ProfileStatus, type HistoricalTask } from './types.js';
+import { type Task, type TabInfo, type ProfileStatus, type HistoricalTask, type ReapResult } from './types.js';
+import { type ReapOptions } from './hygiene.js';
 import { type RefOpts, type RefNode } from './refs.js';
 import type { TargetFilter } from './types.js';
 export type UploadMode = 'auto' | 'input' | 'drop' | 'chooser';
@@ -62,9 +63,11 @@ export interface HealInfo {
 export declare function resolveTaskIdentity(forwarded: {
     actor?: string;
     launchId?: string;
+    sessionId?: string;
 }, resolveLocalActor: () => string): {
     owner: string;
     launchId?: string;
+    sessionId?: string;
 };
 export declare class BrowserService {
     private static readonly SOURCE_PREFIX;
@@ -75,14 +78,22 @@ export declare class BrowserService {
     private networkRequests;
     private pendingDownloads;
     private enabledSessions;
+    /** Profile -> when a `touchTask` last persisted tasks.json for it. */
+    private lastTouchPersist;
+    /** Coalescing window for the `touchTask` write. See {@link touchTask}. */
+    private static readonly TOUCH_PERSIST_INTERVAL_MS;
     start(profileName: string, opts?: {
         taskName?: string;
         url?: string;
         endpointName?: string;
         skipDomainSkill?: boolean;
+        /** Always open a new tab, skipping the abandoned-task reclaim. */
+        fresh?: boolean;
         /** Caller identity, forwarded from the CLI (see IPCRequest.actor/launchId). */
         actor?: string;
         launchId?: string;
+        /** Calling agent session, forwarded from the CLI (see IPCRequest.sessionId). */
+        sessionId?: string;
     }): Promise<{
         task: string;
         name: string;
@@ -91,6 +102,54 @@ export declare class BrowserService {
         profile: string;
         skill?: ResolvedDomainSkill;
     }>;
+    /**
+     * Reclaim a live page already showing `url` from an ABANDONED task, instead
+     * of opening a second copy of the same page (RUSH-2622). Returns its CDP
+     * targetId, or undefined when there is nothing safe to reclaim.
+     *
+     * "Safe" is narrow on purpose, because both of the wider readings close a tab
+     * somebody is using:
+     *
+     *   - An UNOWNED matching page is NOT taken. No task claims it, which most
+     *     often means the user opened it themselves — and adopting it would make
+     *     this task's `done` close the user's tab.
+     *   - A page owned by a LIVE task is NOT taken. Stealing it would leave that
+     *     agent's `screenshot`/`click` throwing "No tabs open for this task", its
+     *     `navigate` silently opening the duplicate this feature exists to
+     *     prevent, and any in-flight recording truncated when the new owner calls
+     *     `done`.
+     *
+     * What is left is exactly the pile-up case: a page held by a task whose owner
+     * is provably gone. Liveness uses the reaper's own predicate
+     * (`taskOwnerIsGone`), so "dead" has one definition in this codebase rather
+     * than two that can drift. A task the reaper cannot prove dead keeps its tab
+     * and is closed later by the idle rule instead.
+     *
+     * Reclaiming transfers rather than shares: two tasks holding one targetId
+     * means the first `done` closes the other's tab. `start --fresh` skips this
+     * path entirely.
+     *
+     * URLs are compared canonically (`new URL(...).href`), so a requested
+     * `https://example.com` matches the `https://example.com/` Chrome reports. A
+     * page that has since redirected elsewhere simply does not match, and the
+     * caller opens a tab as before.
+     */
+    private adoptTabShowing;
+    /**
+     * Every live task across every connected profile — the reaper's input
+     * (`hygiene.ts`). A read-only view: mutating a returned `Task` mutates the
+     * daemon's live state, so callers only read it and act through `stop`.
+     */
+    listTasks(): Array<{
+        profile: string;
+        task: Task;
+    }>;
+    /**
+     * Close tasks whose owning agent session is gone, or that have sat untouched
+     * past the idle window. The entry point the daemon's periodic tick and
+     * `agents browser gc` both call; the policy lives in `hygiene.ts`.
+     */
+    reapAbandoned(opts?: ReapOptions): Promise<ReapResult>;
     stop(taskName: string): Promise<{
         ok: boolean;
         profile?: string;
@@ -277,6 +336,25 @@ export declare class BrowserService {
     private getOrCreateWindow;
     private hasTaskNamed;
     private generateUniqueTaskName;
+    /**
+     * Mark a task as active, so the reaper's idle window measures time since the
+     * last real use rather than time since `start` (RUSH-2622).
+     *
+     * Called from `findTask` — the single funnel every task-scoped operation
+     * resolves through — rather than from each of the ~26 call sites, so a new
+     * action added later cannot forget to stamp it.
+     *
+     * The in-memory stamp is what the reaper reads: it runs inside the same
+     * daemon that owns these `Task` objects. The write to tasks.json exists only
+     * so a daemon RESTART does not inherit a stale stamp and reap a task an agent
+     * has been clicking through for the last half hour — `click`, `type`,
+     * `evaluate`, and `screenshot` never call `saveTaskState` on their own, so
+     * without this the on-disk stamp would sit at the last navigation. It is
+     * coalesced to at most one write per profile per minute so a screenshot loop
+     * does not become a write loop; the resulting on-disk stamp trails by at most
+     * a minute, well inside the 30-minute idle window.
+     */
+    private touchTask;
     private findTask;
     private getTabsForTask;
     private getProfileStatus;

package/dist/lib/browser/service.js

@@ -9,13 +9,29 @@ import { connectSSH, shellQuote } from './drivers/ssh.js';
 import { clearProfileRuntime, listProfileCacheDirs, readProfileRuntimeMeta, isProcessAlive } from './runtime-state.js';
 import { resolveDomainSkill } from './domain-skills.js';
 import { generateTaskId, generateShortId, generateTaskName, } from './types.js';
+import { reapAbandonedTasks, resolveLiveIdentities, taskOwnerIsGone, } from './hygiene.js';
 import { getRefs, resolveRefToCoords, describeRefs, healRef } from './refs.js';
 import { clickAtCoords, hoverAtCoords, scrollAtCoords, typeText, pressKey, focusNode } from './input.js';
 import { typeEditorText } from './editor.js';
 import { detectUploadPattern, stageUploadFile, uploadToDropTarget, uploadToFileInput, uploadViaFileChooser, } from './upload.js';
 import { emit } from '../events.js';
 import { resolveActor } from '../actor.js';
+import { recordBrowserSession } from '../session/db.js';
 import { sshExecAsync } from '../ssh-exec.js';
+/**
+ * Canonical form for comparing a requested URL against what CDP reports for a
+ * live target. `new URL('https://example.com').href` is `https://example.com/`,
+ * which is exactly what Chrome reports — comparing the raw strings would miss
+ * every bare-origin match. Unparseable input compares as itself.
+ */
+function canonicalTabUrl(raw) {
+    try {
+        return new URL(raw).href;
+    }
+    catch {
+        return raw;
+    }
+}
 function isPathInside(candidate, dir) {
     const rel = path.relative(dir, candidate);
     return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
@@ -235,6 +251,7 @@ export function resolveTaskIdentity(forwarded, resolveLocalActor) {
     return {
         owner: forwarded.actor ?? resolveLocalActor(),
         launchId: forwarded.launchId,
+        sessionId: forwarded.sessionId,
     };
 }
 export class BrowserService {
@@ -250,6 +267,10 @@ export class BrowserService {
     networkRequests = new Map();
     pendingDownloads = new Map();
     enabledSessions = new Map(); // sessionId -> enabled domains
+    /** Profile -> when a `touchTask` last persisted tasks.json for it. */
+    lastTouchPersist = new Map();
+    /** Coalescing window for the `touchTask` write. See {@link touchTask}. */
+    static TOUCH_PERSIST_INTERVAL_MS = 60_000;
     async start(profileName, opts = {}) {
         const profile = await getProfile(profileName);
         if (!profile) {
@@ -329,29 +350,49 @@ export class BrowserService {
         // Browsers launch with --no-startup-window (session-cookie persistence,
         // see launchBrowser), so a bare `start` with no --url would otherwise
         // leave the user staring at a process with zero windows. Recreate the
-        // old startup-window affordance: if no page target exists, open a blank
-        // one. Deliberately NOT registered on the task — the startup window
-        // never was either, and tasks track only tabs they created.
+        // old startup-window affordance: if no page target exists, open a blank one.
+        //
+        // This tab IS registered on the task below. It used to be deliberately
+        // unregistered ("tasks track only tabs they created") — but this daemon did
+        // create it, and an unregistered tab is one `done`/`stop` can never close:
+        // `stop` closes exactly the entries in `task.tabs`. So every bare `start`
+        // left a blank globe tab behind forever, which is a large share of the
+        // pile-up in RUSH-2622. Tabs the daemon did NOT open are still left alone —
+        // the branch only fires when the profile has no page target at all.
+        let startupBlankTargetId;
         if (!opts.url && !conn.electron) {
             const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
             if (!targetInfos.some((t) => t.type === 'page')) {
-                await conn.cdp.send('Target.createTarget', { url: 'about:blank' });
+                const created = (await conn.cdp.send('Target.createTarget', {
+                    url: 'about:blank',
+                }));
+                startupBlankTargetId = created.targetId;
                 this.invalidateTargetCache(conn);
             }
         }
+        const now = Date.now();
         const task = {
             id: taskId,
             name: taskName,
             profile: effectiveProfileName,
             tabs: {},
             currentTabId: undefined,
-            createdAt: Date.now(),
+            createdAt: now,
+            // A brand-new task has done exactly one thing — start — so its last
+            // action is its creation. The reaper's idle window runs from here.
+            lastActionAt: now,
             pid: conn.pid,
             // Identity is forwarded from the caller (see resolveTaskIdentity): WHO
-            // (owner) and WHICH run (launchId). Resolving daemon-side would attribute
-            // every task to the shared daemon's actor (the RUSH-2020 bug).
-            ...resolveTaskIdentity({ actor: opts.actor, launchId: opts.launchId }, () => resolveActor().id),
+            // (owner), WHICH run (launchId), and WHICH agent session (sessionId).
+            // Resolving daemon-side would attribute every task to the shared daemon's
+            // actor (the RUSH-2020 bug).
+            ...resolveTaskIdentity({ actor: opts.actor, launchId: opts.launchId, sessionId: opts.sessionId }, () => resolveActor().id),
         };
+        if (startupBlankTargetId) {
+            const shortId = generateShortId();
+            task.tabs[shortId] = startupBlankTargetId;
+            task.currentTabId = shortId;
+        }
         // For Electron, get the existing window as the tab
         if (conn.electron) {
             const windowId = await this.getOrCreateWindow(conn);
@@ -363,6 +404,30 @@ export class BrowserService {
         }
         conn.tasks.set(taskName, task);
         await this.saveTaskState(effectiveProfileName, conn.tasks);
+        // Durable identity, written ONCE at start and never deleted (RUSH-2549).
+        // tasks.json above stays live state: `stop` drops the task from that map, so
+        // anything recorded only there is gone the moment the task ends -- which is
+        // why every finished task used to list as "unlinked". This row outlives the
+        // task, the daemon, and a reboot. Metadata only: the capture bytes stay on
+        // disk under capture_dir.
+        // Guarded like `emit` below ("logging should never break the CLI",
+        // events.ts): the browser task is already started and registered. An
+        // unwritable session DB must not turn a working `agents browser start` into
+        // a failure -- the cost of a miss is one unlinked row, not a dead browser.
+        try {
+            recordBrowserSession({
+                task: taskName,
+                profile: effectiveProfileName,
+                sessionId: task.sessionId,
+                launchId: task.launchId,
+                actor: task.owner,
+                startedAt: task.createdAt,
+                captureDir: getProfileSessionsDir(effectiveProfileName, taskName),
+            });
+        }
+        catch {
+            // Recording is best-effort; the task itself is live either way.
+        }
         emit('browser.launch', { profile: effectiveProfileName, task: taskName, pid: conn.pid });
         void import('../analytics/usage-db.js').then(({ recordUsage }) => {
             recordUsage({
@@ -373,14 +438,17 @@ export class BrowserService {
                 meta: { task: taskName },
             });
         }).catch(() => { });
-        // If URL provided, create tab directly (no about:blank)
+        // If URL provided, reclaim a tab an abandoned task is holding on it, else
+        // create one directly (no about:blank).
         let tabId;
         if (opts.url && !conn.electron) {
-            const result = (await conn.cdp.send('Target.createTarget', {
-                url: opts.url,
-            }));
+            const adopted = opts.fresh ? undefined : await this.adoptTabShowing(conn, opts.url);
+            const targetId = adopted ??
+                (await conn.cdp.send('Target.createTarget', {
+                    url: opts.url,
+                })).targetId;
             const shortId = generateShortId();
-            task.tabs[shortId] = result.targetId;
+            task.tabs[shortId] = targetId;
             task.currentTabId = shortId;
             this.invalidateTargetCache(conn);
             await this.saveTaskState(effectiveProfileName, conn.tasks);
@@ -401,6 +469,110 @@ export class BrowserService {
         }
         return { task: taskId, name: taskName, tabId, profile: effectiveProfileName, skill };
     }
+    /**
+     * Reclaim a live page already showing `url` from an ABANDONED task, instead
+     * of opening a second copy of the same page (RUSH-2622). Returns its CDP
+     * targetId, or undefined when there is nothing safe to reclaim.
+     *
+     * "Safe" is narrow on purpose, because both of the wider readings close a tab
+     * somebody is using:
+     *
+     *   - An UNOWNED matching page is NOT taken. No task claims it, which most
+     *     often means the user opened it themselves — and adopting it would make
+     *     this task's `done` close the user's tab.
+     *   - A page owned by a LIVE task is NOT taken. Stealing it would leave that
+     *     agent's `screenshot`/`click` throwing "No tabs open for this task", its
+     *     `navigate` silently opening the duplicate this feature exists to
+     *     prevent, and any in-flight recording truncated when the new owner calls
+     *     `done`.
+     *
+     * What is left is exactly the pile-up case: a page held by a task whose owner
+     * is provably gone. Liveness uses the reaper's own predicate
+     * (`taskOwnerIsGone`), so "dead" has one definition in this codebase rather
+     * than two that can drift. A task the reaper cannot prove dead keeps its tab
+     * and is closed later by the idle rule instead.
+     *
+     * Reclaiming transfers rather than shares: two tasks holding one targetId
+     * means the first `done` closes the other's tab. `start --fresh` skips this
+     * path entirely.
+     *
+     * URLs are compared canonically (`new URL(...).href`), so a requested
+     * `https://example.com` matches the `https://example.com/` Chrome reports. A
+     * page that has since redirected elsewhere simply does not match, and the
+     * caller opens a tab as before.
+     */
+    async adoptTabShowing(conn, url) {
+        const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
+        const wanted = canonicalTabUrl(url);
+        const matching = new Set(targetInfos
+            .filter((t) => t.type === 'page' && canonicalTabUrl(t.url) === wanted)
+            .map((t) => t.targetId));
+        if (matching.size === 0)
+            return undefined;
+        const candidates = [];
+        for (const task of conn.tasks.values()) {
+            for (const [shortId, cdpId] of Object.entries(task.tabs)) {
+                if (matching.has(cdpId))
+                    candidates.push({ task, shortId, targetId: cdpId });
+            }
+        }
+        if (candidates.length === 0)
+            return undefined;
+        const live = resolveLiveIdentities();
+        for (const { task, shortId, targetId } of candidates) {
+            // An in-flight capture means the task is in use whatever its owner looks
+            // like — same guard the reaper applies before stopping anything.
+            if (this.recordings.has(task.name))
+                continue;
+            if (!(await taskOwnerIsGone(task, live)))
+                continue;
+            // Re-check the claim after the await. Nothing serializes IPC requests —
+            // `BrowserIPCServer` registers a per-connection `socket.on('data', async …)`
+            // that Node never awaits — so two concurrent `start`s can both pass the
+            // liveness check on one candidate and both return the same targetId,
+            // putting two live tasks on one tab and re-opening the double-owner bug
+            // this reclaim is careful to avoid. Whoever deletes it first owns it.
+            if (task.tabs[shortId] !== targetId)
+                continue;
+            delete task.tabs[shortId];
+            delete task.refDescriptors?.[shortId];
+            if (task.currentTabId === shortId) {
+                const remaining = Object.keys(task.tabs);
+                task.currentTabId = remaining.length > 0 ? remaining[remaining.length - 1] : undefined;
+            }
+            try {
+                await conn.cdp.send('Target.activateTarget', { targetId });
+            }
+            catch {
+                // Bringing the tab to the front is cosmetic and not every endpoint
+                // implements activateTarget; the tab is reclaimed either way.
+            }
+            return targetId;
+        }
+        return undefined;
+    }
+    /**
+     * Every live task across every connected profile — the reaper's input
+     * (`hygiene.ts`). A read-only view: mutating a returned `Task` mutates the
+     * daemon's live state, so callers only read it and act through `stop`.
+     */
+    listTasks() {
+        const out = [];
+        for (const [key, conn] of this.connections) {
+            for (const task of conn.tasks.values()) {
+                out.push({ profile: conn.profileName ?? key, task });
+            }
+        }
+        return out;
+    }
+    /**
+     * Close tasks whose owning agent session is gone, or that have sat untouched
+     * past the idle window. The entry point the daemon's periodic tick and
+     * `agents browser gc` both call; the policy lives in `hygiene.ts`.
+     */
+    async reapAbandoned(opts = {}) {
+        return reapAbandonedTasks(this, opts);
+    }
     async stop(taskName) {
         for (const [profileName, conn] of this.connections) {
             const task = conn.tasks.get(taskName);
@@ -1850,6 +2022,41 @@ export class BrowserService {
         }
         throw new Error('Could not generate unique task name after 8 attempts');
     }
+    /**
+     * Mark a task as active, so the reaper's idle window measures time since the
+     * last real use rather than time since `start` (RUSH-2622).
+     *
+     * Called from `findTask` — the single funnel every task-scoped operation
+     * resolves through — rather than from each of the ~26 call sites, so a new
+     * action added later cannot forget to stamp it.
+     *
+     * The in-memory stamp is what the reaper reads: it runs inside the same
+     * daemon that owns these `Task` objects. The write to tasks.json exists only
+     * so a daemon RESTART does not inherit a stale stamp and reap a task an agent
+     * has been clicking through for the last half hour — `click`, `type`,
+     * `evaluate`, and `screenshot` never call `saveTaskState` on their own, so
+     * without this the on-disk stamp would sit at the last navigation. It is
+     * coalesced to at most one write per profile per minute so a screenshot loop
+     * does not become a write loop; the resulting on-disk stamp trails by at most
+     * a minute, well inside the 30-minute idle window.
+     */
+    async touchTask(conn, task) {
+        const now = Date.now();
+        task.lastActionAt = now;
+        const last = this.lastTouchPersist.get(task.profile) ?? 0;
+        if (now - last < BrowserService.TOUCH_PERSIST_INTERVAL_MS)
+            return;
+        this.lastTouchPersist.set(task.profile, now);
+        try {
+            await this.saveTaskState(task.profile, conn.tasks);
+        }
+        catch {
+            // Durability here is best-effort — the in-memory stamp above is
+            // authoritative for the running daemon — and an unwritable runtime dir
+            // must not turn a working browser action into a failure. Same guard the
+            // `recordBrowserSession` call in `start` uses for the same reason.
+        }
+    }
     async findTask(taskId, profileName) {
         if (profileName) {
             const conn = this.connections.get(profileName);
@@ -1860,11 +2067,13 @@ export class BrowserService {
             if (!task) {
                 throw new Error(`Task "${taskId}" not found on profile "${profileName}"`);
             }
+            await this.touchTask(conn, task);
             return { conn, task, profileName };
         }
         for (const [key, conn] of this.connections) {
             const task = conn.tasks.get(taskId);
             if (task) {
+                await this.touchTask(conn, task);
                 return { conn, task, profileName: conn.profileName ?? key };
             }
         }
@@ -2028,11 +2237,19 @@ export class BrowserService {
                     tabs,
                     currentTabId: tabIds.length > 0 ? tabIds[tabIds.length - 1] : undefined,
                     createdAt: task.createdAt,
+                    lastActionAt: task.lastActionAt ?? task.createdAt,
                     pid: task.pid,
                 });
             }
             else {
-                tasks.set(key, task);
+                const loaded = task;
+                // Tasks persisted before RUSH-2622 carry no lastActionAt. Normalize on
+                // read so every in-memory task has one: its own createdAt is the last
+                // moment we can prove the task did anything.
+                if (typeof loaded.lastActionAt !== 'number') {
+                    loaded.lastActionAt = loaded.createdAt;
+                }
+                tasks.set(key, loaded);
             }
         }
         // Save migrated data back to disk

package/dist/lib/browser/sessions-list.d.ts

@@ -33,10 +33,17 @@ export declare function renderBrowserSessions(groups: ProfileArtifacts[]): strin
 export declare function resolveArtifact(groups: ProfileArtifacts[], selector: string): string | null;
 /** Open a file in the OS default app. Returns true on success. */
 export declare function openArtifact(filePath: string): boolean;
-/** The identity fields this module cares about from a profile's `tasks.json`. */
+/** The identity fields this module cares about for one task. */
 export interface TaskIdentity {
     owner?: string;
     launchId?: string;
+    /**
+     * The agent session that drove the task. Primary identity: it is carried by
+     * every agent process, whereas a launch id is present on a minority of them.
+     * Sourced from the durable `browser_sessions` row, which survives task stop —
+     * `tasks.json` never records it beyond the task's own lifetime (RUSH-2549).
+     */
+    sessionId?: string;
 }
 /**
  * Read a profile's `tasks.json` for the identity of its CURRENTLY LIVE tasks,
@@ -48,6 +55,17 @@ export interface TaskIdentity {
  * browser daemon is running.
  */
 export declare function loadTaskIdentities(profile: string): Map<string, TaskIdentity>;
+/**
+ * Identity for one profile's tasks, durable copy first.
+ *
+ * `browser_sessions` is the source of truth: it is written at task start and
+ * never deleted, so it answers for tasks that have already stopped — the case
+ * `tasks.json` structurally cannot, since `saveTaskState` rewrites that file
+ * from the LIVE task map. The live file is still merged on top for a task that
+ * is running right now, so a task started by an older CLI (no DB row yet) keeps
+ * whatever identity it does have rather than regressing to nothing.
+ */
+export declare function loadDurableTaskIdentities(profile: string): Map<string, TaskIdentity>;
 /** launchId -> indexed session id, built once from every source that records
  *  this join, so a task-heavy profile resolves without re-scanning per task. */
 export interface LaunchSessionIndex {
@@ -85,6 +103,8 @@ export interface BrowserSessionRow {
     task?: string;
     owner?: string;
     launchId?: string;
+    /** The agent session that drove the task, when one was recorded. */
+    sessionId?: string;
     linkStatus: BrowserSessionLinkStatus;
     linkedSession?: SessionMeta;
     /** Newest first. */
@@ -99,7 +119,7 @@ export interface BrowserSessionRow {
  * or session-index dependency and is unit-testable with synthetic data (see
  * {@link buildBrowserSessionRows} for the impure disk/index-reading caller).
  */
-export declare function groupIntoRows(groups: ProfileArtifacts[], taskIdentities: Map<string, Map<string, TaskIdentity>>, resolveLaunch?: (launchId: string) => SessionMeta | null): BrowserSessionRow[];
+export declare function groupIntoRows(groups: ProfileArtifacts[], taskIdentities: Map<string, Map<string, TaskIdentity>>, resolveLaunch?: (launchId: string) => SessionMeta | null, resolveSession?: (sessionId: string) => SessionMeta | null): BrowserSessionRow[];
 /** Build task-first rows for one profile (or every profile with captures),
  *  reading `tasks.json` and resolving launchIds against the live indexes.
  *  The interactive picker's data source. */

package/dist/lib/browser/sessions-list.js

@@ -19,7 +19,7 @@ import * as path from 'path';
 import { spawnSync } from 'child_process';
 import { getBrowserRuntimeDir, getProfileRuntimeDir } from './profiles.js';
 import { formatRelativeTime } from '../session/relative-time.js';
-import { getSessionById } from '../session/db.js';
+import { getSessionById, listBrowserSessionRecords, pruneToolSessions } from '../session/db.js';
 import { listPidSessionEntries } from '../session/pid-registry.js';
 import { loadHookSessionIndex } from '../session/hook-sessions.js';
 import { readRecentActivity } from '../activity.js';
@@ -214,10 +214,40 @@ export function loadTaskIdentities(profile) {
         out.set(name, {
             owner: typeof t.owner === 'string' ? t.owner : undefined,
             launchId: typeof t.launchId === 'string' ? t.launchId : undefined,
+            sessionId: typeof t.sessionId === 'string' ? t.sessionId : undefined,
         });
     }
     return out;
 }
+/**
+ * Identity for one profile's tasks, durable copy first.
+ *
+ * `browser_sessions` is the source of truth: it is written at task start and
+ * never deleted, so it answers for tasks that have already stopped — the case
+ * `tasks.json` structurally cannot, since `saveTaskState` rewrites that file
+ * from the LIVE task map. The live file is still merged on top for a task that
+ * is running right now, so a task started by an older CLI (no DB row yet) keeps
+ * whatever identity it does have rather than regressing to nothing.
+ */
+export function loadDurableTaskIdentities(profile) {
+    const merged = new Map();
+    for (const record of listBrowserSessionRecords(profile)) {
+        merged.set(record.task, {
+            owner: record.actor,
+            launchId: record.launchId,
+            sessionId: record.sessionId,
+        });
+    }
+    for (const [task, live] of loadTaskIdentities(profile)) {
+        const durable = merged.get(task);
+        merged.set(task, {
+            owner: live.owner ?? durable?.owner,
+            launchId: live.launchId ?? durable?.launchId,
+            sessionId: live.sessionId ?? durable?.sessionId,
+        });
+    }
+    return merged;
+}
 /**
  * Build the launchId -> sessionId index from the same three sources
  * `feed-post.ts` `resolvePostIdentity` already uses for this exact problem —
@@ -260,7 +290,7 @@ export function resolveLaunchSession(index, launchId) {
  * or session-index dependency and is unit-testable with synthetic data (see
  * {@link buildBrowserSessionRows} for the impure disk/index-reading caller).
  */
-export function groupIntoRows(groups, taskIdentities, resolveLaunch) {
+export function groupIntoRows(groups, taskIdentities, resolveLaunch, resolveSession) {
     const rows = [];
     for (const g of groups) {
         const identities = taskIdentities.get(g.profile) ?? new Map();
@@ -278,14 +308,24 @@ export function groupIntoRows(groups, taskIdentities, resolveLaunch) {
         for (const [task, artifacts] of byTask) {
             artifacts.sort((a, b) => b.mtimeMs - a.mtimeMs);
             const identity = identities.get(task);
-            const linkedSession = identity?.launchId ? resolveLaunch?.(identity.launchId) ?? null : null;
+            // Session id first: it is the direct answer and the one agents actually
+            // carry. The launchId join stays as the fallback for a task that recorded
+            // only that (an older CLI, or a run whose session id was unset).
+            let linkedSession = null;
+            if (identity?.sessionId && resolveSession)
+                linkedSession = resolveSession(identity.sessionId);
+            if (!linkedSession && identity?.launchId && resolveLaunch) {
+                linkedSession = resolveLaunch(identity.launchId);
+            }
+            const hasIdentityKey = !!(identity?.sessionId || identity?.launchId);
             rows.push({
                 kind: 'task',
                 profile: g.profile,
                 task,
                 owner: identity?.owner,
                 launchId: identity?.launchId,
-                linkStatus: linkedSession ? 'linked' : identity?.launchId ? 'unresolved' : 'unlinked',
+                sessionId: identity?.sessionId,
+                linkStatus: linkedSession ? 'linked' : hasIdentityKey ? 'unresolved' : 'unlinked',
                 linkedSession: linkedSession ?? undefined,
                 artifacts,
                 counts: countByKind(artifacts),
@@ -311,10 +351,18 @@ export function groupIntoRows(groups, taskIdentities, resolveLaunch) {
  *  reading `tasks.json` and resolving launchIds against the live indexes.
  *  The interactive picker's data source. */
 export function buildBrowserSessionRows(profile) {
+    // Retention runs from BOTH listing paths, not just the computer one: a box
+    // that uses `agents browser` and never runs `agents sessions --computer`
+    // would otherwise never sweep either table. Best-effort — a read-only DB
+    // must not break a listing.
+    try {
+        pruneToolSessions();
+    }
+    catch { /* listing must not fail on retention */ }
     const groups = listBrowserSessions(profile);
-    const taskIdentities = new Map(groups.map((g) => [g.profile, loadTaskIdentities(g.profile)]));
+    const taskIdentities = new Map(groups.map((g) => [g.profile, loadDurableTaskIdentities(g.profile)]));
     const index = buildLaunchSessionIndex();
-    return groupIntoRows(groups, taskIdentities, (launchId) => resolveLaunchSession(index, launchId));
+    return groupIntoRows(groups, taskIdentities, (launchId) => resolveLaunchSession(index, launchId), (sessionId) => getSessionById(sessionId));
 }
 /**
  * Search predicate for the interactive picker: task name, profile, the linked

package/dist/lib/browser/stream.d.ts

@@ -5,6 +5,8 @@ export interface BrowserIPCStreamOptions {
     task?: string;
     actor: string;
     launchId?: string;
+    /** Calling agent session, forwarded onto `start` requests (RUSH-2549). */
+    sessionId?: string;
     autoStartDaemon?: boolean;
 }
 /**

package/dist/lib/browser/stream.js

@@ -53,6 +53,7 @@ export async function runBrowserIPCStream(options) {
                     taskName: request.taskName ?? defaultTask,
                     actor: request.actor ?? options.actor,
                     launchId: request.launchId ?? options.launchId,
+                    sessionId: request.sessionId ?? options.sessionId,
                 };
             }
             else if (!request.task && defaultTask) {