@phnx-labs/agents-cli 1.22.114 → 1.22.116

package/dist/lib/cloudflare/creds.js

@@ -0,0 +1,46 @@
+// Cloudflare API credential glue, shared by the commands that provision or read
+// Cloudflare-backed endpoints (`agents traces`, `agents sessions backup`).
+//
+// This used to live in `lib/share/config.ts` alongside the embedded artifact
+// share engine. The share engine moved out to `@phnx-labs/artifacts-cli`
+// (PHNX-3992); `readCloudflareCreds` stayed because it is a generic Cloudflare
+// util that `traces`/`sessions backup` borrow, unrelated to sharing.
+import { bundleExistsSync as bundleExists, readAndResolveBundleEnvSync as readAndResolveBundleEnv, } from '../secrets-client.js';
+export const DEFAULT_CF_BUNDLE = 'cloudflare';
+/** Cloudflare API credentials for provisioning, read from `cloudflare` (or a
+ * user-named bundle). Fuzzy-matches key names so it works across bundle layouts. */
+export function readCloudflareCreds(bundle = DEFAULT_CF_BUNDLE, override) {
+    // Explicit --token/--account bypass the bundle entirely (robust escape hatch).
+    if (override?.apiToken) {
+        return { apiToken: override.apiToken, accountId: override.accountId ?? '' };
+    }
+    // Check existence first: resolving a missing bundle through the process client
+    // surfaces an opaque transport code (e.g. LOCKED), never naming the bundle the
+    // user typed — so name it here.
+    if (!bundleExists(bundle)) {
+        throw new Error(`The '${bundle}' bundle does not exist. ` +
+            `Pass credentials directly with --token <t> [--account <id>], or create it: ` +
+            `agents secrets add ${bundle} CLOUDFLARE_API_TOKEN`);
+    }
+    const { env } = readAndResolveBundleEnv(bundle, {
+        caller: 'cloudflare',
+        // Setup is still a read; only `agents secrets unlock` may authenticate.
+        agentOnly: true,
+    });
+    const find = (re) => {
+        for (const [k, v] of Object.entries(env))
+            if (re.test(k) && v)
+                return v;
+        return '';
+    };
+    const apiToken = env.CLOUDFLARE_API_TOKEN || env.CF_API_TOKEN || find(/API[_-]?TOKEN|(?:^|_)TOKEN$/i);
+    const accountId = override?.accountId || env.CLOUDFLARE_ACCOUNT_ID || env.CF_ACCOUNT_ID || find(/ACCOUNT[_-]?ID/i);
+    if (!apiToken) {
+        const keys = Object.keys(env);
+        throw new Error(`No Cloudflare API token in the '${bundle}' bundle ` +
+            `(keys present: ${keys.length ? keys.join(', ') : 'none'}). ` +
+            `Pass it directly with --token <t> [--account <id>], or add it: ` +
+            `agents secrets add ${bundle} CLOUDFLARE_API_TOKEN`);
+    }
+    return { apiToken, accountId };
+}

package/dist/lib/cloudflare/provision.d.ts

