@phnx-labs/agents-cli 1.22.46 → 1.22.47

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

@@ -30,12 +30,54 @@ export interface AnswerRecord {
     /** Whether the operator identity was verified against the registry. */
     verified?: boolean;
 }
+/**
+ * Where an attention record came from, strongest evidence first.
+ *   hook      — a harness event (AskUserQuestion / permission / notification).
+ *   declared  — the agent said it is stuck (`agents feed post --blocked`).
+ *   lifecycle — a structural session signal (plan handoff / permission wait).
+ *   heuristic — an inferred prose question that decays.
+ *   system    — a synthetic card the feed computed (runaway / needy / PR review).
+ */
+export type AttentionSource = 'hook' | 'declared' | 'lifecycle' | 'heuristic' | 'system';
+/**
+ * The lifecycle state of an attention record. A block is `open` until it is
+ * answered from some surface, `answered` once a surface claimed it, `consumed`
+ * once the agent read the reply, `continued` once the agent moved on, and
+ * `resolved` for a terminal clear (the block file is being removed). This is the
+ * axis the operator projection ranks on — only `open` needs a human.
+ */
+export type AttentionState = 'open' | 'answered' | 'consumed' | 'continued' | 'resolved';
+/**
+ * A cursor into the source that produced a block — the transcript's last write
+ * (`lastActivityMs`) or a specific transcript `eventId`. It is what lets a
+ * resolution tombstone say "this generation was resolved at THIS point" so a
+ * stale lifecycle re-read cannot resurrect it while the session sits still, yet
+ * a genuinely newer turn (a strictly later cursor) is allowed through as a new
+ * generation. See {@link AttentionResolution} and `reconcileAttention`.
+ */
+export interface SourceCursor {
+    lastActivityMs?: number;
+    eventId?: string;
+}
 export interface OpenBlock {
     blockId: string;
     sessionId: string;
     mailboxId: string;
     host: string;
     runtime: string;
+    /**
+     * Generation key for this block's CURRENT question. A new AskUserQuestion (or a
+     * new `--blocked` post) in the same session mints a new generation, so a
+     * resolution tombstone for the previous generation cannot suppress the fresh
+     * ask. Derived from `ts` when a writer did not stamp it — see {@link blockGeneration}.
+     */
+    generation?: string;
+    /** How this block came to exist. Derived from {@link kind} when absent — see {@link blockSource}. */
+    source?: AttentionSource;
+    /** Lifecycle state. Derived from the answer/continue markers when absent — see {@link deriveBlockState}. */
+    state?: AttentionState;
+    /** Where in the source this block's generation sits — carried onto its resolution tombstone. */
+    sourceCursor?: SourceCursor;
     /** Indexed launch origin, added at read time when the live session is known. */
     origin?: 'cli' | 'routine';
     /** Routine definition name when origin is `routine`. */
@@ -121,6 +163,66 @@ export interface FeedAskStats {
     totalAskCount: number;
     recentAskTimestamps: string[];
 }
+/**
+ * Why an attention generation stopped needing a human — a resolution tombstone.
+ *   answered        — a surface recorded an answer.
+ *   continued       — the agent consumed the answer and moved on.
+ *   tool_completed  — the tool an approval gated finished (permission cleared).
+ *   expired         — a decaying heuristic ask aged out.
+ *   session_advanced— the transcript moved past the block (Stop/PostToolUse clear).
+ */
+export type ResolutionReason = 'answered' | 'continued' | 'tool_completed' | 'expired' | 'session_advanced';
+/**
+ * A resolution tombstone. It is recorded BEFORE the open-block view is cleared so
+ * a resolved generation can never silently resurrect from a stale lifecycle
+ * re-read (the RUSH-1522 stale-flag class): the reconciler suppresses a
+ * lifecycle candidate whose generation the tombstone already covers, until the
+ * session advances strictly past `sourceCursor`. One tombstone per block id,
+ * latest-wins — the block id is stable per session, so this never grows unbounded.
+ */
+export interface AttentionResolution {
+    blockId: string;
+    /** The generation this tombstone resolved — matched against a fresh candidate's generation. */
+    generation: string;
+    /** ISO-8601 timestamp of the resolution. */
+    resolvedAt: string;
+    /** Where in the source the resolved generation sat; the reconciler compares a candidate's cursor against it. */
+    sourceCursor?: SourceCursor;
+    reason: ResolutionReason;
+}
+/**
+ * Canonical generation for a block. A writer that stamped `generation` wins;
+ * otherwise the publish timestamp `ts` is the generation, because the feed
+ * rewrites `ts` only when a NEW question replaces the old one (an answer/continue
+ * update to the same block keeps `ts`). So `ts` changes exactly when the ask
+ * changes — which is what a generation must track.
+ */
+export declare function blockGeneration(block: OpenBlock): string;
+/**
+ * Canonical source for a block. A writer that stamped `source` wins; otherwise it
+ * is derived from `kind`: a declared block is `declared`, a synthetic control card
+ * is `system`, everything else (question / notification, written by a harness hook)
+ * is `hook`.
+ */
+export declare function blockSource(block: OpenBlock): AttentionSource;
+/**
+ * Canonical lifecycle state for a block. A writer that stamped `state` wins;
+ * otherwise it is derived from the markers already on the block: `continuedAt`
+ * means `continued`, a recorded `answer` means `answered`, and anything else is
+ * still `open`. This is the ONE place that turns the historical marker fields into
+ * the lifecycle axis, so no consumer re-derives it and drifts.
+ */
+export declare function deriveBlockState(block: OpenBlock): AttentionState;
+/**
+ * Record a resolution tombstone (latest-wins per block id). Called from the
+ * answer / continue / clear paths BEFORE the open-block view is removed, so the
+ * reconciler always has the tombstone by the time the block file is gone.
+ */
+export declare function recordResolution(resolution: AttentionResolution, root?: string): void;
+/** Read the latest resolution tombstone for a block, if one exists. */
+export declare function readResolution(blockId: string, root?: string): AttentionResolution | undefined;
+/** Read every resolution tombstone. Returns them sorted by stable block filename. */
+export declare function listResolutions(root?: string): AttentionResolution[];
 /**
  * Stable block id for a session. One block per session -- a new question
  * replaces the previous one (the agent can only ask one question at a time).
@@ -155,6 +257,13 @@ export declare function recordAnswer(blockId: string, answer: {
 }, root?: string): RecordAnswerResult;
 /** Read the answer record for a block, if one exists. */
 export declare function getAnswerRecord(blockId: string, root?: string): AnswerRecord | undefined;
+/**
+ * Release one specific answer claim after its reply rail failed. The compare on
+ * `answeredAt` makes this a conditional rollback: it can never erase a newer
+ * claimant. The caller supplies the exact pre-claim block/resolution snapshots,
+ * restoring the attention lifecycle to the state another surface observed.
+ */
+export declare function rollbackAnswerClaim(blockId: string, answeredAt: string, previousBlock: OpenBlock, previousResolution: AttentionResolution | undefined, root?: string): boolean;
 /** True when the block has already been answered. */
 export declare function isBlockAnswered(blockId: string, root?: string): boolean;
 /**

package/dist/lib/feed/feed.js

@@ -29,6 +29,80 @@ import { getFeedDir, getUserAgentsDir } from '../state.js';
 import { isAdmin, isHighConsequenceAllowed, isKnownOperator } from '../operator.js';
 import { projectKeyFromCwd } from '../project-key.js';
 import { atomicWriteJsonSync } from '../fs-atomic.js';
+function resolutionDir(root) { return path.join(root, 'resolutions'); }
+/**
+ * Canonical generation for a block. A writer that stamped `generation` wins;
+ * otherwise the publish timestamp `ts` is the generation, because the feed
+ * rewrites `ts` only when a NEW question replaces the old one (an answer/continue
+ * update to the same block keeps `ts`). So `ts` changes exactly when the ask
+ * changes — which is what a generation must track.
+ */
+export function blockGeneration(block) {
+    return block.generation ?? block.ts;
+}
+/**
+ * Canonical source for a block. A writer that stamped `source` wins; otherwise it
+ * is derived from `kind`: a declared block is `declared`, a synthetic control card
+ * is `system`, everything else (question / notification, written by a harness hook)
+ * is `hook`.
+ */
+export function blockSource(block) {
+    if (block.source)
+        return block.source;
+    switch (block.kind) {
+        case 'declared': return 'declared';
+        case 'control': return 'system';
+        default: return 'hook';
+    }
+}
+/**
+ * Canonical lifecycle state for a block. A writer that stamped `state` wins;
+ * otherwise it is derived from the markers already on the block: `continuedAt`
+ * means `continued`, a recorded `answer` means `answered`, and anything else is
+ * still `open`. This is the ONE place that turns the historical marker fields into
+ * the lifecycle axis, so no consumer re-derives it and drifts.
+ */
+export function deriveBlockState(block) {
+    if (block.state)
+        return block.state;
+    if (block.continuedAt)
+        return 'continued';
+    if (block.answer)
+        return 'answered';
+    return 'open';
+}
+/**
+ * Record a resolution tombstone (latest-wins per block id). Called from the
+ * answer / continue / clear paths BEFORE the open-block view is removed, so the
+ * reconciler always has the tombstone by the time the block file is gone.
+ */
+export function recordResolution(resolution, root) {
+    const dir = resolutionDir(root ?? getFeedDir());
+    ensureDir(dir);
+    atomicWriteJsonSync(path.join(dir, `${resolution.blockId}.json`), resolution);
+}
+/** Read the latest resolution tombstone for a block, if one exists. */
+export function readResolution(blockId, root) {
+    return safeReadJson(path.join(resolutionDir(root ?? getFeedDir()), `${blockId}.json`));
+}
+/** Read every resolution tombstone. Returns them sorted by stable block filename. */
+export function listResolutions(root) {
+    const dir = resolutionDir(root ?? getFeedDir());
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names.filter(n => n.endsWith('.json')).sort()) {
+        const parsed = safeReadJson(path.join(dir, name));
+        if (parsed?.blockId && parsed.generation && parsed.reason)
+            out.push(parsed);
+    }
+    return out;
+}
 /**
  * Stable block id for a session. One block per session -- a new question
  * replaces the previous one (the agent can only ask one question at a time).
@@ -131,9 +205,20 @@ export function recordAnswer(blockId, answer, root) {
         }
         throw err;
     }
-    // Marker created successfully -- mirror the answer into the block file.
+    // Marker created successfully -- mirror the answer into the block file and
+    // advance the lifecycle to `answered`. The resolution tombstone is written
+    // first, so if a stale lifecycle re-read races the block-file update the
+    // reconciler already refuses to resurrect this generation.
     if (block) {
+        recordResolution({
+            blockId,
+            generation: blockGeneration(block),
+            resolvedAt: record.answeredAt,
+            sourceCursor: block.sourceCursor,
+            reason: 'answered',
+        }, dir);
         block.answer = record;
+        block.state = 'answered';
         publishBlock(block, dir);
     }
     return { ok: true };
@@ -142,6 +227,37 @@ export function recordAnswer(blockId, answer, root) {
 export function getAnswerRecord(blockId, root) {
     return safeReadJson(path.join(answeredDir(root ?? getFeedDir()), `${blockId}.json`));
 }
+/**
+ * Release one specific answer claim after its reply rail failed. The compare on
+ * `answeredAt` makes this a conditional rollback: it can never erase a newer
+ * claimant. The caller supplies the exact pre-claim block/resolution snapshots,
+ * restoring the attention lifecycle to the state another surface observed.
+ */
+export function rollbackAnswerClaim(blockId, answeredAt, previousBlock, previousResolution, root) {
+    const dir = root ?? getFeedDir();
+    const marker = path.join(answeredDir(dir), `${blockId}.json`);
+    const current = safeReadJson(marker);
+    if (!current || current.answeredAt !== answeredAt)
+        return false;
+    // Restore while the O_EXCL marker still excludes every other claimant. The
+    // marker is removed LAST; once another writer can win recordAnswer, this
+    // rollback has no state left to overwrite.
+    publishBlock(previousBlock, dir);
+    const resolutionFile = path.join(resolutionDir(dir), `${blockId}.json`);
+    if (previousResolution)
+        recordResolution(previousResolution, dir);
+    else {
+        try {
+            fs.unlinkSync(resolutionFile);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    fs.unlinkSync(marker);
+    return true;
+}
 /** True when the block has already been answered. */
 export function isBlockAnswered(blockId, root) {
     return fs.existsSync(path.join(answeredDir(root ?? getFeedDir()), `${blockId}.json`));
@@ -190,7 +306,16 @@ export function recordContinued(blockId, root) {
     const block = readBlock(blockId, dir);
     if (!block)
         return;
-    block.continuedAt = new Date().toISOString();
+    const now = new Date().toISOString();
+    block.continuedAt = now;
+    block.state = 'continued';
+    recordResolution({
+        blockId,
+        generation: blockGeneration(block),
+        resolvedAt: now,
+        sourceCursor: block.sourceCursor,
+        reason: 'continued',
+    }, dir);
     publishBlock(block, dir);
 }
 /** Mark a decision-class block as hard-parked (no safe default existed). */
@@ -260,13 +385,20 @@ export function buildDeclaredBlock(agent, input) {
         .filter(Boolean)
         .map((label) => ({ label }));
     const project = projectKeyFromCwd(agent.cwd);
+    const ts = input.ts ?? new Date().toISOString();
     return {
         blockId: blockIdForSession(agent.sessionId),
         sessionId: agent.sessionId,
         mailboxId: agent.mailboxId,
         host: agent.host,
         runtime: agent.runtime,
-        ts: input.ts ?? new Date().toISOString(),
+        ts,
+        // A declared block is an explicit, agent-raised attention record: it opens the
+        // lifecycle here, sourced `declared`, with `ts` as its generation so a later
+        // `--blocked` in the same session mints a fresh generation past any tombstone.
+        generation: ts,
+        source: 'declared',
+        state: 'open',
         kind: 'declared',
         questions: [{ text, header: 'Needs you', ...(options.length ? { options } : {}) }],
         blockClass: input.safeDefault ? 'approval' : 'decision',
@@ -337,6 +469,25 @@ export function listAskStats(root) {
 /** Remove a block record and its lifecycle sidecars. Returns true if the file was deleted. */
 export function removeBlock(blockId, root) {
     const dir = root ?? getFeedDir();
+    // Record a resolution tombstone BEFORE the block file and answered marker are
+    // gone, so a stale lifecycle re-read of the same session cannot resurrect this
+    // cleared generation. The reason names how it closed: an answered marker means
+    // the operator answered, `continuedAt` means the agent moved on, otherwise the
+    // transcript advanced past it (a Stop/PostToolUse clear). The tombstone itself
+    // is deliberately NOT cleared — it must outlive the block to do its job.
+    const block = readBlock(blockId, dir);
+    if (block) {
+        const reason = isBlockAnswered(blockId, dir)
+            ? 'answered'
+            : block.continuedAt ? 'continued' : 'session_advanced';
+        recordResolution({
+            blockId,
+            generation: blockGeneration(block),
+            resolvedAt: new Date().toISOString(),
+            sourceCursor: block.sourceCursor,
+            reason,
+        }, dir);
+    }
     clearBlockLifecycle(blockId, dir);
     try {
         fs.unlinkSync(blockPath(dir, blockId));

package/dist/lib/feed/pr-status.d.ts

@@ -0,0 +1,14 @@
+import type { ActiveSession } from '../session/active.js';
+import type { PullRequestAttentionSignal } from './attention.js';
+export declare const PR_STATUS_TTL_MS = 45000;
+export declare const PR_STATUS_FIELDS = "number,title,state,isDraft,reviewDecision,mergeable,statusCheckRollup";
+export interface PullRequestStatus extends PullRequestAttentionSignal {
+    statusCheckRollup?: unknown[];
+}
+/** CLI-owned bounded-TTL source shared by feed attention and PR-board consumers. */
+export declare function readPullRequestStatus(session: ActiveSession, options?: {
+    nowMs?: number;
+    ttlMs?: number;
+}): Promise<PullRequestStatus | undefined>;
+export declare function projectPullRequestBoard(sessions: ActiveSession[]): Promise<PullRequestStatus[]>;
+export declare function resetPullRequestStatusCache(): void;

package/dist/lib/feed/pr-status.js

@@ -0,0 +1,47 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export const PR_STATUS_TTL_MS = 45_000;
+export const PR_STATUS_FIELDS = 'number,title,state,isDraft,reviewDecision,mergeable,statusCheckRollup';
+const cache = new Map();
+function needsHuman(value) {
+    if (value.state !== 'OPEN' || value.isDraft)
+        return false;
+    const checks = value.statusCheckRollup ?? [];
+    const checksSettled = checks.every((check) => {
+        const row = check;
+        return row.conclusion === 'SUCCESS' || row.conclusion === 'NEUTRAL' || row.status === 'COMPLETED';
+    });
+    return value.reviewDecision !== 'APPROVED' || (value.mergeable === 'MERGEABLE' && checksSettled);
+}
+/** CLI-owned bounded-TTL source shared by feed attention and PR-board consumers. */
+export async function readPullRequestStatus(session, options = {}) {
+    const ref = session.pr?.url ?? session.pr?.number;
+    if (!ref || !session.cwd)
+        return undefined;
+    const key = `${session.cwd}\0${String(ref)}`;
+    const now = options.nowMs ?? Date.now();
+    const hit = cache.get(key);
+    if (hit && hit.expiresAt > now)
+        return hit.value;
+    try {
+        const { stdout } = await execFileAsync('gh', ['pr', 'view', String(ref), '--json', PR_STATUS_FIELDS], {
+            cwd: session.cwd,
+            timeout: 15_000,
+            maxBuffer: 1024 * 1024,
+        });
+        const raw = JSON.parse(stdout);
+        const value = { ...raw, url: session.pr?.url, needsHuman: needsHuman(raw) };
+        cache.set(key, { expiresAt: now + (options.ttlMs ?? PR_STATUS_TTL_MS), value });
+        return value;
+    }
+    catch {
+        cache.set(key, { expiresAt: now + (options.ttlMs ?? PR_STATUS_TTL_MS) });
+        return undefined;
+    }
+}
+export async function projectPullRequestBoard(sessions) {
+    const rows = await Promise.all(sessions.map((session) => readPullRequestStatus(session)));
+    return rows.filter((row) => row !== undefined);
+}
+export function resetPullRequestStatusCache() { cache.clear(); }

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

@@ -0,0 +1,59 @@
+import { type SessionWatchEnvelope, type SessionWatchRow, type SessionWatchScopeStatus } from '../session/watch.js';
+import { type AttentionItem } from './attention.js';
+import { type ActivityEvent } from './activity.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: '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 declare function projectSessionEnvelope(event: SessionWatchEnvelope, state: FeedWatchState): Promise<FeedWatchEnvelope[]>;
+export declare function watchLocalFeed(options: {
+    scope: string;
+    signal: AbortSignal;
+    emit: (event: FeedWatchEnvelope) => void;
+    activityPollMs?: number;
+}): Promise<void>;
+export declare function watchFleetFeed(options: {
+    signal: AbortSignal;
+    emit: (event: FeedWatchEnvelope) => void;
+    reconnectMs?: number;
+}): Promise<void>;
+export {};

package/dist/lib/feed/watch.js

@@ -0,0 +1,180 @@
+import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { loadDevices, isDialableDevice } from '../devices/registry.js';
+import { deviceIdentityArgs, sshTargetFor } from '../devices/connect.js';
+import { machineId, normalizeHost } from '../machine-id.js';
+import { SSH_OPTS, controlOpts, shellQuote } from '../ssh-exec.js';
+import { buildWindowsAgentsCommand, remoteShellFor } from '../hosts/remote-cmd.js';
+import { watchLocalSessions } from '../session/watch.js';
+import { readBlock, readResolution, blockIdForSession } from './feed.js';
+import { reconcileAttention } from './attention.js';
+import { readRecentActivity } from './activity.js';
+import { readPullRequestStatus } 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 };
+    }
+}
+async function attentionFor(agent) {
+    if (!agent.sessionId)
+        return undefined;
+    const blockId = blockIdForSession(agent.sessionId);
+    // ActiveSession.host names the terminal app; the feed contract's host is the
+    // device scope. Normalize only the reconciler input so lifecycle/PR keys are
+    // routable across the fleet while the projected agent row stays compatible.
+    const session = { ...agent, host: agent.sourceDevice, viewingIn: undefined };
+    return reconcileAttention({
+        block: readBlock(blockId), session,
+        resolution: readResolution(blockId),
+        pullRequest: await readPullRequestStatus(session), nowMs: Date.now(),
+    });
+}
+export async function projectSessionEnvelope(event, state) {
+    if (event.type === 'reset') {
+        const attention = (await Promise.all(event.rows.map(attentionFor))).filter((item) => item !== undefined);
+        return [state.emit({ type: 'reset', capturedAt: event.capturedAt, scope: event.scope, agents: event.rows, attention })];
+    }
+    if (event.type === 'upsert') {
+        const attention = await attentionFor(event.row);
+        return [
+            state.emit({ type: 'agent.upsert', scope: event.scope, rowKey: event.rowKey, agent: event.row }),
+            attention
+                ? state.emit({ type: 'attention.upsert', scope: event.scope, rowKey: event.rowKey, attention })
+                : state.emit({ type: 'attention.remove', scope: event.scope, rowKey: event.rowKey }),
+        ];
+    }
+    if (event.type === 'remove')
+        return [state.emit({ type: 'attention.remove', scope: event.scope, rowKey: event.rowKey })];
+    if (event.type === 'scope')
+        return [state.emit({ type: 'scope', capturedAt: event.capturedAt, scope: event.scope, status: event.status, ...(event.reason ? { reason: event.reason } : {}) })];
+    return [state.emit({ type: 'heartbeat', capturedAt: event.capturedAt, scope: event.scope })];
+}
+export async function watchLocalFeed(options) {
+    const state = new FeedWatchState();
+    let activityCursor = Date.now();
+    const agents = new Map();
+    const attention = new Map();
+    let pending = Promise.resolve();
+    const reconcileRows = async () => {
+        for (const [rowKey, agent] of agents) {
+            const item = await attentionFor(agent);
+            const next = item ? JSON.stringify(item) : '';
+            if (attention.get(rowKey) === next)
+                continue;
+            attention.set(rowKey, next);
+            options.emit(item
+                ? state.emit({ type: 'attention.upsert', scope: options.scope, rowKey, attention: item })
+                : state.emit({ type: 'attention.remove', scope: options.scope, rowKey }));
+        }
+    };
+    const activityTimer = setInterval(() => {
+        pending = pending.then(async () => {
+            const events = readRecentActivity({ sinceMs: activityCursor + 1 }).reverse();
+            for (const event of events) {
+                activityCursor = Math.max(activityCursor, Date.parse(event.ts));
+                options.emit(state.emit({ type: 'activity.append', scope: options.scope, event }));
+            }
+            await reconcileRows();
+        });
+    }, options.activityPollMs ?? 500);
+    const stopActivity = () => clearInterval(activityTimer);
+    options.signal.addEventListener('abort', stopActivity, { once: true });
+    try {
+        await watchLocalSessions({ scope: options.scope, signal: options.signal, emit: (event) => {
+                if (event.type === 'reset') {
+                    agents.clear();
+                    for (const row of event.rows)
+                        agents.set(row.rowKey, row);
+                }
+                else if (event.type === 'upsert')
+                    agents.set(event.rowKey, event.row);
+                else if (event.type === 'remove') {
+                    agents.delete(event.rowKey);
+                    attention.delete(event.rowKey);
+                }
+                pending = pending.then(() => projectSessionEnvelope(event, state)).then((events) => {
+                    for (const projected of events) {
+                        if (projected.type === 'reset') {
+                            attention.clear();
+                            for (const row of projected.agents)
+                                attention.set(row.rowKey, '');
+                            for (const item of projected.attention) {
+                                const row = projected.agents.find((agent) => agent.sessionId === item.sessionId);
+                                if (row)
+                                    attention.set(row.rowKey, JSON.stringify(item));
+                            }
+                        }
+                        else if (projected.type === 'attention.upsert')
+                            attention.set(projected.rowKey, JSON.stringify(projected.attention));
+                        else if (projected.type === 'attention.remove')
+                            attention.set(projected.rowKey, '');
+                        options.emit(projected);
+                    }
+                });
+            } });
+        await pending;
+    }
+    finally {
+        stopActivity();
+    }
+}
+function remoteFeedWatchCommand(os) {
+    const args = ['feed', 'watch', '--json', '--local'];
+    return remoteShellFor(os) === 'powershell'
+        ? buildWindowsAgentsCommand({ args })
+        : `bash -lc ${shellQuote(`agents ${args.map(shellQuote).join(' ')}`)}`;
+}
+export async function watchFleetFeed(options) {
+    const coordinator = new FeedWatchState();
+    const forward = (event) => {
+        const { v: _v, streamId: peerStreamId, sequence: peerSequence, ...payload } = event;
+        options.emit(coordinator.emit({ ...payload, peerStreamId, peerSequence }));
+    };
+    const local = watchLocalFeed({ scope: machineId(), signal: options.signal, emit: forward });
+    let devices;
+    try {
+        devices = await loadDevices();
+    }
+    catch {
+        await local;
+        return;
+    }
+    const self = machineId();
+    const peers = Object.values(devices).filter((device) => isDialableDevice(device) && normalizeHost(device.name) !== self && ['windows', 'linux', 'macos'].includes(device.platform));
+    const tasks = peers.map(async (device) => {
+        const scope = normalizeHost(device.name);
+        while (!options.signal.aborted) {
+            let target;
+            try {
+                target = sshTargetFor(device);
+            }
+            catch (error) {
+                options.emit(coordinator.emit({ type: 'scope', capturedAt: Date.now(), scope, status: 'unavailable', reason: String(error) }));
+                break;
+            }
+            const child = spawn('ssh', [...SSH_OPTS, ...controlOpts(), ...deviceIdentityArgs(device), target, remoteFeedWatchCommand(device.platform)], { stdio: ['ignore', 'pipe', 'ignore'] });
+            const stop = () => child.kill('SIGTERM');
+            options.signal.addEventListener('abort', stop, { once: true });
+            const reader = createInterface({ input: child.stdout });
+            reader.on('line', (line) => { try {
+                const event = JSON.parse(line);
+                if (event.v === 1)
+                    forward(event);
+            }
+            catch { /* protocol only */ } });
+            const code = await new Promise((resolve) => { child.once('error', () => resolve(null)); child.once('close', resolve); });
+            reader.close();
+            options.signal.removeEventListener('abort', stop);
+            if (options.signal.aborted)
+                break;
+            options.emit(coordinator.emit({ type: 'scope', capturedAt: Date.now(), scope, status: 'unavailable', reason: code == null ? 'ssh failed' : `ssh exited ${code}` }));
+            await new Promise((resolve) => { const timer = setTimeout(resolve, options.reconnectMs ?? 2_000); options.signal.addEventListener('abort', () => { clearTimeout(timer); resolve(); }, { once: true }); });
+        }
+    });
+    await Promise.all([local, ...tasks]);
+}

package/dist/lib/fleet/capture.js

@@ -58,6 +58,12 @@ export function captureFleet(prev, inputs) {
     if (prev?.discovery && Object.keys(prev.discovery).length > 0) {
         manifest.discovery = { ...prev.discovery };
     }
+    // Dismissals are operator state, not live state — a capture must never wipe
+    // them (fleet.ignored syncs; losing it re-suggests every dismissed node
+    // fleet-wide). Carry forward verbatim, same contract as `discovery`.
+    if (prev?.ignored && prev.ignored.length > 0) {
+        manifest.ignored = prev.ignored.map((e) => ({ ...e }));
+    }
     const bundles = inputs.secretsBundles ?? prev?.secrets?.bundles;
     if (bundles && bundles.length > 0)
         manifest.secrets = { bundles: [...bundles].sort() };