@phnx-labs/agents-cli 1.22.83 → 1.22.85

package/dist/lib/feed/activity-stream.js

@@ -0,0 +1,271 @@
+/**
+ * Incremental reader for the activity log directory.
+ *
+ * `readRecentActivity` answers "what happened since T?" by tailing and parsing
+ * every session log in the directory. That is the right shape for a one-shot
+ * `agents feed` render and the wrong shape for `agents feed watch`, which asks
+ * the same question twice a second for as long as a VS Code window is open: on
+ * a real operator box the directory holds 1,437 logs / 64 MB, so every tick
+ * re-read and re-parsed the whole corpus to emit, almost always, nothing.
+ *
+ * This reader keeps a per-file cursor instead. The opening scan opens no files
+ * at all — it records each log's size, inode, and mtime — so only bytes appended
+ * *after* the stream started are ever read. Steady-state cost is one `stat` per
+ * changed file plus a parse of exactly the appended bytes.
+ *
+ * The emitted events, their order, and the `sinceMs` filter match
+ * `readRecentActivity` for everything appended while the stream is open; the
+ * equivalence is pinned by `activity-stream.test.ts`.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getActivityDir } from '../state.js';
+import { ACTIVITY_TAIL_BYTES, parseActivityLine } from './activity.js';
+/** How often the stream falls back to a full directory stat sweep. */
+export const ACTIVITY_SWEEP_MS = 5_000;
+/** Bytes behind the cursor re-verified before appended bytes are trusted. */
+export const ACTIVITY_ANCHOR_BYTES = 64;
+const NEWLINE = 0x0a;
+const EMPTY = Buffer.alloc(0);
+/** Could this file have changed since its cursor last looked? */
+function changed(cursor, stat) {
+    return stat.identity !== cursor.identity
+        || stat.size !== cursor.size
+        || stat.mtimeNs !== cursor.mtimeNs
+        || stat.ctimeNs !== cursor.ctimeNs;
+}
+/**
+ * A cursor over the activity directory. Construct it at the moment the caller's
+ * activity cursor starts, then call {@link read} once per tick.
+ */
+export class ActivityStream {
+    dir;
+    maxBytesPerRead;
+    sweepMs;
+    cursors = new Map();
+    dirty = new Set();
+    watcher;
+    watchRequested;
+    lastSweepMs = 0;
+    /** False during the opening scan, so it registers history without reading it. */
+    started = false;
+    /** Bytes read from activity logs since construction. Observability + tests. */
+    bytesRead = 0;
+    constructor(options = {}) {
+        this.dir = options.root ?? getActivityDir();
+        this.maxBytesPerRead = options.maxBytesPerRead ?? ACTIVITY_TAIL_BYTES;
+        this.sweepMs = options.sweepMs ?? ACTIVITY_SWEEP_MS;
+        this.watchRequested = options.watch ?? true;
+        this.sweep(Date.now());
+        this.armWatcher();
+    }
+    /**
+     * Events appended since the last call, newest first, filtered to `sinceMs`
+     * inclusive — the same shape and order `readRecentActivity({ sinceMs })`
+     * returns for those events.
+     */
+    read(sinceMs, nowMs = Date.now()) {
+        const out = [];
+        for (const name of this.candidates(nowMs)) {
+            for (const event of this.readFile(name)) {
+                const at = Date.parse(event.ts);
+                if (Number.isFinite(at) && at >= sinceMs)
+                    out.push(event);
+            }
+        }
+        out.sort((a, b) => Date.parse(b.ts) - Date.parse(a.ts));
+        return out;
+    }
+    /** Release the directory watcher. Safe to call more than once. */
+    close() {
+        this.watchRequested = false;
+        this.watcher?.close();
+        this.watcher = undefined;
+    }
+    /** Which log names could have changed since the previous tick. */
+    candidates(nowMs) {
+        // A watcher that never armed (unsupported filesystem, or a directory that
+        // did not exist at construction) means every tick sweeps. That is the
+        // fallback: never a silent no-op that would drop events.
+        if (!this.watcher)
+            this.armWatcher();
+        if (!this.watcher || nowMs - this.lastSweepMs >= this.sweepMs)
+            this.sweep(nowMs);
+        const names = [...this.dirty];
+        this.dirty.clear();
+        return names;
+    }
+    /**
+     * Stat every log, marking the ones that could have changed. Opens nothing: a
+     * log the opening scan sees is registered past its own bytes, so history is
+     * never replayed onto the stream.
+     */
+    sweep(nowMs) {
+        this.lastSweepMs = nowMs;
+        let names;
+        try {
+            names = fs.readdirSync(this.dir).filter((name) => name.endsWith('.jsonl'));
+        }
+        catch {
+            return; // The directory appears with the first logged event.
+        }
+        const seen = new Set();
+        for (const name of names) {
+            seen.add(name);
+            const stat = this.statOf(name);
+            if (!stat)
+                continue;
+            const cursor = this.cursors.get(name);
+            if (!cursor) {
+                // A log first seen after the opening scan is new work: left
+                // unregistered so `readFile` opens it from a bounded tail.
+                if (this.started)
+                    this.dirty.add(name);
+                else
+                    this.cursors.set(name, {
+                        identity: stat.identity, offset: stat.size, partial: EMPTY, partialIsFragment: false,
+                        anchor: EMPTY, size: stat.size, mtimeNs: stat.mtimeNs, ctimeNs: stat.ctimeNs,
+                    });
+                continue;
+            }
+            if (changed(cursor, stat))
+                this.dirty.add(name);
+        }
+        // A cursor is dropped only when its log is gone. There is deliberately no
+        // size cap: the map cannot outgrow the directory this sweep already had to
+        // enumerate, so a cap bounds nothing the readdir does not — while dropping
+        // a live log's cursor would re-register it as new work on the next sweep
+        // and replay a bounded tail of it onto the stream as duplicates.
+        for (const name of [...this.cursors.keys()])
+            if (!seen.has(name))
+                this.cursors.delete(name);
+        this.started = true;
+    }
+    statOf(name) {
+        try {
+            const st = fs.statSync(path.join(this.dir, name), { bigint: true });
+            return {
+                identity: `${st.dev}:${st.ino}`,
+                size: Number(st.size),
+                mtimeNs: Number(st.mtimeNs),
+                ctimeNs: Number(st.ctimeNs),
+            };
+        }
+        catch {
+            return undefined; // Deleted between readdir and stat.
+        }
+    }
+    /** A cursor starting at a bounded tail of the file as it stands right now. */
+    freshCursor(stat) {
+        const offset = Math.max(0, stat.size - this.maxBytesPerRead);
+        return {
+            identity: stat.identity, offset, partial: EMPTY, partialIsFragment: offset > 0,
+            anchor: EMPTY, size: stat.size, mtimeNs: stat.mtimeNs, ctimeNs: stat.ctimeNs,
+        };
+    }
+    /** Read and parse only the bytes appended to one log since its cursor. */
+    readFile(name, restarted = false) {
+        const stat = this.statOf(name);
+        if (!stat) {
+            this.cursors.delete(name);
+            return [];
+        }
+        let cursor = this.cursors.get(name);
+        // Unseen, replaced, truncated, or rewritten in place at the same length:
+        // restart from a bounded tail of the file as it now stands. The caller's
+        // `sinceMs` drops whatever predates the stream.
+        //
+        // The same-length case is why ctime is tracked. Growth is caught by the
+        // 64-byte anchor and a shrink by the offset compare, but a rewrite that
+        // lands on exactly the previous size moves neither, and the early return
+        // below would otherwise retire the file for good with content unread.
+        if (!cursor || cursor.identity !== stat.identity || stat.size < cursor.offset
+            || (stat.size === cursor.size && stat.ctimeNs !== cursor.ctimeNs)) {
+            cursor = this.freshCursor(stat);
+            this.cursors.set(name, cursor);
+        }
+        cursor.size = stat.size;
+        cursor.mtimeNs = stat.mtimeNs;
+        cursor.ctimeNs = stat.ctimeNs;
+        if (stat.size <= cursor.offset)
+            return [];
+        // A burst larger than the budget keeps the newest bytes; the skipped span is
+        // exactly what the bounded-tail reader would have dropped as well.
+        const start = Math.max(cursor.offset, stat.size - this.maxBytesPerRead);
+        if (start > cursor.offset) {
+            cursor.partial = EMPTY;
+            cursor.partialIsFragment = true;
+            cursor.anchor = EMPTY;
+        }
+        const verify = Math.min(cursor.anchor.length, start);
+        const buf = this.readRange(name, start - verify, stat.size - start + verify);
+        if (buf === undefined)
+            return []; // Transient I/O error: retry next tick.
+        if (verify > 0 && !buf.subarray(0, verify).equals(cursor.anchor.subarray(cursor.anchor.length - verify))) {
+            // The bytes behind the cursor changed, so this file was rewritten rather
+            // than appended to. Restart it once from a bounded tail.
+            if (restarted)
+                return [];
+            this.cursors.delete(name);
+            return this.readFile(name, true);
+        }
+        const fresh = buf.subarray(verify);
+        cursor.offset = stat.size;
+        cursor.anchor = Buffer.concat([cursor.anchor, fresh]).subarray(-ACTIVITY_ANCHOR_BYTES);
+        const chunk = Buffer.concat([cursor.partial, fresh]);
+        const fragment = cursor.partialIsFragment;
+        const end = chunk.lastIndexOf(NEWLINE);
+        // Hold an unterminated trailing line: the writer appends whole
+        // newline-terminated records (`appendActivityEvent`), so a tail without a
+        // newline is a write in progress and completes on a later tick.
+        cursor.partial = end < 0 ? chunk : chunk.subarray(end + 1);
+        cursor.partialIsFragment = end < 0 ? fragment : false;
+        if (end < 0)
+            return [];
+        const lines = chunk.subarray(0, end).toString('utf-8').split('\n');
+        // A range that began mid-file starts inside a record; that leading fragment
+        // is not one, exactly as the bounded-tail reader drops it.
+        if (fragment)
+            lines.shift();
+        const events = [];
+        for (const line of lines) {
+            const event = parseActivityLine(line);
+            if (event)
+                events.push(event);
+        }
+        return events;
+    }
+    readRange(name, start, length) {
+        let fd;
+        try {
+            fd = fs.openSync(path.join(this.dir, name), 'r');
+            const buf = Buffer.allocUnsafe(length);
+            const read = fs.readSync(fd, buf, 0, length, start);
+            this.bytesRead += read;
+            return buf.subarray(0, read);
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            if (fd !== undefined)
+                fs.closeSync(fd);
+        }
+    }
+    armWatcher() {
+        if (!this.watchRequested || this.watcher)
+            return;
+        try {
+            this.watcher = fs.watch(this.dir, (_event, name) => {
+                if (typeof name === 'string' && name.endsWith('.jsonl'))
+                    this.dirty.add(name);
+            });
+            // A watch error (the directory is removed) degrades to sweeping rather
+            // than taking down the watcher process.
+            this.watcher.on('error', () => { this.watcher?.close(); this.watcher = undefined; });
+        }
+        catch {
+            this.watcher = undefined;
+        }
+    }
+}

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