@@ -0,0 +1,35 @@
+/** One compiled non-JS Worker module (e.g. WASM) uploaded alongside the script. */
+export interface WorkerModule {
+    name: string;
+    contentType: string;
+    contents: Uint8Array<ArrayBuffer>;
+}
+/** A Worker script plus any extra modules to upload with it. */
+export interface WorkerBundle {
+    script: string;
+    modules: WorkerModule[];
+}
+export interface CloudflareRequest {
+    apiToken: string;
+    method: string;
+    pathname: string;
+    body?: unknown;
+    form?: FormData;
+}
+export type CloudflareRequester = <T = unknown>(request: CloudflareRequest) => Promise<T>;
+interface ProvisionOptions {
+    request?: CloudflareRequester;
+}
+/** Create the R2 bucket (idempotent). */
+export declare function createBucket(apiToken: string, accountId: string, name: string, opts?: ProvisionOptions): Promise<void>;
+/** Upload the module Worker with an R2 binding (`BUCKET`). Secrets are set via the Workers Secrets API. */
+export declare function deployWorker(apiToken: string, accountId: string, workerName: string, worker: string | WorkerBundle, bucketName: string, opts?: ProvisionOptions): Promise<void>;
+/** Add/update a secret_text binding using Cloudflare's Workers Secrets API. */
+export declare function putWorkerSecret(apiToken: string, accountId: string, workerName: string, name: string, text: string, opts?: ProvisionOptions): Promise<void>;
+/** Enable the free `*.workers.dev` route for the script, and return the account subdomain. */
+export declare function enableWorkersDev(apiToken: string, accountId: string, workerName: string, opts?: ProvisionOptions): Promise<string>;
+/** Resolve a zone id for a domain the token can see, or null if not owned/visible. */
+export declare function findZoneId(apiToken: string, domain: string, opts?: ProvisionOptions): Promise<string | null>;
+/** Map a custom hostname (e.g. `share.getrush.ai`) to the Worker via Workers Custom Domains. */
+export declare function addCustomDomain(apiToken: string, accountId: string, workerName: string, zoneId: string, hostname: string, opts?: ProvisionOptions): Promise<void>;
+export {};

package/dist/lib/cloudflare/provision.js

