@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/feed/tools.js

@@ -0,0 +1,265 @@
+/**
+ * Canonical tool activity on the feed stream — browser tasks and computer runs
+ * projected into one row contract, alongside the agent and attention rows.
+ *
+ * WHY A PROJECTION AND NOT A NEW STORE. Both sources already exist and already
+ * have an owner: `agents browser sessions` groups a profile's captures into
+ * task-first rows (`browser/sessions-list.ts`), and `agents computer sessions`
+ * groups `computer.action` ledger entries into run rows
+ * (`computer/sessions-list.ts`). A menu-bar or Fleet view that wanted the same
+ * information had only one way to get it: shell out to those two commands, per
+ * tool, per device, on a timer. That is the per-tool polling this module
+ * removes — the rows ride the ONE stream `agents feed watch --json` already
+ * holds open, so a consumer switching its All/Agents/Browser/Computer filter
+ * spawns zero commands.
+ *
+ * WHAT IS DELIBERATELY DIFFERENT BETWEEN THE TWO KINDS. A browser task is a
+ * LIVE resource: it is bound in the task index while it exists, it can be
+ * driven, and it can be closed (`agents browser done --task <name>`). A
+ * computer run is a LEDGER ENTRY: the actions already happened, the CLI process
+ * that performed them has exited, and there is nothing to stop. So
+ * {@link ComputerToolRow} pins `live: false` and carries no close/stop command
+ * at all — inventing one would offer an operator a control that cannot work.
+ *
+ * PRIVACY. Rows carry capture PATHS and names, never contents, and a task URL
+ * is redacted ({@link redactToolUrl}) before it leaves this process: userinfo
+ * is stripped and credential-shaped query parameters are replaced. The feed is
+ * read by the menu bar, the extension, and any `--json` consumer; a bearer
+ * token in a `?access_token=` is exactly the value that must not ride it.
+ */
+import { createHash } from 'node:crypto';
+import { normalizeHost } from '../machine-id.js';
+import { sessionHeadline } from '../session/title.js';
+/** Newest captures retained per row. A task with hundreds of screenshots must
+ *  not turn one stream envelope into a megabyte. */
+export const TOOL_CAPTURE_LIMIT = 20;
+/** Newest actions retained per computer row, for the same reason. */
+export const TOOL_ACTION_LIMIT = 50;
+/** Stable identity for one tool row within one device scope. */
+export function toolRowKey(scope, kind, identity) {
+    return createHash('sha256').update(`${scope}\0${kind}\0${identity}`).digest('base64url').slice(0, 22);
+}
+/** Query parameters whose value is a credential, not a locator. */
+const CREDENTIAL_PARAM = /(token|secret|password|passwd|pwd|api[-_]?key|auth|session|signature|sig|code)/i;
+const REDACTED = '<redacted>';
+/**
+ * A task URL safe to publish: userinfo removed and credential-shaped query
+ * parameters replaced. A string that does not parse as a URL is dropped
+ * entirely rather than published unexamined — it cannot be redacted safely.
+ */
+export function redactToolUrl(raw) {
+    if (!raw)
+        return undefined;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return undefined;
+    }
+    url.username = '';
+    url.password = '';
+    for (const key of [...url.searchParams.keys()]) {
+        if (CREDENTIAL_PARAM.test(key))
+            url.searchParams.set(key, REDACTED);
+    }
+    // A fragment is where OAuth implicit flows put the token, and nothing on a
+    // status row needs it.
+    if (url.hash)
+        url.hash = '';
+    return url.toString();
+}
+/**
+ * The owning agent session, or nothing.
+ *
+ * `sessionId` is passed in as the EFFECTIVE identity rather than read off the
+ * capture row: a task's session is recorded in the live task record and in the
+ * device binding as well as in the durable capture history, and a row assembled
+ * from only one of those had an owner on some paths and not others. Resolving the
+ * effective id first is what makes the owner link consistent for one task however
+ * its row was assembled.
+ *
+ * Returns undefined when no id is known. `recordBrowserSession`/`emit` are
+ * pre-existing no-ops for some paths, so closed history genuinely lacks an owner
+ * sometimes — and an invented link would be worse than an absent one.
+ */
+function ownerOf(sessionId, linkedSession, scope) {
+    if (!sessionId)
+        return undefined;
+    const session = linkedSession ?? undefined;
+    // One headline ladder for the whole CLI (SES-14c): a row's own `label`, then the
+    // daemon-generated title, then the first-prompt topic. Re-deriving it here would
+    // silently drop the generated-title rung and show a different name for the same
+    // session than `agents sessions` does.
+    const label = session ? sessionHeadline(session) : undefined;
+    return {
+        sessionId,
+        device: normalizeHost(session?.machine ?? scope),
+        ...(label ? { label } : {}),
+        ...(session?.agent ? { agent: session.agent } : {}),
+    };
+}
+/** A machine name, or undefined for the `unknown` not-identified sentinel. */
+function knownMachine(machine) {
+    return machine && machine !== 'unknown' ? machine : undefined;
+}
+function countBy(items, key) {
+    const counts = {};
+    for (const item of items)
+        counts[key(item)] = (counts[key(item)] ?? 0) + 1;
+    return counts;
+}
+/**
+ * A browser task the task index binds but that has produced no capture yet.
+ *
+ * `buildBrowserSessionRows` derives its rows from captures on disk, so a task
+ * that was just opened — bound, live, drivable, closable — had no row at all
+ * until its first screenshot landed. That is the window an operator most wants
+ * to see, and it is exactly when a Sessions pane showed nothing. This
+ * synthesizes the zero-capture row so it goes through the SAME projection rather
+ * than a second parallel one.
+ */
+export function boundBrowserRow(task, binding) {
+    return {
+        kind: 'task', task, profile: binding.profile ?? '',
+        linkStatus: 'unlinked', artifacts: [],
+        counts: { screenshot: 0, pdf: 0, recording: 0, download: 0 },
+        latestMtimeMs: 0,
+    };
+}
+/**
+ * One browser task (or a profile's downloads bucket) as a tool row. Pure: the
+ * liveness verdict is passed in, because only the machine running the browser
+ * daemon holds the task index that answers it.
+ */
+export function projectBrowserToolRow(scope, row, binding, live) {
+    const host = normalizeHost(scope);
+    // Live means the task still EXISTS: either this host's browser holds a live
+    // record for it, or the task index still routes it (which is the case for a
+    // task whose browser runs on another device).
+    const isLive = Boolean(row.task) && (live !== undefined || binding !== undefined);
+    const captures = row.artifacts.slice(0, TOOL_CAPTURE_LIMIT).map((artifact) => ({
+        kind: artifact.kind, name: artifact.name, path: artifact.path, host, bytes: artifact.bytes, atMs: artifact.mtimeMs,
+    }));
+    const oldest = row.artifacts.length > 0 ? row.artifacts[row.artifacts.length - 1].mtimeMs : row.latestMtimeMs;
+    const url = redactToolUrl(binding?.url);
+    // One effective identity for the row AND its owner link, resolved before either
+    // is built: durable capture history first (it survives the task), then the live
+    // record, then the device binding.
+    const sessionId = row.sessionId ?? live?.sessionId ?? binding?.sessionId;
+    const launchId = row.launchId ?? live?.launchId ?? binding?.launchId;
+    const owner = ownerOf(sessionId, row.linkedSession, host);
+    // Tabs are only knowable from a LIVE task record on THIS host; a row projected
+    // from captures alone, or from a binding pointing at another device, genuinely
+    // does not know them and says so by omitting the field.
+    const tabs = live?.tabs;
+    const showTab = tabs?.find((tab) => tab.current && !tab.borrowed)?.id
+        ?? tabs?.find((tab) => !tab.borrowed)?.id;
+    const startedAtMs = live?.startedAtMs ?? binding?.createdAt ?? oldest;
+    // A task with no captures has no capture mtime to sort by. `lastActionAt` is
+    // refreshed by every task-scoped action, so it is the honest freshness key;
+    // its own start is the fallback. Reporting 0 would sort a brand-new live task
+    // to the very bottom of a newest-first list.
+    const updatedAtMs = Math.max(row.latestMtimeMs, live?.lastActionAtMs ?? 0) || startedAtMs;
+    return {
+        kind: 'browser',
+        // Keyed on the TASK, never on the profile. A task with no captures yet is
+        // discovered from the task index, where the profile may not be recorded, so
+        // folding the profile into the identity would give the same task two
+        // different keys and render it twice the moment its first capture landed.
+        // Task names are unique within a machine's task index, which is the scope
+        // this key is already qualified by. The downloads bucket has no task, so it
+        // keys on its profile — one such row per profile, which is what it is.
+        rowKey: toolRowKey(host, 'browser', row.task ? `task\0${row.task}` : `downloads\0${row.profile}`),
+        scope: host,
+        device: normalizeHost(binding?.device ?? host),
+        live: isLive,
+        ...(row.task ? { task: row.task } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        ...(launchId ? { launchId } : {}),
+        ...(row.linkedSession?.agent ? { agent: row.linkedSession.agent } : {}),
+        ...(owner ? { owner } : {}),
+        linkStatus: row.linkedSession ? 'linked' : sessionId ? 'unresolved' : 'unlinked',
+        startedAtMs,
+        updatedAtMs,
+        captures,
+        captureCounts: countBy(row.artifacts, (artifact) => artifact.kind),
+        profile: row.profile || live?.profile || '',
+        ...(url ? { url } : {}),
+        ...(tabs ? { tabs } : {}),
+        // `runOn` is the OBSERVING host, not `device`: the binding that resolves the
+        // task's device lives here, and passing `--device` to a later verb is
+        // refused outright. See {@link ToolCommand}.
+        ...(isLive && showTab ? { showCommand: { command: 'agents', args: ['browser', 'tab', 'focus', showTab, '--task', row.task], runOn: host } } : {}),
+        ...(isLive ? { closeCommand: { command: 'agents', args: ['browser', 'done', '--task', row.task], runOn: host } } : {}),
+    };
+}
+/**
+ * One computer run as a tool row. `live` is pinned false and no close/stop
+ * command is produced: the emitting CLI process is already gone.
+ */
+export function projectComputerToolRow(scope, row) {
+    const host = normalizeHost(scope);
+    const owner = ownerOf(row.sessionId, row.linkedSession, host);
+    const agent = row.agent ?? row.linkedSession?.agent;
+    // Captures come ONLY from a `capture` the producer recorded after the file was
+    // written. A screenshot action from before the producer carried that field has
+    // no path to report, and this deliberately reports none rather than guessing one
+    // from an output flag — a fabricated path is worse than an honest absence.
+    //
+    // `host` is the INVOKING machine, never `remoteHost`. The engine's helper RPC
+    // returns the image as base64 and the invoking process resolves `--out` and
+    // writes the file locally, so even a remote-desktop run leaves its screenshot
+    // on the box that ran the command. Naming the driven host would send a consumer
+    // looking for the file on a machine it was never written to.
+    const captures = [];
+    const captureCounts = {};
+    for (const action of row.actions) {
+        if (!action.capture)
+            continue;
+        captureCounts[action.capture.kind] = (captureCounts[action.capture.kind] ?? 0) + 1;
+        if (captures.length >= TOOL_CAPTURE_LIMIT)
+            continue;
+        captures.push({
+            kind: action.capture.kind, name: action.capture.name, path: action.capture.path,
+            host,
+            ...(action.capture.bytes !== undefined ? { bytes: action.capture.bytes } : {}),
+            atMs: action.tsMs,
+        });
+    }
+    const actions = row.actions.slice(0, TOOL_ACTION_LIMIT).map((action) => ({
+        verb: action.verb, atMs: action.tsMs,
+        ...(action.host ? { host: action.host } : {}),
+        ...(action.bundle ? { bundle: action.bundle } : {}),
+    }));
+    return {
+        kind: 'computer',
+        rowKey: toolRowKey(host, 'computer', row.invocationId ?? `${row.machine}\0${row.pid ?? ''}\0${row.startMs}`),
+        scope: host,
+        // `groupIntoComputerRuns` writes the literal 'unknown' when no record in the
+        // run identified a machine, which is a sentinel for "not identified" and not a
+        // device name. Publishing it made a locally-run action unaddressable and made
+        // it disappear under a device filter, so it resolves to the observing host —
+        // which is the machine whose ledger the run was read from.
+        device: normalizeHost(row.remoteHost ?? knownMachine(row.machine) ?? host),
+        live: false,
+        ...(row.task ? { task: row.task } : {}),
+        ...(row.sessionId ? { sessionId: row.sessionId } : {}),
+        ...(row.launchId ? { launchId: row.launchId } : {}),
+        ...(agent ? { agent } : {}),
+        ...(owner ? { owner } : {}),
+        linkStatus: row.linkStatus,
+        startedAtMs: row.startMs,
+        updatedAtMs: row.endMs,
+        captures,
+        captureCounts,
+        ...(row.bundle ? { bundle: row.bundle } : {}),
+        actions,
+        actionCounts: { ...row.counts },
+        ...(row.recoveredActionCount !== undefined ? { recoveredActionCount: row.recoveredActionCount } : {}),
+    };
+}
+/** Newest first across both kinds — the order a consumer renders. */
+export function sortToolRows(rows) {
+    return [...rows].sort((a, b) => b.updatedAtMs - a.updatedAtMs);
+}

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

@@ -1,64 +1,30 @@
-import { type SessionWatchEnvelope, type SessionWatchRow, type SessionWatchScopeStatus, type WatchLocalOptions } from '../session/watch.js';
-import { type AttentionItem } from './attention.js';
-import { type ActivityEvent } from './activity.js';
+import { type SessionWatchEnvelope, type WatchLocalOptions } from '../session/watch.js';
+import { watchToolActivity } from './tool-activity.js';
+import { type ToolRow } from './tools.js';
+import { FeedWatchState, type FeedWatchEnvelope } from './envelope.js';
+import { FeedHub } from './hub.js';
+import { getCachedToolSetup, subscribeToolSetup, type ToolSetupRow } from '../setup-tool-status.js';
 import type { GhExec } from '../github/pr-mergeable.js';
-export declare const FEED_WATCH_VERSION: 1;
-type Base = {
-    v: 1;
-    type: string;
-    streamId: string;
-    sequence: number;
-    scope: string;
-};
-export type FeedWatchEnvelope = Base & {
-    type: 'reset';
-    capturedAt: number;
-    agents: SessionWatchRow[];
-    attention: AttentionItem[];
-} | Base & {
-    type: 'agent.upsert';
-    rowKey: string;
-    agent: SessionWatchRow;
-} | Base & {
-    type: 'agent.remove';
-    rowKey: string;
-} | Base & {
-    type: 'attention.upsert';
-    rowKey: string;
-    attention: AttentionItem;
-} | Base & {
-    type: 'attention.remove';
-    rowKey: string;
-} | Base & {
-    type: 'activity.append';
-    event: ActivityEvent;
-} | Base & {
-    type: 'scope';
-    capturedAt: number;
-    status: SessionWatchScopeStatus;
-    reason?: string;
-} | Base & {
-    type: 'heartbeat';
-    capturedAt: number;
-};
-type FeedWatchPayload = FeedWatchEnvelope extends infer Envelope ? Envelope extends FeedWatchEnvelope ? Omit<Envelope, 'v' | 'streamId' | 'sequence'> : never : never;
-export declare class FeedWatchState {
-    readonly streamId: string;
-    private sequence;
-    constructor(streamId?: `${string}-${string}-${string}-${string}-${string}`);
-    emit(event: FeedWatchPayload): FeedWatchEnvelope;
-}
+export { FeedWatchState, type FeedWatchEnvelope, type FeedWatchPayload } from './envelope.js';
 /** Reuse session ownership reconciliation for the combined operator stream. */
 export declare class FeedSessionProjection {
     private readonly state;
     private readonly sessions;
     private readonly observations;
     private projectedAttention;
+    /**
+     * Tool rows per observing scope. A reset replaces one scope's rows and must
+     * not touch another's — the same per-scope rule the agent rows follow, and
+     * the reason a peer reconnecting cannot erase the local machine's tasks.
+     */
+    private readonly toolsByScope;
+    /** Whole-set per scope; see the `setup.snapshot` docblock in `envelope.ts`. */
+    private readonly setupByScope;
     constructor(state?: FeedWatchState);
     apply(event: FeedWatchEnvelope): FeedWatchEnvelope[];
 }
-export declare function projectSessionEnvelope(event: SessionWatchEnvelope, state: FeedWatchState, gh?: GhExec): Promise<FeedWatchEnvelope[]>;
-export interface WatchLocalFeedOptions {
+export declare function projectSessionEnvelope(event: SessionWatchEnvelope, state: FeedWatchState, gh?: GhExec, tools?: ToolRow[], setup?: ToolSetupRow[]): Promise<FeedWatchEnvelope[]>;
+interface WatchLocalFeedOptions {
     scope: string;
     signal: AbortSignal;
     emit: (event: FeedWatchEnvelope) => void;
@@ -70,11 +36,44 @@ export interface WatchLocalFeedOptions {
     sessions?: Pick<WatchLocalOptions, 'readCache' | 'readPrevious' | 'journalPath' | 'journalPollMs' | 'heartbeatMs'>;
     /** The `gh` runner behind PR status; a test passes a recorded table. */
     gh?: GhExec;
+    /** Tool-activity inputs, forwarded verbatim to {@link watchToolActivity}. */
+    tools?: Pick<Parameters<typeof watchToolActivity>[0], 'sweepMs' | 'roots' | 'sources'>;
+    /**
+     * Tool-setup readers. The setup teammate owns DETECTION
+     * (`lib/setup-tool-status.ts`); this stream only publishes what its cache
+     * already holds, and never triggers a probe of its own.
+     */
+    setup?: {
+        read?: typeof getCachedToolSetup;
+        subscribe?: typeof subscribeToolSetup;
+    };
 }
 export declare function watchLocalFeed(options: WatchLocalFeedOptions): Promise<void>;
+/**
+ * The one ingress for an envelope produced by ANOTHER agents-cli.
+ *
+ * `tools` was added to the `reset` payload within protocol v1, so a peer on an
+ * older CLI is a correct v1 producer that simply reports no tool rows — which is
+ * true of it, not a data defect to paper over. Normalizing HERE, at the single
+ * place a foreign envelope enters, is what keeps every consumer downstream able
+ * to treat the field as present instead of each re-checking it. A mixed-version
+ * fleet is the normal state during a rollout, so an absent field must not take
+ * the whole fan-out down.
+ */
+export declare function normalizePeerEnvelope(event: FeedWatchEnvelope): FeedWatchEnvelope;
+/** The shared local collector, constructed on first use. Exposed for tests. */
+export declare function sharedLocalFeedHub(): FeedHub;
+/** Reset the shared collector. Tests only — it must not leak across cases. */
+export declare function resetSharedLocalFeedHub(): Promise<void>;
+/**
+ * Subscribe to this machine's rows through the shared collector, until abort.
+ */
+export declare function subscribeSharedLocalFeed(options: {
+    signal: AbortSignal;
+    emit: (event: FeedWatchEnvelope) => void;
+}): Promise<void>;
 export declare function watchFleetFeed(options: {
     signal: AbortSignal;
     emit: (event: FeedWatchEnvelope) => void;
     reconnectMs?: number;
 }): Promise<void>;
-export {};

package/dist/lib/feed/watch.js

@@ -1,5 +1,4 @@
 import { SessionProjection } from '../session/projection.js';
-import { randomUUID } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { loadDevices, isDialableDevice } from '../devices/registry.js';
@@ -12,22 +11,26 @@ import { watchLocalSessions } from '../session/watch.js';
 import { readBlock, readResolution, blockIdForSession } from './feed.js';
 import { reconcileAttention } from './attention.js';
 import { ActivityStream } from './activity-stream.js';
+import { collectToolRows, watchToolActivity } from './tool-activity.js';
+import { FeedWatchState } from './envelope.js';
+import { FeedHub } from './hub.js';
+import { getCachedToolSetup, subscribeToolSetup } from '../setup-tool-status.js';
 import { PR_STATUS_TTL_MS, readPullRequestStatus, withPullRequestStatus } from './pr-status.js';
-export const FEED_WATCH_VERSION = 1;
-export class FeedWatchState {
-    streamId;
-    sequence = 0;
-    constructor(streamId = randomUUID()) { this.streamId = streamId; }
-    emit(event) {
-        return { v: 1, streamId: this.streamId, sequence: ++this.sequence, ...event };
-    }
-}
+export { FeedWatchState } from './envelope.js';
 /** Reuse session ownership reconciliation for the combined operator stream. */
 export class FeedSessionProjection {
     state;
     sessions = new SessionProjection();
     observations = new Map();
     projectedAttention = new Map();
+    /**
+     * Tool rows per observing scope. A reset replaces one scope's rows and must
+     * not touch another's — the same per-scope rule the agent rows follow, and
+     * the reason a peer reconnecting cannot erase the local machine's tasks.
+     */
+    toolsByScope = new Map();
+    /** Whole-set per scope; see the `setup.snapshot` docblock in `envelope.ts`. */
+    setupByScope = new Map();
     constructor(state = new FeedWatchState()) {
         this.state = state;
     }
@@ -44,6 +47,8 @@ export class FeedSessionProjection {
                     attention.set(row.rowKey, item);
             }
             this.observations.set(scope, attention);
+            this.toolsByScope.set(scope, new Map(event.tools.map((tool) => [tool.rowKey, tool])));
+            this.setupByScope.set(scope, event.setup);
         }
         else if (event.type === 'agent.upsert') {
             sessionEvent = { ...base, type: 'upsert', rowKey: event.rowKey, row: event.agent };
@@ -60,6 +65,20 @@ export class FeedSessionProjection {
         else if (event.type === 'attention.remove') {
             this.observations.get(scope)?.delete(event.rowKey);
         }
+        else if (event.type === 'tool.upsert') {
+            if (!this.toolsByScope.has(scope))
+                this.toolsByScope.set(scope, new Map());
+            this.toolsByScope.get(scope).set(event.rowKey, event.tool);
+            return [this.state.emit({ type: 'tool.upsert', scope, rowKey: event.rowKey, tool: event.tool })];
+        }
+        else if (event.type === 'tool.remove') {
+            this.toolsByScope.get(scope)?.delete(event.rowKey);
+            return [this.state.emit({ type: 'tool.remove', scope, rowKey: event.rowKey })];
+        }
+        else if (event.type === 'setup.snapshot') {
+            this.setupByScope.set(scope, event.setup);
+            return [this.state.emit({ type: 'setup.snapshot', scope, capturedAt: event.capturedAt, setup: event.setup })];
+        }
         else {
             const { v: _v, streamId: _streamId, sequence: _sequence, ...payload } = event;
             return [this.state.emit(payload)];
@@ -78,7 +97,9 @@ export class FeedSessionProjection {
             if (rowEvent.type === 'reset') {
                 resetScopes.add(rowEvent.scope);
                 result.push(this.state.emit({ type: 'reset', scope: rowEvent.scope, capturedAt: rowEvent.capturedAt, agents: rowEvent.rows,
-                    attention: [...next.values()].filter(value => value.scope === rowEvent.scope).map(value => value.item) }));
+                    attention: [...next.values()].filter(value => value.scope === rowEvent.scope).map(value => value.item),
+                    tools: [...(this.toolsByScope.get(rowEvent.scope)?.values() ?? [])],
+                    setup: this.setupByScope.get(rowEvent.scope) ?? [] }));
             }
             else if (rowEvent.type === 'upsert') {
                 result.push(this.state.emit({ type: 'agent.upsert', scope: rowEvent.scope, rowKey: rowEvent.rowKey, agent: rowEvent.row }));
@@ -137,11 +158,11 @@ async function projectAgent(agent, gh) {
     const pullRequest = await pullRequestFor(agent, gh);
     return { agent: withPullRequestStatus(agent, pullRequest), attention: attentionFor(agent, pullRequest) };
 }
-export async function projectSessionEnvelope(event, state, gh) {
+export async function projectSessionEnvelope(event, state, gh, tools = [], setup = []) {
     if (event.type === 'reset') {
         const projected = await Promise.all(event.rows.map((row) => projectAgent(row, gh)));
         const attention = projected.map((p) => p.attention).filter((item) => item !== undefined);
-        return [state.emit({ type: 'reset', capturedAt: event.capturedAt, scope: event.scope, agents: projected.map((p) => p.agent), attention })];
+        return [state.emit({ type: 'reset', capturedAt: event.capturedAt, scope: event.scope, agents: projected.map((p) => p.agent), attention, tools, setup })];
     }
     if (event.type === 'upsert') {
         const { agent, attention } = await projectAgent(event.row, gh);
@@ -199,6 +220,23 @@ export async function watchLocalFeed(options) {
     // dropping it from a window the caller believes was covered.
     const activity = new ActivityStream();
     let activityCursor = Date.now();
+    // The tool rows as this machine last projected them. Held here rather than
+    // re-collected per reset: a session-watch reconnect emits a fresh reset, and
+    // re-reading the browser tree and the ledger for it would reintroduce exactly
+    // the per-render cost `tool-activity.ts` exists to remove.
+    let toolRows = collectToolRows(options.scope, options.tools?.sources).rows;
+    // Setup rows come from the setup teammate's cache, never from a probe here:
+    // `getCachedToolSetup` reads metadata plus the last EXPLICIT health check, so
+    // publishing it costs no subprocess and cannot unlock a secret store.
+    const readSetup = options.setup?.read ?? getCachedToolSetup;
+    let setupRows = (() => {
+        try {
+            return readSetup();
+        }
+        catch {
+            return [];
+        }
+    })();
     const agents = new Map();
     const attention = new Map();
     // The PR status last projected onto each row, so a merge or a check verdict
@@ -246,7 +284,30 @@ export async function watchLocalFeed(options) {
             await reconcileRows();
         });
     }, options.activityPollMs ?? 500);
-    const stopActivity = () => { clearInterval(activityTimer); stopAttentionWatch(); activity.close(); };
+    const toolWatch = watchToolActivity({
+        ...options.tools, scope: options.scope, signal: options.signal, initial: toolRows,
+        onDiff: (diff) => {
+            for (const tool of diff.upserts) {
+                toolRows = [...toolRows.filter((row) => row.rowKey !== tool.rowKey), tool];
+                options.emit(state.emit({ type: 'tool.upsert', scope: options.scope, rowKey: tool.rowKey, tool }));
+            }
+            for (const rowKey of diff.removes) {
+                toolRows = toolRows.filter((row) => row.rowKey !== rowKey);
+                options.emit(state.emit({ type: 'tool.remove', scope: options.scope, rowKey }));
+            }
+        },
+    });
+    // The setup cache is file-backed and notifies on change, so a Settings pane
+    // costs no polling: `subscribeToolSetup` is the invalidation the setup side
+    // publishes for exactly this consumer.
+    const stopSetupWatch = (options.setup?.subscribe ?? subscribeToolSetup)((rows) => {
+        const next = JSON.stringify(rows);
+        if (next === JSON.stringify(setupRows))
+            return;
+        setupRows = rows;
+        options.emit(state.emit({ type: 'setup.snapshot', scope: options.scope, capturedAt: Date.now(), setup: rows }));
+    });
+    const stopActivity = () => { clearInterval(activityTimer); stopAttentionWatch(); activity.close(); toolWatch.stop(); stopSetupWatch(); };
     options.signal.addEventListener('abort', stopActivity, { once: true });
     try {
         await watchLocalSessions({ ...options.sessions, scope: options.scope, signal: options.signal, emit: (event) => {
@@ -262,7 +323,7 @@ export async function watchLocalFeed(options) {
                     attention.delete(event.rowKey);
                     prStatus.delete(event.rowKey);
                 }
-                pending = pending.then(() => projectSessionEnvelope(event, state, options.gh)).then((events) => {
+                pending = pending.then(() => projectSessionEnvelope(event, state, options.gh, toolRows, setupRows)).then((events) => {
                     for (const projected of events) {
                         if (projected.type === 'reset') {
                             attention.clear();
@@ -302,6 +363,75 @@ function remoteFeedWatchCommand(os) {
         ? buildWindowsAgentsCommand({ args })
         : `bash -lc ${shellQuote(`agents ${args.map(shellQuote).join(' ')}`)}`;
 }
+/**
+ * The one ingress for an envelope produced by ANOTHER agents-cli.
+ *
+ * `tools` was added to the `reset` payload within protocol v1, so a peer on an
+ * older CLI is a correct v1 producer that simply reports no tool rows — which is
+ * true of it, not a data defect to paper over. Normalizing HERE, at the single
+ * place a foreign envelope enters, is what keeps every consumer downstream able
+ * to treat the field as present instead of each re-checking it. A mixed-version
+ * fleet is the normal state during a rollout, so an absent field must not take
+ * the whole fan-out down.
+ */
+export function normalizePeerEnvelope(event) {
+    if (event.type !== 'reset')
+        return event;
+    if (Array.isArray(event.tools) && Array.isArray(event.setup))
+        return event;
+    return { ...event, tools: event.tools ?? [], setup: event.setup ?? [] };
+}
+/**
+ * The process-wide local collector, shared by refcount.
+ *
+ * `watchLocalFeed` is cheap per tick but NOT free to duplicate: each call builds
+ * its own `ActivityStream` cursor set over the activity directory, its own
+ * recursive tool watchers, its own feed/resolution watchers and its own
+ * setup subscription. Two callers in one process paid all of that twice and
+ * produced identical envelopes — and there are genuinely two callers on a daemon
+ * box: the fleet fan-out (which watches the local scope alongside every peer)
+ * and anything else that wants this machine's rows.
+ *
+ * One {@link FeedHub} over `watchLocalFeed` collapses them: the watcher starts on
+ * the first subscriber, stops on the last, and a late subscriber is caught up
+ * from held state instead of constructing a second cursor set.
+ *
+ * This is deliberately PROCESS-wide and not machine-wide. Making `feed watch
+ * --json --local` attach to the daemon instead would be the machine-wide
+ * version, and it would put a daemon dependency on the one command the fleet
+ * fan-out runs over ssh on every peer — a peer with a sick daemon would drop off
+ * the fleet stream entirely rather than degrade. The cross-process sharing that
+ * matters is the FLEET stream, which is what the daemon hub serves.
+ */
+let sharedLocal = null;
+/** The shared local collector, constructed on first use. Exposed for tests. */
+export function sharedLocalFeedHub() {
+    return sharedLocal ??= new FeedHub({
+        watch: (hubOptions) => watchLocalFeed({
+            scope: machineId(), signal: hubOptions.signal, emit: hubOptions.emit,
+        }),
+    });
+}
+/** Reset the shared collector. Tests only — it must not leak across cases. */
+export async function resetSharedLocalFeedHub() {
+    const hub = sharedLocal;
+    sharedLocal = null;
+    await hub?.close();
+}
+/**
+ * Subscribe to this machine's rows through the shared collector, until abort.
+ */
+export function subscribeSharedLocalFeed(options) {
+    const detach = sharedLocalFeedHub().subscribe(options.emit);
+    return new Promise((resolve) => {
+        if (options.signal.aborted) {
+            detach();
+            resolve();
+            return;
+        }
+        options.signal.addEventListener('abort', () => { detach(); resolve(); }, { once: true });
+    });
+}
 export async function watchFleetFeed(options) {
     const coordinator = new FeedWatchState();
     const projection = new FeedSessionProjection(coordinator);
@@ -309,7 +439,7 @@ export async function watchFleetFeed(options) {
         for (const projected of projection.apply(event))
             options.emit(projected);
     };
-    const local = watchLocalFeed({ scope: machineId(), signal: options.signal, emit: forward });
+    const local = subscribeSharedLocalFeed({ signal: options.signal, emit: forward });
     let devices;
     try {
         devices = await loadDevices();
@@ -332,7 +462,7 @@ export async function watchFleetFeed(options) {
                     const event = JSON.parse(line);
                     if (event.v !== 1)
                         return false;
-                    forward(event);
+                    forward(normalizePeerEnvelope(event));
                     return true;
                 }
                 catch {