@@ -129,6 +129,13 @@ export declare function appendActivityEvent(event: Omit<ActivityEvent, 'v' | 'ti
     v?: number;
     tier?: ActivityTier;
 }, root?: string): void;
+/**
+ * Parse one activity log line. Tolerant by design: a blank, corrupt, or
+ * half-written line is skipped rather than failing the whole read.
+ */
+export declare function parseActivityLine(line: string): ActivityEvent | undefined;
+/** Per-session byte budget for a bounded tail read of an activity log. */
+export declare const ACTIVITY_TAIL_BYTES: number;
 /** Read all events for one session (bounded tail). */
 export declare function readSessionActivity(sessionId: string, root?: string, maxBytes?: number): ActivityEvent[];
 /** List session ids that have an activity log. */

package/dist/lib/feed/activity.js

@@ -119,7 +119,11 @@ export function appendActivityEvent(event, root) {
     };
     fs.appendFileSync(activityPath(dir, event.sessionId), `${JSON.stringify(record)}\n`, { mode: 0o644 });
 }
-function parseLine(line) {
+/**
+ * Parse one activity log line. Tolerant by design: a blank, corrupt, or
+ * half-written line is skipped rather than failing the whole read.
+ */
+export function parseActivityLine(line) {
     const trimmed = line.trim();
     if (!trimmed)
         return undefined;
@@ -160,6 +164,8 @@ function parseLine(line) {
         return undefined; // skip corrupt / partial lines (fail-open reader)
     }
 }
+/** Per-session byte budget for a bounded tail read of an activity log. */
+export const ACTIVITY_TAIL_BYTES = 256 * 1024;
 /** Read the tail of a file as UTF-8, bounded to the last `maxBytes`. */
 function readTail(file, maxBytes) {
     let fd;
@@ -232,7 +238,7 @@ function readActivityTail(file, maxBytes, sinceMs = -Infinity) {
     const events = [];
     let newestMs = -Infinity;
     for (const line of text.split('\n')) {
-        const event = parseLine(line);
+        const event = parseActivityLine(line);
         if (!event)
             continue;
         events.push(event);
@@ -277,7 +283,7 @@ function readActivityTail(file, maxBytes, sinceMs = -Infinity) {
     return result;
 }
 /** Read all events for one session (bounded tail). */
-export function readSessionActivity(sessionId, root, maxBytes = 256 * 1024) {
+export function readSessionActivity(sessionId, root, maxBytes = ACTIVITY_TAIL_BYTES) {
     const dir = root ?? getActivityDir();
     return structuredClone(readActivityTail(activityPath(dir, sessionId), maxBytes).events ?? []);
 }
@@ -301,7 +307,7 @@ export function readRecentActivity(opts = {}) {
     const wanted = opts.events && opts.events.length > 0 ? new Set(opts.events) : null;
     const all = [];
     for (const sessionId of listActivitySessions(dir)) {
-        const tail = readActivityTail(activityPath(dir, sessionId), opts.maxBytesPerSession ?? 256 * 1024, sinceMs);
+        const tail = readActivityTail(activityPath(dir, sessionId), opts.maxBytesPerSession ?? ACTIVITY_TAIL_BYTES, sinceMs);
         if (tail.newestMs < sinceMs)
             continue;
         for (const ev of tail.events ?? []) {

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

@@ -1,4 +1,4 @@
-import { type SessionWatchEnvelope, type SessionWatchRow, type SessionWatchScopeStatus } from '../session/watch.js';
+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';
 export declare const FEED_WATCH_VERSION: 1;
@@ -48,12 +48,18 @@ export declare class FeedWatchState {
     emit(event: FeedWatchPayload): FeedWatchEnvelope;
 }
 export declare function projectSessionEnvelope(event: SessionWatchEnvelope, state: FeedWatchState): Promise<FeedWatchEnvelope[]>;
-export declare function watchLocalFeed(options: {
+export interface WatchLocalFeedOptions {
     scope: string;
     signal: AbortSignal;
     emit: (event: FeedWatchEnvelope) => void;
+    /** Activity drain cadence. */
     activityPollMs?: number;
-}): Promise<void>;
+    /** Attention reconcile cadence when nothing has announced a change. */
+    reconcileMs?: number;
+    /** Session-watch inputs, forwarded verbatim to {@link watchLocalSessions}. */
+    sessions?: Pick<WatchLocalOptions, 'readCache' | 'readPrevious' | 'journalPath' | 'journalPollMs' | 'heartbeatMs'>;
+}
+export declare function watchLocalFeed(options: WatchLocalFeedOptions): Promise<void>;
 export declare function watchFleetFeed(options: {
     signal: AbortSignal;
     emit: (event: FeedWatchEnvelope) => void;

package/dist/lib/feed/watch.js

@@ -1,16 +1,17 @@
 import { randomUUID } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 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 { shellQuote } from '../ssh-exec.js';
 import { buildWindowsAgentsCommand, remoteShellFor } from '../hosts/remote-cmd.js';
+import { getFeedDir } from '../state.js';
+import { streamFromPeer } from '../session/remote/peer-stream.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';
+import { ActivityStream } from './activity-stream.js';
+import { PR_STATUS_TTL_MS, readPullRequestStatus } from './pr-status.js';
 export const FEED_WATCH_VERSION = 1;
 export class FeedWatchState {
     streamId;
@@ -64,8 +65,37 @@ export async function projectSessionEnvelope(event, state) {
         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 })];
 }
+/**
+ * Watch the feed dirs that can change attention without a session event: an
+ * `agents feed post --blocked` writes a block, `feed answer` writes a
+ * resolution. Both are external processes, so nothing on the session stream
+ * announces them — this is what lets the reconcile pass be event-driven instead
+ * of a poll over every row twice a second.
+ */
+function watchAttentionStores(onChange) {
+    const feedDir = getFeedDir();
+    const watchers = [];
+    for (const dir of [feedDir, path.join(feedDir, 'resolutions')]) {
+        try {
+            const watcher = fs.watch(dir, () => onChange());
+            // A directory that disappears must not take the watcher process down; the
+            // PR-status cadence below still reconciles on its own timer.
+            watcher.on('error', () => watcher.close());
+            watchers.push(watcher);
+        }
+        catch { /* the dir appears with the first block; the timed pass covers it */ }
+    }
+    return () => { for (const watcher of watchers)
+        watcher.close(); };
+}
 export async function watchLocalFeed(options) {
     const state = new FeedWatchState();
+    // The stream's opening scan registers every log past its own bytes, so the
+    // cursor has to be taken *after* it: a record appended while the scan was
+    // walking the directory is unreadable from the byte cursor, and only a
+    // timestamp taken after the scan classifies it as history rather than
+    // dropping it from a window the caller believes was covered.
+    const activity = new ActivityStream();
     let activityCursor = Date.now();
     const agents = new Map();
     const attention = new Map();
@@ -82,20 +112,34 @@ export async function watchLocalFeed(options) {
                 : state.emit({ type: 'attention.remove', scope: options.scope, rowKey }));
         }
     };
+    // Attention is reconciled when something can actually have changed it — a row
+    // moved, a block/resolution file was written — or when the PR-status TTL has
+    // expired and the cached verdicts are stale. Re-running it every 500 ms cost
+    // two file reads per row per tick and changed nothing.
+    const reconcileMs = options.reconcileMs ?? PR_STATUS_TTL_MS;
+    let attentionDirty = true;
+    let lastReconcileMs = 0;
+    const markAttentionDirty = () => { attentionDirty = true; };
+    const stopAttentionWatch = watchAttentionStores(markAttentionDirty);
     const activityTimer = setInterval(() => {
         pending = pending.then(async () => {
-            const events = readRecentActivity({ sinceMs: activityCursor + 1 }).reverse();
+            const nowMs = Date.now();
+            const events = activity.read(activityCursor + 1, nowMs).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 }));
             }
+            if (!attentionDirty && nowMs - lastReconcileMs < reconcileMs)
+                return;
+            attentionDirty = false;
+            lastReconcileMs = nowMs;
             await reconcileRows();
         });
     }, options.activityPollMs ?? 500);
-    const stopActivity = () => clearInterval(activityTimer);
+    const stopActivity = () => { clearInterval(activityTimer); stopAttentionWatch(); activity.close(); };
     options.signal.addEventListener('abort', stopActivity, { once: true });
     try {
-        await watchLocalSessions({ scope: options.scope, signal: options.signal, emit: (event) => {
+        await watchLocalSessions({ ...options.sessions, scope: options.scope, signal: options.signal, emit: (event) => {
                 if (event.type === 'reset') {
                     agents.clear();
                     for (const row of event.rows)
@@ -156,35 +200,27 @@ export async function watchFleetFeed(options) {
     }
     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 tasks = peers.map((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)
+        return streamFromPeer({
+            device,
+            signal: options.signal,
+            command: remoteFeedWatchCommand(device.platform),
+            backoffBaseMs: options.reconnectMs,
+            onLine: (line) => {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.v !== 1)
+                        return false;
                     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 }); });
-        }
+                    return true;
+                }
+                catch {
+                    return false; /* protocol only */
+                }
+            },
+            onUnavailable: (reason) => options.emit(coordinator.emit({ type: 'scope', capturedAt: Date.now(), scope, status: 'unavailable', reason })),
+        });
     });
     await Promise.all([local, ...tasks]);
 }

package/dist/lib/fleet/apply.d.ts

@@ -8,7 +8,7 @@
  * (`readyProbe`, `bootstrapAgentsCli`, `buildRemoteAgentsInvocation`, `sshExec`).
  */
 import type { DeviceProfile } from '../devices/registry.js';
-import { type RemoteBackend } from '../secrets/push.js';
+import type { RemoteBackend } from '../secrets-types.js';
 import type { DeviceDesired, DeviceProbe, DeviceDiff, FleetAction, FleetPlan, AuthFilePayload } from './types.js';
 /** Strip a version suffix from an agent spec: `claude@latest` -> `claude`. */
 export declare function agentIdOf(spec: string): string;
@@ -149,7 +149,7 @@ export interface ExecContext {
     dryRun?: boolean;
 }
 /** Execute one device's planned actions in order. Real SSH — no mocks. */
-export declare function reconcileDevice(row: DeviceDiff, device: DeviceProfile, ctx: ExecContext): DeviceApplyResult;
+export declare function reconcileDevice(row: DeviceDiff, device: DeviceProfile, ctx: ExecContext): Promise<DeviceApplyResult>;
 /** Run a pool of async tasks with a concurrency cap, preserving input order. */
 export declare function pool<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
 /** Reconcile every device row in parallel (capped). */

package/dist/lib/fleet/apply.js

@@ -8,8 +8,8 @@
  * (`readyProbe`, `bootstrapAgentsCli`, `buildRemoteAgentsInvocation`, `sshExec`).
  */
 import * as os from 'os';
-import { pushBundleToHost } from '../secrets/push.js';
-import { AUTH_BUNDLE_NAME, inspectReservedAuthBundle, isReservedBundleName } from '../secrets/bundles.js';
+import { pushBundleToHost } from '../secrets-client.js';
+import { AUTH_BUNDLE_NAME, inspectReservedAuthBundle, isReservedBundleName } from '../secrets-policy.js';
 import { deviceIdentityArgs, sshTargetFor } from '../devices/connect.js';
 import { readyProbe, bootstrapAgentsCli } from '../hosts/ready.js';
 import { buildRemoteAgentsInvocation } from '../hosts/remote-cmd.js';
@@ -371,7 +371,7 @@ export function parseRemoteBundles(stdout) {
     }
 }
 /** Execute one device's planned actions in order. Real SSH — no mocks. */
-export function reconcileDevice(row, device, ctx) {
+export async function reconcileDevice(row, device, ctx) {
     if (!row.probe.reachable) {
         return { device: row.device, ok: false, steps: [], note: row.probe.note ?? 'unreachable' };
     }
@@ -438,7 +438,7 @@ export function reconcileDevice(row, device, ctx) {
         }
         const backend = isReservedBundleName(bundle) || device.platform === 'linux' ? 'file' : 'keychain';
         try {
-            const out = pushBundleToHost(bundle, target, {
+            const out = await pushBundleToHost(bundle, target, {
                 remoteBackend: backend,
                 operation: `fleet apply ${row.device}`,
                 // No passphrase, ever, from this path. On the file backend the remote

package/dist/lib/fleet/auth-sync.js

@@ -138,9 +138,10 @@ export const FLEET_LOGIN_FLOWS = {
     // claude: interactive `/login` inside the TUI is a loopback browser flow, and
     // the token is keychain-bound on macOS. That native login stays per-box and
     // is never copied. The shareable `claude setup-token` mint is a different
-    // credential class — wired as `agents accounts mint claude` / `agents auth mint`
-    // (`lib/auth-mint.ts`), not as a fleet-login device-code flow (a setup-token
-    // is account-scoped, not per-machine).
+    // credential class — minted by `agents accounts add claude [name]` /
+    // `agents accounts login claude#<name>` (`lib/auth-mint.ts`), not as a
+    // fleet-login device-code flow (a setup-token is account-scoped, not
+    // per-machine).
     claude: {
         loginCommand: 'claude',
         flowType: 'loopback',

package/dist/lib/fleet-shared-repo-sync.js

@@ -267,15 +267,12 @@ async function performFleetSharedRepoSync(root, device, timeoutMs) {
     }
     const ownedFile = fleetSharedStatePath(device, root);
     const relativeOwnedFile = path.relative(root, ownedFile).split(path.sep).join('/');
-    // The central `agents.yaml` is fleet-shared state too — `agents accounts label`
-    // writes version-scoped native account rows there (lib/state.ts writeMetaUnlocked),
-    // as a plain file write with no commit. Publishing only the per-device file and
-    // then `rebase --autostash`-ing over a dirty central file silently destroyed
-    // those labels: every box lost its account labels on its next daemon publish
-    // (PHNX-3887). Commit it alongside the device doc so the rebase carries the
-    // rows instead of stashing them, which is also what `accounts label --help`
-    // already promises ("labels live on the central account rows in agents.yaml,
-    // which repo push/pull already syncs fleet-wide").
+    // The central `agents.yaml` is fleet-shared state too — native account rows
+    // land there (lib/state.ts writeMetaUnlocked) as a plain file write with no
+    // commit. Publishing only the per-device file and then `rebase --autostash`-ing
+    // over a dirty central file silently destroyed those names: every box lost its
+    // account names on its next daemon publish (PHNX-3887). Commit it alongside the
+    // device doc so the rebase carries the rows instead of stashing them.
     const centralFile = path.join(root, 'agents.yaml');
     const publishPaths = [relativeOwnedFile];
     if (fs.existsSync(centralFile))

package/dist/lib/fleet-shared-state.d.ts

@@ -34,6 +34,12 @@ export interface SessionMirrorRow {
     summaryChecklist?: import('./session/types.js').SessionChecklistItem[];
     /** Lifecycle of the daemon-computed summary (PHNX-3939). */
     summaryState?: import('./session/types.js').SummaryState;
+    /** Tidied latest user turn, so a peer row shows what the agent was asked (PHNX-3939). */
+    request?: import('./session/types.js').SessionRequest;
+    /** Bounded narration-anchored steps, so a peer row shows what the agent did. */
+    timeline?: import('./session/types.js').SessionTimeline;
+    /** Bounded file-change list for the peer row. */
+    files?: import('./session/types.js').SessionFiles;
     capturedAt: number;
 }
 export interface FleetSharedDeviceState {

package/dist/lib/harness/adapter.d.ts

@@ -150,16 +150,16 @@ export interface HarnessAdapter {
     routineModeArgs?(cmd: string[], ctx: RoutineLaunchCtx): void;
 }
 /**
- * The four config-dir env keys a harness pins to its version home. Every
- * per-harness branch in the old buildExecEnv deleted the ones it does NOT set,
- * so its own config pointer never leaks into a foreign harness's invocation.
- * (XDG_CONFIG_HOME / XDG_DATA_HOME — Muse/Cursor — are deliberately absent: the
- * old code sets them but never strips them, and this preserves that exactly.)
+ * Config-dir env keys a harness pins to its slot / version home. Every
+ * per-harness branch in buildExecEnv deletes the ones it does NOT set, so a
+ * slot never inherits another account's dir (PHNX-3940 T5). GROK_HOME,
+ * OPENCODE_CONFIG_DIR, and the XDG pair were previously omitted, which let a
+ * parent agent's pin leak into a sibling slot.
  */
-export declare const CONFIG_DIR_ENV_KEYS: readonly ["CLAUDE_CONFIG_DIR", "CODEX_HOME", "COPILOT_HOME", "KIMI_CODE_HOME"];
+export declare const CONFIG_DIR_ENV_KEYS: readonly ["CLAUDE_CONFIG_DIR", "CODEX_HOME", "COPILOT_HOME", "KIMI_CODE_HOME", "GROK_HOME", "OPENCODE_CONFIG_DIR", "XDG_CONFIG_HOME", "XDG_DATA_HOME"];
 /**
  * Strip every config-dir env key except the one(s) this harness sets. `keep=[]`
- * (the default / no-config-dir harness) deletes all four — the old `else` arm.
+ * (the default / no-config-dir harness) deletes all of them — the old `else` arm.
  */
 export declare function stripForeignConfigDir(result: NodeJS.ProcessEnv, keep?: readonly string[]): void;
 export declare function registerHarnessAdapter(adapter: HarnessAdapter): void;