@@ -0,0 +1,144 @@
+// Generic Cloudflare orchestration — plain `fetch` against the CF REST API (the
+// repo has no CF wrapper). Create an R2 bucket, upload a module Worker with an R2
+// binding, set secrets via the Workers Secrets API, enable the free
+// `*.workers.dev` subdomain, and map a custom domain when the token owns the zone.
+//
+// This was `lib/share/provision.ts`. The artifact share engine moved out to
+// `@phnx-labs/artifacts-cli` (PHNX-3992), but `agents traces` provisions its own
+// isolated Cloudflare-backed store with the SAME primitives — so the generic
+// layer relocated here (share-specific lifecycle/collab/managed helpers left
+// with the share engine). `traces/provision.ts` is now the only consumer.
+const CF_API = 'https://api.cloudflare.com/client/v4';
+async function cf(apiToken, method, pathname, body, form) {
+    const headers = { authorization: `Bearer ${apiToken}` };
+    let payload;
+    if (form) {
+        payload = form; // fetch sets multipart boundary
+    }
+    else if (body !== undefined) {
+        headers['content-type'] = 'application/json';
+        payload = JSON.stringify(body);
+    }
+    const res = await fetch(`${CF_API}${pathname}`, { method, headers, body: payload });
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok || json.success === false) {
+        const msg = (json.errors ?? []).map((e) => `${e.code ?? ''} ${e.message ?? ''}`.trim()).join('; ') ||
+            res.statusText;
+        throw new Error(`Cloudflare ${method} ${pathname} failed (${res.status}): ${msg}`);
+    }
+    return json.result;
+}
+const defaultCloudflareRequester = (request) => cf(request.apiToken, request.method, request.pathname, request.body, request.form);
+/** True if the CF error looks like "the thing already exists" (idempotent create). */
+function isAlreadyExists(e) {
+    return /already exists|duplicate|10004|10014/i.test(String(e));
+}
+/** Create the R2 bucket (idempotent). */
+export async function createBucket(apiToken, accountId, name, opts = {}) {
+    const request = opts.request ?? defaultCloudflareRequester;
+    try {
+        await request({
+            apiToken,
+            method: 'POST',
+            pathname: `/accounts/${accountId}/r2/buckets`,
+            body: { name },
+        });
+    }
+    catch (e) {
+        if (!isAlreadyExists(e))
+            throw e;
+    }
+}
+/** Upload the module Worker with an R2 binding (`BUCKET`). Secrets are set via the Workers Secrets API. */
+export async function deployWorker(apiToken, accountId, workerName, worker, bucketName, opts = {}) {
+    const request = opts.request ?? defaultCloudflareRequester;
+    const metadata = {
+        main_module: 'worker.js',
+        compatibility_date: '2024-11-06',
+        bindings: [
+            { type: 'r2_bucket', name: 'BUCKET', bucket_name: bucketName },
+        ],
+    };
+    const form = new FormData();
+    form.set('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
+    const bundle = typeof worker === 'string' ? { script: worker, modules: [] } : worker;
+    form.set('worker.js', new Blob([bundle.script], { type: 'application/javascript+module' }), 'worker.js');
+    for (const module of bundle.modules) {
+        form.set(module.name, new Blob([module.contents], { type: module.contentType }), module.name);
+    }
+    await request({
+        apiToken,
+        method: 'PUT',
+        pathname: `/accounts/${accountId}/workers/scripts/${workerName}`,
+        form,
+    });
+}
+/** Add/update a secret_text binding using Cloudflare's Workers Secrets API. */
+export async function putWorkerSecret(apiToken, accountId, workerName, name, text, opts = {}) {
+    const request = opts.request ?? defaultCloudflareRequester;
+    await request({
+        apiToken,
+        method: 'PUT',
+        pathname: `/accounts/${accountId}/workers/scripts/${workerName}/secrets`,
+        body: { name, text, type: 'secret_text' },
+    });
+}
+/** Enable the free `*.workers.dev` route for the script, and return the account subdomain. */
+export async function enableWorkersDev(apiToken, accountId, workerName, opts = {}) {
+    const request = opts.request ?? defaultCloudflareRequester;
+    await request({
+        apiToken,
+        method: 'POST',
+        pathname: `/accounts/${accountId}/workers/scripts/${workerName}/subdomain`,
+        body: {
+            enabled: true,
+            previews_enabled: false,
+        },
+    });
+    const sub = await request({
+        apiToken,
+        method: 'GET',
+        pathname: `/accounts/${accountId}/workers/subdomain`,
+    });
+    if (!sub?.subdomain) {
+        throw new Error('No workers.dev subdomain on this account yet — register one at dash.cloudflare.com → Workers → Subdomain, then re-run.');
+    }
+    return sub.subdomain;
+}
+/** Resolve a zone id for a domain the token can see, or null if not owned/visible. */
+export async function findZoneId(apiToken, domain, opts = {}) {
+    const request = opts.request ?? defaultCloudflareRequester;
+    // Try the exact name, then the registrable parent (share.getrush.ai -> getrush.ai).
+    const candidates = [domain, domain.split('.').slice(-2).join('.')];
+    for (const name of candidates) {
+        const zones = await request({
+            apiToken,
+            method: 'GET',
+            pathname: `/zones?name=${encodeURIComponent(name)}`,
+        }).catch(() => []);
+        if (zones?.length)
+            return zones[0].id;
+    }
+    return null;
+}
+/** Map a custom hostname (e.g. `share.getrush.ai`) to the Worker via Workers Custom Domains. */
+export async function addCustomDomain(apiToken, accountId, workerName, zoneId, hostname, opts = {}) {
+    const request = opts.request ?? defaultCloudflareRequester;
+    try {
+        await request({
+            apiToken,
+            method: 'PUT',
+            pathname: `/accounts/${accountId}/workers/domains`,
+            body: {
+                zone_id: zoneId,
+                hostname,
+                service: workerName,
+                environment: 'production',
+            },
+        });
+    }
+    catch (e) {
+        if (!isAlreadyExists(e))
+            throw e;
+    }
+}

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

@@ -26,7 +26,61 @@ export interface ComputerAction {
     agent?: string;
     machineId?: string;
     hostname?: string;
+    /**
+     * The file a successful `screenshot` action actually wrote.
+     *
+     * Recorded by the standalone engine only AFTER the write succeeded, so its
+     * presence is proof the file existed — which is why nothing here ever derives
+     * a path from the verb. An action from before the producer carried this field
+     * has no capture, and that is reported honestly as none rather than guessed at
+     * from an output flag that may never have been written.
+     */
+    capture?: {
+        path: string;
+        kind: 'screenshot';
+        name: string;
+        bytes?: number;
+    };
 }
+/**
+ * The standalone engine's OWN action ledger.
+ *
+ * `agents computer` is a thin consumer of the standalone `computer` engine
+ * (PHNX-4075), and that engine ALWAYS appends every action it performs to
+ * `<cache>/computer/actions/<day>.jsonl` — independently of whether agents-cli
+ * was in the call at all. So a `computer` command the operator ran directly
+ * appears ONLY here: it never reached `recordComputerAction`, so it is in
+ * neither the feed event ledger nor `computer_sessions`. Reading only those two
+ * meant the actions an operator actually performed were invisible to every
+ * agents-cli surface.
+ */
+export declare function standaloneComputerActionsDir(): string;
+/**
+ * Read the standalone ledger, newest day first, bounded by `limit` actions.
+ *
+ * Bounded by construction: days are read newest-first and reading stops as soon
+ * as the budget is met, so a box with months of history costs the same as one
+ * with a day of it.
+ */
+export declare function listStandaloneComputerActions(opts?: {
+    limit?: number;
+    dir?: string;
+    observer?: string;
+}): ComputerAction[];
+/**
+ * Union the two ledgers, preferring the standalone record for any run present in
+ * both.
+ *
+ * Dedupe keys on `invocationId`, NOT on a timestamp or pid. When a command is
+ * forwarded through `agents computer`, BOTH stores receive it — and the
+ * forwarding rewrites `ts` and `pid` on the way through, so the two copies of one
+ * action do not agree on either. `invocationId` is minted by the engine and
+ * echoed unchanged, which makes it the only field that identifies the same run in
+ * both files. A legacy feed record with no invocationId cannot be matched to
+ * anything, so it is kept: dropping it would lose history the standalone ledger
+ * never had.
+ */
+export declare function mergeComputerActionSources(standalone: ComputerAction[], legacy: ComputerAction[]): ComputerAction[];
 /** Read `computer.action` events straight from the durable event ledger,
  *  newest first, bounded by `limit`. Malformed/legacy records (missing
  *  `command` or `pid`, or an unparseable `ts`) are skipped, never thrown —
@@ -94,6 +148,7 @@ export declare function groupIntoComputerRuns(actions: ComputerAction[], resolve
 export declare function buildComputerSessionRows(opts?: {
     limit?: number;
     machine?: string;
+    observer?: string;
 }): ComputerRunRow[];
 /**
  * Search predicate for the interactive picker: task text, machine/remote

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

@@ -58,6 +58,10 @@
  * `sessionId` doesn't resolve (a rotated/unindexed session) but `launchId`
  * still does via the more authoritative pid registry.
  */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getCacheDir } from '../state.js';
+import { machineId } from '../machine-id.js';
 import { query, truncate } from '../feed/events.js';
 import { formatRelativeTime } from '../session/relative-time.js';
 import { getSessionById, listComputerSessionRecords, pruneToolSessions } from '../session/db.js';
@@ -70,6 +74,21 @@ export const TASK_PREVIEW_MAX_CHARS = 200;
  *  already reads newest-first and stops at this cutoff mid-scan, so raising
  *  it only ever costs as much as the history actually holds. */
 const DEFAULT_ACTION_LIMIT = 5000;
+/** A capture record, accepted only when the producer gave a real path + name. */
+function parseActionCapture(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    if (typeof record.path !== 'string' || !record.path)
+        return undefined;
+    const name = typeof record.name === 'string' && record.name ? record.name : path.basename(record.path);
+    return {
+        path: record.path,
+        kind: 'screenshot',
+        name,
+        ...(typeof record.bytes === 'number' ? { bytes: record.bytes } : {}),
+    };
+}
 function recordToAction(r) {
     if (typeof r.command !== 'string' || typeof r.pid !== 'number')
         return null;
@@ -91,8 +110,153 @@ function recordToAction(r) {
         agent: typeof r.agent === 'string' ? r.agent : undefined,
         machineId: typeof r.machineId === 'string' ? r.machineId : undefined,
         hostname: typeof r.hostname === 'string' ? r.hostname : undefined,
+        capture: parseActionCapture(r.capture),
     };
 }
+/**
+ * The standalone engine's OWN action ledger.
+ *
+ * `agents computer` is a thin consumer of the standalone `computer` engine
+ * (PHNX-4075), and that engine ALWAYS appends every action it performs to
+ * `<cache>/computer/actions/<day>.jsonl` — independently of whether agents-cli
+ * was in the call at all. So a `computer` command the operator ran directly
+ * appears ONLY here: it never reached `recordComputerAction`, so it is in
+ * neither the feed event ledger nor `computer_sessions`. Reading only those two
+ * meant the actions an operator actually performed were invisible to every
+ * agents-cli surface.
+ */
+export function standaloneComputerActionsDir() {
+    return path.join(getCacheDir(), 'computer', 'actions');
+}
+/**
+ * One line of the standalone ledger as a {@link ComputerAction}.
+ *
+ * The on-disk record is the same `computer.action` event the engine reports on
+ * fd 4 — the contract `computer-client.ts` `ComputerActionEvent` already
+ * describes and `recordComputerAction` already consumes — so this maps the same
+ * fields rather than inventing a second vocabulary. A record missing the two
+ * fields that make it an action at all (`command`, a parseable timestamp) is
+ * skipped, never defaulted: the file is plain JSONL another process may be
+ * mid-append to.
+ */
+function standaloneLineToAction(line, observer) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const record = parsed;
+    const verb = typeof record.command === 'string' ? record.command : undefined;
+    const ts = typeof record.ts === 'string' ? record.ts : undefined;
+    if (!verb || !ts)
+        return null;
+    const tsMs = Date.parse(ts);
+    if (Number.isNaN(tsMs))
+        return null;
+    const text = (key) => (typeof record[key] === 'string' ? record[key] : undefined);
+    const num = (key) => (typeof record[key] === 'number' ? record[key] : undefined);
+    // The producer identifies the DRIVEN host only for a remote run, and emits no
+    // `hostname`/`machineId` of its own at all. Defaulting those to the observing
+    // machine HERE, at the source, is what keeps a direct local action attributable:
+    // without it `groupIntoComputerRuns` fell back to `machine: 'unknown'`, the row's
+    // device read `unknown`, and every locally-run `computer` action vanished the
+    // moment a consumer filtered by device. The observer IS the machine that ran it
+    // — this ledger is per-machine by construction, written by the engine on the box
+    // it ran on — so the fallback is a fact, not a guess. An explicit `host` still
+    // wins, because that names a genuinely different driven machine.
+    return {
+        verb, ts, tsMs,
+        // The engine's pid is its own; a record without one still groups by
+        // invocationId, which is the identity that actually matters here.
+        pid: num('pid') ?? 0,
+        invocationId: text('invocationId'),
+        targetPid: num('targetPid'),
+        bundle: text('bundle'),
+        host: text('host'),
+        task: text('task'),
+        sessionId: text('sessionId'),
+        launchId: text('launchId'),
+        agent: text('agent'),
+        machineId: text('machineId'),
+        hostname: text('hostname') ?? observer,
+        capture: parseActionCapture(record.capture),
+    };
+}
+/**
+ * Read the standalone ledger, newest day first, bounded by `limit` actions.
+ *
+ * Bounded by construction: days are read newest-first and reading stops as soon
+ * as the budget is met, so a box with months of history costs the same as one
+ * with a day of it.
+ */
+export function listStandaloneComputerActions(opts = {}) {
+    const dir = opts.dir ?? standaloneComputerActionsDir();
+    const limit = opts.limit ?? DEFAULT_ACTION_LIMIT;
+    // This ledger is per-machine by construction, so "who ran it" is this machine
+    // unless the record names a driven remote host.
+    const observer = opts.observer ?? machineId();
+    let days;
+    try {
+        days = fs.readdirSync(dir).filter((name) => name.endsWith('.jsonl')).sort().reverse();
+    }
+    catch {
+        return []; // The engine has never run here, or is not installed.
+    }
+    const out = [];
+    for (const day of days) {
+        if (out.length >= limit)
+            break;
+        let lines;
+        try {
+            lines = fs.readFileSync(path.join(dir, day), 'utf8').split('\n');
+        }
+        catch {
+            continue; /* rotated or removed mid-read */
+        }
+        // Newest last within a day, and the budget favours the newest actions.
+        for (let index = lines.length - 1; index >= 0 && out.length < limit; index--) {
+            const line = lines[index];
+            if (!line)
+                continue;
+            const action = standaloneLineToAction(line, observer);
+            if (action)
+                out.push(action);
+        }
+    }
+    out.sort((a, b) => b.tsMs - a.tsMs);
+    return out;
+}
+/**
+ * Union the two ledgers, preferring the standalone record for any run present in
+ * both.
+ *
+ * Dedupe keys on `invocationId`, NOT on a timestamp or pid. When a command is
+ * forwarded through `agents computer`, BOTH stores receive it — and the
+ * forwarding rewrites `ts` and `pid` on the way through, so the two copies of one
+ * action do not agree on either. `invocationId` is minted by the engine and
+ * echoed unchanged, which makes it the only field that identifies the same run in
+ * both files. A legacy feed record with no invocationId cannot be matched to
+ * anything, so it is kept: dropping it would lose history the standalone ledger
+ * never had.
+ */
+export function mergeComputerActionSources(standalone, legacy) {
+    const standaloneRuns = new Set();
+    for (const action of standalone)
+        if (action.invocationId)
+            standaloneRuns.add(action.invocationId);
+    const merged = [...standalone];
+    for (const action of legacy) {
+        if (action.invocationId && standaloneRuns.has(action.invocationId))
+            continue;
+        merged.push(action);
+    }
+    merged.sort((a, b) => b.tsMs - a.tsMs);
+    return merged;
+}
 /** Read `computer.action` events straight from the durable event ledger,
  *  newest first, bounded by `limit`. Malformed/legacy records (missing
  *  `command` or `pid`, or an unparseable `ts`) are skipped, never thrown —
@@ -240,7 +404,10 @@ function appendPrunedRunsFromDb(rows, limit) {
  *  flat/`--json` printer's) data source. `machine` narrows to rows whose
  *  invoking hostname, machineId, or `--device` target contains the substring. */
 export function buildComputerSessionRows(opts = {}) {
-    const actions = listComputerActions({ limit: opts.limit });
+    const actions = mergeComputerActionSources(
+    // `observer` is threaded from the caller's scope so a row's device and the
+    // scope that reported it can never name the same box differently.
+    listStandaloneComputerActions({ limit: opts.limit, ...(opts.observer ? { observer: opts.observer } : {}) }), listComputerActions({ limit: opts.limit }));
     const index = buildLaunchSessionIndex();
     const rows = groupIntoComputerRuns(actions, (sessionId) => getSessionById(sessionId), (launchId) => resolveLaunchSession(index, launchId));
     // Retention runs here, on the listing path, never on the action hot path:

package/dist/lib/config-keys.d.ts

@@ -16,7 +16,7 @@ export type ConfigScope = 'run' | 'interactive' | 'auto' | 'browser' | 'project'
  * CONFIG_KEYS (user scope); this list is only the parser's allow-set so an
  * unknown `menubar.menu.<x>` fails loud here instead of at the store.
  */
-export declare const MENUBAR_MENU_PROPERTIES: readonly ["defaultProject", "workingRowsShown", "showPreviews", "projectPriorityFilter", "hideCompletedMilestones", "bannerWhenNeedsYou", "includeOtherDeviceRequests", "groupBy", "thenBy", "projectScope", "projectSort", "ticketSort", "showPullRequests"];
+export declare const MENUBAR_MENU_PROPERTIES: readonly ["defaultProject", "workingRowsShown", "showPreviews", "projectPriorityFilter", "hideCompletedMilestones", "bannerWhenNeedsYou", "includeOtherDeviceRequests", "groupBy", "thenBy", "projectScope", "projectSort", "ticketSort", "showPullRequests", "sessionUpdates", "deviceSort", "headlessAgent", "headlessFallbackAgent", "headlessPlacement"];
 /** A run-time default key: model, mode, effort, or tier override. */
 export interface ParsedRunConfigKey {
     scope: 'run';

package/dist/lib/config-keys.js

@@ -29,6 +29,11 @@ export const MENUBAR_MENU_PROPERTIES = [
     'projectSort',
     'ticketSort',
     'showPullRequests',
+    'sessionUpdates',
+    'deviceSort',
+    'headlessAgent',
+    'headlessFallbackAgent',
+    'headlessPlacement',
 ];
 const DEVICE_CONFIG_PROPERTIES = [
     'browser.viewer',

package/dist/lib/daemon/daemon.js

@@ -878,7 +878,7 @@ export async function runDaemon() {
     assertTestDaemonHome();
     // Lifecycle readers and launchers do not run services. Load their code only
     // in the daemon process, before it claims or publishes lifecycle state.
-    const [{ BrowserService }, { SessionIndexService }, { SessionSummarizerService }, { SessionTitleService }, { MonitorEngineService }, { AccountUsageService, AccountAuthService }, { CatchupService }, { BrowserIPCService }, { WatchdogService }, { DeviceProbeService }, { SelfHealService }, { SelfUpdateService }, { HarnessUpdateService }, { AuthSyncService }, { UsageSyncService }, { StateDirCheckService }, { SessionStateService }, { AttentionNotifyService }, { WebhookReceiverService }, { HeartbeatService }, { TmuxReapService }, { BrowserTaskReapService },] = await Promise.all([
+    const [{ BrowserService }, { SessionIndexService }, { SessionSummarizerService }, { SessionTitleService }, { MonitorEngineService }, { AccountUsageService, AccountAuthService }, { CatchupService }, { BrowserIPCService }, { WatchdogService }, { DeviceProbeService }, { SelfHealService }, { SelfUpdateService }, { HarnessUpdateService }, { AuthSyncService }, { UsageSyncService }, { StateDirCheckService }, { SessionStateService }, { FeedStreamService }, { AttentionNotifyService }, { WebhookReceiverService }, { HeartbeatService }, { TmuxReapService }, { BrowserTaskReapService },] = await Promise.all([
         import('../browser/service.js'),
         import('./session-index-service.js'),
         import('./session-summarizer-service.js'),
@@ -896,6 +896,7 @@ export async function runDaemon() {
         import('./usage-sync-service.js'),
         import('./state-dir-check-service.js'),
         import('./session-state-service.js'),
+        import('./feed-stream-service.js'),
         import('./attention-notify-service.js'),
         import('./webhook-receiver-service.js'),
         import('./heartbeat-service.js'),
@@ -1021,6 +1022,12 @@ export async function runDaemon() {
     }
     else
         log('INFO', 'Live session-state service disabled');
+    // The shared feed fan-out. Registered even when disabled at boot so a later
+    // `agents daemon services enable feed-stream` brings it up over SIGHUP, the
+    // same live-transition shape browser IPC uses.
+    supervisor.register(new FeedStreamService(), { enabled: isEnabled('feed-stream') });
+    if (!isEnabled('feed-stream'))
+        log('INFO', 'Shared feed stream service disabled');
     const monitorEngineSvc = new MonitorEngineService();
     if (isEnabled('monitors'))
         supervisor.register(monitorEngineSvc);

package/dist/lib/daemon/feed-stream-service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The shared feed collector's lifecycle as a `DaemonService`.
+ *
+ * WHY THE DAEMON OWNS IT. Dialing every peer over ssh and holding those
+ * connections open is an ACTION on the fleet, so by the repo's one-scheduler /
+ * one-executor rule it belongs to the daemon and not to a UI surface. Before
+ * this service, every consumer of `agents feed watch --json` ran its own
+ * `watchFleetFeed`, which is N ssh children per peer for N readers. The daemon
+ * runs one, and the readers attach over a socket (`feed/hub-server.ts`).
+ *
+ * The server binds on start, but the fan-out itself is DEMAND-GATED by the hub:
+ * with no client connected there is no `watchFleetFeed`, so an idle box holds no
+ * peer connections — the same idle-cost rule `SessionStateService` follows for
+ * its gather.
+ */
+import { BaseDaemonService, type DaemonContext } from './service.js';
+import type { DaemonServiceId } from '../daemon-services.js';
+export declare class FeedStreamService extends BaseDaemonService {
+    readonly id: DaemonServiceId;
+    private server;
+    protected onStart(ctx: DaemonContext): Promise<void>;
+    protected onStop(): Promise<void>;
+}

package/dist/lib/daemon/feed-stream-service.js

@@ -0,0 +1,40 @@
+/**
+ * The shared feed collector's lifecycle as a `DaemonService`.
+ *
+ * WHY THE DAEMON OWNS IT. Dialing every peer over ssh and holding those
+ * connections open is an ACTION on the fleet, so by the repo's one-scheduler /
+ * one-executor rule it belongs to the daemon and not to a UI surface. Before
+ * this service, every consumer of `agents feed watch --json` ran its own
+ * `watchFleetFeed`, which is N ssh children per peer for N readers. The daemon
+ * runs one, and the readers attach over a socket (`feed/hub-server.ts`).
+ *
+ * The server binds on start, but the fan-out itself is DEMAND-GATED by the hub:
+ * with no client connected there is no `watchFleetFeed`, so an idle box holds no
+ * peer connections — the same idle-cost rule `SessionStateService` follows for
+ * its gather.
+ */
+import { BaseDaemonService } from './service.js';
+import { FeedHub } from '../feed/hub.js';
+import { FeedHubServer } from '../feed/hub-server.js';
+import { sharedLocalFeedHub, watchFleetFeed } from '../feed/watch.js';
+export class FeedStreamService extends BaseDaemonService {
+    id = 'feed-stream';
+    server = null;
+    async onStart(ctx) {
+        // Two collectors, one socket. The fleet hub holds one ssh child per peer plus
+        // this box's rows; the local hub is this box ONLY and cannot fan out, so a
+        // reader that wants just this machine never causes a peer dial. They are
+        // separate hubs rather than one filtered stream because demand must be
+        // separate too: a local-only reader must not start the fleet fan-out.
+        const fleet = new FeedHub({ watch: watchFleetFeed });
+        this.server = new FeedHubServer(fleet, undefined, sharedLocalFeedHub());
+        await this.server.start();
+        ctx.log('INFO', 'Feed stream hub listening (fan-out starts on first reader)');
+    }
+    async onStop() {
+        const server = this.server;
+        this.server = null;
+        if (server)
+            await server.stop();
+    }
+}

package/dist/lib/daemon-services.d.ts

@@ -7,7 +7,7 @@
  * enabled without pulling in the whole daemon lifecycle.
  */
 /** Every service the daemon can host. IDs are kebab-case and stable. */
-export type DaemonServiceId = 'scheduler' | 'catchup' | 'monitors' | 'browser-ipc' | 'webhook-receiver' | 'self-heal' | 'self-update' | 'account-state' | 'account-auth' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'session-title' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'browser-task-reap' | 'session-state' | 'session-summarizer' | 'attention-notify' | 'harness-update';
+export type DaemonServiceId = 'scheduler' | 'catchup' | 'monitors' | 'browser-ipc' | 'webhook-receiver' | 'self-heal' | 'self-update' | 'account-state' | 'account-auth' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'session-title' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'browser-task-reap' | 'session-state' | 'feed-stream' | 'session-summarizer' | 'attention-notify' | 'harness-update';
 /** Human-readable metadata for each service. */
 interface DaemonServiceDef {
     id: DaemonServiceId;

package/dist/lib/daemon-services.js

@@ -92,6 +92,11 @@ export const DAEMON_SERVICES = [
         title: 'Live session state',
         description: 'Publishes this host\'s active session metadata for sessions watch and fleet consumers.',
     },
+    {
+        id: 'feed-stream',
+        title: 'Shared feed stream',
+        description: 'Owns the one fleet feed fan-out and serves it to every reader over a socket, so N consumers cost one ssh per peer instead of N.',
+    },
     {
         id: 'session-index',
         title: 'Session-index warm',