@phnx-labs/agents-cli 1.22.117 → 1.22.119

package/dist/lib/daemon/usage-sync-service.js

@@ -1,29 +1,24 @@
 /**
- * Fleet shared-state sync as a `PeriodicService` (PHNX-3392 usage-sync,
- * PHNX-3792 session mirror).
+ * Fleet state exchange as a `PeriodicService` (PHNX-3392 usage-sync,
+ * PHNX-3792 session mirror, PHNX-4051 auth verdict, PHNX-4116 SSH transport).
  *
- * This is the ONE tick that owns the bounded Git exchange over the fleet-synced
- * user repo, so every non-secret daemon-state field rides it rather than opening
- * a second committer. Each tick: (1) publishes this box's own fields into its
- * conflict-free `devices/<device>/daemon-state.json` — a headed box's Claude
- * usage snapshot, EVERY box's lightweight session digests (PHNX-3792), and the
- * reserved-auth readiness verdict (PHNX-4051, folded in from the auth-sync tick
- * so a single caller holds the shared-repo lock per tick); (2) runs one
- * serialized, timeout-bounded commit/rebase/push; (3) consumes the peer fields
- * the exchange delivered — a worker merges usage newest-wins, and every
- * non-worker box folds peers' session digests into its local index so the picker
- * renders remote-host previews inline. No tick opens a device-to-device SSH mesh.
+ * Each tick: (1) refreshes every field this box owns in its own
+ * `devices/<device>/daemon-state.json` — a headed box's Claude usage snapshot,
+ * EVERY box's lightweight session digests, and the reserved-auth readiness
+ * verdict; (2) on a headed box (`personal`/`desktop`) only, dials every dialable
+ * peer in parallel with `agents __usage-ingest --reply`, sending that envelope
+ * on stdin and storing each peer's reply as `devices/<peer>/daemon-state.json`
+ * stamped `receivedAt` (`exchangeFleetStateWithPeers`); (3) folds the peers'
+ * session digests into the local index so the picker renders remote-host
+ * previews inline. A worker never initiates: its state leaves the box only as
+ * the reply to a headed peer's dial, and a headed peer's usage rows arrive on
+ * that same dial.
  *
- * Why the auth verdict publishes here (PHNX-4051): auth-sync used to run its OWN
- * `syncFleetSharedStateRepo`, so on every box two ticks 30 s apart contended for
- * the one `proper-lockfile` lock (20×100 ms ≈ 2 s of retries) while a real
- * fetch/rebase/push on a drifted repo runs far longer — the usage tick then
- * failed with "Lock file is already being held" (zion logged it 95× in 24 h) and
- * workers never received a fresh usage snapshot, which the 40-min placement gate
- * turned into "no ready device". Folding the auth verdict into this single
- * committer removes the second caller entirely. Auth-sync keeps its non-git
- * duties (worker-slot reconcile + the credential SSH pushes) under its own
- * deadline and circuit breaker.
+ * There is no git in this tick. The exchange used to be a commit/rebase/push of
+ * the fleet-synced user repo, which needed a cross-process lock, a 45 s
+ * process-tree deadline, an 8-minute kickoff offset from auth-sync to dodge that
+ * lock, and untracked-collision backups — and still wedged every clone behind a
+ * bloated remote. Peers that time out are skipped this tick; none blocks another.
  */
 import { BasePeriodicService } from './service.js';
 import { USAGE_SYNC_INTERVAL_MS } from '../accounting/usage-sync.js';
@@ -37,12 +32,8 @@ import { USAGE_SYNC_INTERVAL_MS } from '../accounting/usage-sync.js';
  */
 export const USAGE_SYNC_TICK_MS = USAGE_SYNC_INTERVAL_MS;
 const USAGE_SYNC_DEADLINE_MS = 2 * 60_000;
-/**
- * Offset from auth-sync's 60s kickoff so the two never contend for the
- * shared-repo lock. Auth fires at T+1m, T+16m, …; usage at T+8m, T+23m, …
- * The git exchange deadline is 45s, so a 7-minute gap is the whole point.
- */
-export const USAGE_SYNC_KICKOFF_MS = 8 * 60_000;
+/** Let the daemon's registry/device probes settle before the first fan-out. */
+export const USAGE_SYNC_KICKOFF_MS = 90_000;
 export class UsageSyncService extends BasePeriodicService {
     id = 'usage-sync';
     intervalMs = USAGE_SYNC_TICK_MS;
@@ -55,57 +46,34 @@ export class UsageSyncService extends BasePeriodicService {
         // Nothing to release — the supervisor's timer teardown is the only cleanup.
     }
     async onTick(ctx) {
-        const { consumeUsageSnapshotsFromSharedStore, publishUsageSnapshotToSharedStore } = await import('../accounting/usage-sync.js');
-        const { consumeSessionMirrorFromSharedStore, publishSessionMirrorToSharedStore } = await import('../session/mirror.js');
-        // Publish every owned field BEFORE the single git exchange so they ride one commit.
-        // Discovered native browser profiles (Arc Spaces, Comet profiles) go into this
-        // device's declaration first, so every other box lists them with WHERE=<here>
-        // and routes a `--profile` for one of them to this machine (PHNX-4042).
-        const { publishDiscoveredProfiles } = await import('../browser/profiles.js');
-        const profiles = await publishDiscoveredProfiles().catch((error) => ({
-            published: [],
-            errors: { publish: error instanceof Error ? error.message : String(error) },
-        }));
-        if (profiles.published.length > 0)
-            ctx.log('INFO', `browser-profiles: published ${profiles.published.join(', ')} to this device's declaration`);
-        for (const [browser, message] of Object.entries(profiles.errors))
-            ctx.log('WARN', `browser-profiles: ${browser}: ${message}`);
-        const published = await publishUsageSnapshotToSharedStore();
-        if (published.changed)
-            ctx.log('INFO', `usage-sync: published usage snapshot to ${published.path}`);
-        if (published.error)
-            ctx.log('WARN', `usage-sync: publish: ${published.error}`);
-        const mirrored = await publishSessionMirrorToSharedStore();
-        if (mirrored.changed)
-            ctx.log('INFO', `session-mirror: published ${mirrored.count} session digest(s)`);
-        if (mirrored.error)
-            ctx.log('WARN', `session-mirror: publish: ${mirrored.error}`);
-        // The reserved-auth readiness verdict rides this single git exchange too
-        // (PHNX-4051): it is a conflict-free field in the same owned daemon-state
-        // file, so publishing it here — instead of from a second committer in
-        // auth-sync — is what keeps exactly one caller of syncFleetSharedStateRepo on
-        // the periodic path.
-        const { publishReservedAuthVerdict } = await import('../secrets-policy.js');
-        const authVerdict = await publishReservedAuthVerdict();
-        if (authVerdict.error)
-            ctx.log('WARN', `usage-sync: auth verdict: ${authVerdict.error}`);
-        const { syncFleetSharedStateRepo } = await import('../fleet-shared-repo-sync.js');
-        const transport = await syncFleetSharedStateRepo();
-        if (transport.skipped)
-            ctx.log('WARN', `usage-sync: ${transport.skipped}`);
-        if (transport.error)
-            ctx.log('WARN', `usage-sync: shared-store transport: ${transport.error}`);
-        if (transport.untrackedBackedUp?.length) {
-            ctx.log('WARN', `usage-sync: backed up ${transport.untrackedBackedUp.length} untracked shared-store collision(s) to ${transport.untrackedBackupDir}: ${transport.untrackedBackedUp.join(', ')}`);
-        }
-        if (!transport.success)
+        const { exchangeFleetStateWithPeers, publishOwnFleetState } = await import('../accounting/usage-sync.js');
+        const { isHeadedDeviceRole, selfConfiguredDeviceRole } = await import('../device-config.js');
+        // Refresh every owned field BEFORE the fan-out so peers receive this tick's state.
+        const published = await publishOwnFleetState();
+        if (published.usage.changed)
+            ctx.log('INFO', `usage-sync: published usage snapshot to ${published.usage.path}`);
+        if (published.mirror.changed)
+            ctx.log('INFO', `session-mirror: published ${published.mirror.count} session digest(s)`);
+        for (const err of published.errors)
+            ctx.log('WARN', `usage-sync: publish ${err}`);
+        if (!isHeadedDeviceRole(selfConfiguredDeviceRole())) {
+            ctx.log('INFO', 'usage-sync: not a headed device; peers dial in with `agents __usage-ingest --reply`, nothing to send');
             return;
-        const consumed = consumeUsageSnapshotsFromSharedStore();
-        if (consumed.merged > 0) {
-            ctx.log('INFO', `usage-sync: merged ${consumed.merged} row(s) from ${consumed.sources.join(', ')}`);
         }
-        for (const err of consumed.errors)
-            ctx.log('WARN', `usage-sync: ${err.device}: ${err.message}`);
+        const exchange = await exchangeFleetStateWithPeers();
+        if (exchange.skipped)
+            ctx.log('WARN', `usage-sync: ${exchange.skipped}`);
+        const delivered = exchange.outcomes.filter((o) => o.delivered);
+        if (delivered.length > 0) {
+            ctx.log('INFO', `usage-sync: exchanged with ${delivered.map((o) => `${o.device}${o.merged ? ` (+${o.merged} usage row(s))` : ''}`).join(', ')}`);
+        }
+        for (const o of exchange.outcomes) {
+            if (o.error)
+                ctx.log('WARN', `usage-sync: ${o.device}: ${o.error}`);
+            for (const err of o.peerErrors)
+                ctx.log('WARN', `usage-sync: ${o.device} reported: ${err}`);
+        }
+        const { consumeSessionMirrorFromSharedStore } = await import('../session/mirror.js');
         const foldedIn = consumeSessionMirrorFromSharedStore();
         if (foldedIn.merged > 0) {
             ctx.log('INFO', `session-mirror: folded ${foldedIn.merged} session(s) from ${foldedIn.sources.join(', ')}`);

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

@@ -1,5 +1,3 @@
-/** Stable subsystem identifiers shared by the daemon (writer) and `agents daemon` (reader). */
-export declare const SUBSYSTEM_BROWSER_IPC = "browser-ipc";
 /**
  * Daemon startup itself (RUSH-2418). Unlike the two above, this record is
  * written from BOTH sides: the launching CLI records a start that produced no
@@ -22,8 +20,8 @@ export interface SubsystemHealth {
     /** ISO timestamp of the most recent success, or null if it has never succeeded. */
     lastOkAt: string | null;
     /**
-     * `ServiceSupervisor`'s lifecycle state (`idle`/`running`/`parked`/`stopped`),
-     * written by `recordSubsystemState` on every transition. Only present for
+     * `ServiceSupervisor`'s lifecycle state (`idle`/`running`/`stopped`), written
+     * by `recordSubsystemState` on every transition. Only present for
      * supervisor-managed subsystems (RUSH-3193 P4) — a subsystem that predates the
      * supervisor (e.g. `daemon-start`) never has this field, which is how `agents
      * daemon services` tells a measured state from an inferred one.
@@ -50,10 +48,29 @@ export declare function recordSubsystemErrorReason(subsystem: string, error: str
 /**
  * Record a `ServiceSupervisor` lifecycle-state transition, without touching
  * the ok/error streak. Cross-process readers (`agents daemon services`) have
- * no other way to see `parked`/`stopped` vs `running` — `agents daemon
+ * no other way to see `stopped`/`idle` vs `running` — `agents daemon
  * status` runs as a separate process from the daemon (see module docblock).
  */
 export declare function recordSubsystemState(subsystem: string, state: string): void;
+/** One supervised restart: the service whose deadline breach forced the daemon to exit, and when. */
+export interface DaemonRestartRecord {
+    /** ISO timestamp of the breach that forced the restart. */
+    at: string;
+    /** The service id whose tick or lifecycle call breached its deadline. */
+    subsystem: string;
+    /** The deadline-breach message. */
+    cause: string;
+}
+/**
+ * Append a supervised-restart record and flush it to disk SYNCHRONOUSLY. The
+ * caller is `ServiceSupervisor.exitForRestart`, which calls `process.exit`
+ * immediately after, so the write must be durable before the process dies.
+ * Never throws (same contract as the health file above) — a dropped ledger entry
+ * must not keep the process from exiting for its restart.
+ */
+export declare function recordDaemonRestart(subsystem: string, cause: string, at?: string): void;
+/** Every supervised restart recorded at or after `sinceMs`, oldest first. */
+export declare function readRecentDaemonRestarts(sinceMs: number): DaemonRestartRecord[];
 /** Read one subsystem's health record, or null if it has never reported in. */
 export declare function readSubsystemHealth(subsystem: string): SubsystemHealth | null;
 /** Read every subsystem's health record, sorted by subsystem name. */

package/dist/lib/daemon-health.js

@@ -27,8 +27,6 @@ import * as path from 'path';
 import { getDaemonDir } from './state.js';
 import { atomicWriteFileSync, ensureLockTarget, withFileLock } from './fs-atomic.js';
 const HEALTH_FILE = 'health.json';
-/** Stable subsystem identifiers shared by the daemon (writer) and `agents daemon` (reader). */
-export const SUBSYSTEM_BROWSER_IPC = 'browser-ipc';
 /**
  * Daemon startup itself (RUSH-2418). Unlike the two above, this record is
  * written from BOTH sides: the launching CLI records a start that produced no
@@ -125,7 +123,7 @@ export function recordSubsystemErrorReason(subsystem, error, at = new Date().toI
 /**
  * Record a `ServiceSupervisor` lifecycle-state transition, without touching
  * the ok/error streak. Cross-process readers (`agents daemon services`) have
- * no other way to see `parked`/`stopped` vs `running` — `agents daemon
+ * no other way to see `stopped`/`idle` vs `running` — `agents daemon
  * status` runs as a separate process from the daemon (see module docblock).
  */
 export function recordSubsystemState(subsystem, state) {
@@ -134,6 +132,52 @@ export function recordSubsystemState(subsystem, state) {
         all[subsystem] = { ...existing, subsystem, state };
     });
 }
+// ─── Supervised-restart ledger (PHNX-4116) ────────────────────────────────────
+const RESTARTS_FILE = 'restarts.json';
+/** Bound so a crash loop cannot grow the ledger file without limit. */
+const MAX_RESTART_RECORDS = 200;
+function getRestartsPath() {
+    return path.join(getDaemonDir(), RESTARTS_FILE);
+}
+function readRestarts() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(getRestartsPath(), 'utf-8'));
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Append a supervised-restart record and flush it to disk SYNCHRONOUSLY. The
+ * caller is `ServiceSupervisor.exitForRestart`, which calls `process.exit`
+ * immediately after, so the write must be durable before the process dies.
+ * Never throws (same contract as the health file above) — a dropped ledger entry
+ * must not keep the process from exiting for its restart.
+ */
+export function recordDaemonRestart(subsystem, cause, at = new Date().toISOString()) {
+    try {
+        const restartsPath = getRestartsPath();
+        ensureLockTarget(restartsPath, '[]');
+        withFileLock(restartsPath, () => {
+            const records = readRestarts();
+            records.push({ at, subsystem, cause });
+            atomicWriteFileSync(restartsPath, JSON.stringify(records.slice(-MAX_RESTART_RECORDS)), { encoding: 'utf-8', mode: 0o600 });
+            try {
+                fs.chmodSync(restartsPath, 0o600);
+            }
+            catch { /* best effort */ }
+        });
+    }
+    catch { /* a dropped restart record must never block the exit-for-restart */ }
+}
+/** Every supervised restart recorded at or after `sinceMs`, oldest first. */
+export function readRecentDaemonRestarts(sinceMs) {
+    return readRestarts().filter((r) => {
+        const t = Date.parse(r.at);
+        return Number.isFinite(t) && t >= sinceMs;
+    });
+}
 /** Read one subsystem's health record, or null if it has never reported in. */
 export function readSubsystemHealth(subsystem) {
     return readAll()[subsystem] ?? null;

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' | 'feed-stream' | 'session-summarizer' | 'attention-notify' | 'harness-update';
+export type DaemonServiceId = 'scheduler' | 'catchup' | 'monitors' | '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' | '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

@@ -27,11 +27,6 @@ export const DAEMON_SERVICES = [
         title: 'Monitor engine',
         description: 'Watches event sources and triggers monitor-driven routines.',
     },
-    {
-        id: 'browser-ipc',
-        title: 'Browser IPC',
-        description: 'Keeps a supervised browser automation IPC socket available for sessions.',
-    },
     {
         id: 'webhook-receiver',
         title: 'Webhook receiver',
@@ -82,11 +77,6 @@ export const DAEMON_SERVICES = [
         title: 'Tmux reap',
         description: 'Reaps dead managed tmux sessions and their orphaned helper processes.',
     },
-    {
-        id: 'browser-task-reap',
-        title: 'Browser task reap',
-        description: 'Closes abandoned browser-task tabs whose owner exited or idle lease expired.',
-    },
     {
         id: 'session-state',
         title: 'Live session state',

package/dist/lib/daemon-ticks.js

@@ -158,9 +158,11 @@ export async function runUsageRefreshTick(signal) {
         // is bounded by deadlineMs, not just each fetch's own 5s timeout (PHNX-3608).
         signal,
         pollerDevice: machineId(),
+        // A changed poll refreshes this box's own state file so the next usage-sync
+        // fan-out (or a placement probe before it) sends the new reading.
         onSnapshotsChanged: async () => {
-            const { pushUsageSnapshotNow } = await import('./accounting/usage-sync.js');
-            await pushUsageSnapshotNow();
+            const { publishUsageSnapshotToSharedStore } = await import('./accounting/usage-sync.js');
+            await publishUsageSnapshotToSharedStore();
         },
     });
     const { listProfiles } = await import('./profiles.js');

package/dist/lib/devices/doctor-findings.js

@@ -315,12 +315,7 @@ export function remediationFor(finding) {
             // shape only, for a kind constructed through finding() by a future caller.
             return 'kill <pid>';
         case 'owner-sink-unreachable':
-            // The lane delivers over the rush-backed owner channel, which needs rush on
-            // PATH AND a usable session in THIS context. Non-interactive shells miss a
-            // ~/.zshrc export (RUSH-2258), and the session is keychain-bound, not in
-            // ~/.rush/user.yaml (RUSH-2262) — so `rush login` here, or the Rush App for
-            // a GUI keychain, is what makes it reachable.
-            return "put rush on PATH for non-interactive shells (~/.zshenv) and run 'rush login'";
+            return 'check the channel transport: iMessage needs macOS, Slack needs SLACK_BOT_TOKEN in env or the webhooks bundle';
     }
 }
 function finding(f) {
@@ -369,11 +364,13 @@ export function buildLocalFindings(input) {
     const sink = input.ownerSink;
     if (sink?.configured && !sink.reachable) {
         const chan = sink.channel ?? 'owner';
-        const why = sink.reason === 'rush-not-on-path'
-            ? `rush CLI not on this box's PATH`
-            : sink.reason === 'rush-signed-out'
-                ? 'rush has no usable session here'
-                : 'transport unreachable';
+        const why = sink.reason === 'imessage-not-macos'
+            ? 'iMessage requires macOS (peer-forward delivers from a macOS peer)'
+            : sink.reason === 'slack-no-token'
+                ? 'no SLACK_BOT_TOKEN — set it in env or the webhooks secrets bundle'
+                : sink.reason === 'channel-unsupported'
+                    ? `${chan} transport removed (Rush daemon)`
+                    : 'transport unreachable';
         out.push(finding({
             severity: FINDING_SEVERITY['owner-sink-unreachable'], kind: 'owner-sink-unreachable', device,
             message: `${chan} → owner unreachable: ${why}`,

package/dist/lib/devices/harness-inventory.js

@@ -15,7 +15,7 @@
  */
 import chalk from 'chalk';
 import { ALL_AGENT_IDS, accountDisplayLabel, getAccountInfo, } from '../agents.js';
-import { deriveUsageStatusFromSnapshot, classifyUsageErrorKind, getUsageInfoByIdentity, getUsageLookupKey, usageErrorForDisplay, } from '../accounting/usage.js';
+import { deriveUsageStatusFromSnapshot, liveUsageWindows, classifyUsageErrorKind, getUsageInfoByIdentity, getUsageLookupKey, usageErrorForDisplay, } from '../accounting/usage.js';
 import { getVersionHomePath, listInstalledVersions } from '../installations/store.js';
 import { readMeta } from '../state.js';
 import { findNativeAccountByIdentity } from '../account-registry.js';
@@ -59,11 +59,20 @@ export function summarizeQuota(snapshot, unavailableReason = null, accountStatus
             unavailableReason: status ? null : (reason ?? 'usage unavailable'),
         };
     }
-    const blocking = snapshot.windows.filter((w) => w.key !== 'sonnet_week');
-    const windows = blocking.length > 0 ? blocking : snapshot.windows;
+    // Percentage and status MUST read from the SAME live windows, or a window past
+    // its reset (usedPercent from the PREVIOUS period) makes the status `available`
+    // while the displayed percentage still shows a stale ~100% (#3705). Select the
+    // live set first, then narrow to blocking exactly as
+    // `deriveUsageStatusFromSnapshot` does.
+    const live = liveUsageWindows(snapshot);
+    const blocking = live.filter((w) => w.key !== 'sonnet_week');
+    const windows = blocking.length > 0 ? blocking : live;
     const derived = deriveUsageStatusFromSnapshot(snapshot);
     const status = accountStatus === 'out_of_credits' ? accountStatus : derived;
-    let usedPercent = Math.round(Math.max(...windows.map((w) => w.usedPercent)));
+    // Every window rolled over: no live utilization to show (status is `available`).
+    let usedPercent = windows.length > 0
+        ? Math.round(Math.max(...windows.map((w) => w.usedPercent)))
+        : 0;
     // Never show 100% for an account that isn't actually capped: a genuinely-100
     // blocking window makes the status `rate_limited` (rendered "limited"), so a
     // rounded 100 on an `available` account (e.g. 99.6% → 100) would read as maxed
@@ -123,7 +132,7 @@ export function applyUsageHonesty(verdict, usage) {
         }
         return { verdict, usage: stripped };
     }
-    if ((usage.status === 'rate_limited' || usage.status === 'out_of_credits') && (verdict === 'live' || verdict === 'unverified')) {
+    if ((usage.status === 'rate_limited' || usage.status === 'out_of_credits') && (verdict === 'live' || verdict === 'unverified' || verdict === 'no_evidence')) {
         return { verdict: 'rate_limited', usage };
     }
     return { verdict, usage };

package/dist/lib/exec-account-home.js

@@ -142,6 +142,11 @@ async function matchLegacyIdentityHome(agent, account, meta) {
     const needles = [row?.identityKey, row?.identityLabel]
         .filter((value) => typeof value === 'string' && value.trim().length > 0)
         .map((value) => value.trim().toLowerCase());
+    // For accounts that predate the native registry, the row is missing but the
+    // account name carries the email the caller selected with `#email`.
+    if (needles.length === 0 && account.name.includes('@')) {
+        needles.push(account.name.trim().toLowerCase());
+    }
     if (needles.length === 0)
         return null;
     const needleSet = new Set(needles);

package/dist/lib/exec.js

@@ -33,12 +33,12 @@ import { recordRunName } from './session/run-names.js';
 import { mailboxDir, isValidMailboxId } from './mailbox.js';
 import { composeWin32CommandLine } from './platform/index.js';
 import { isTmuxInstalled } from './tmux/binary.js';
-import { isTmuxEnabled, selfConfiguredDeviceRole } from './device-config.js';
+import { isHeadedDeviceRole, isTmuxEnabled, selfConfiguredDeviceRole } from './device-config.js';
 import { machineId } from './machine-id.js';
 import { shellQuote } from './ssh-exec.js';
 import { codexEditWritableRoots, codexPolicyArgs } from './codex-policy.js';
 import { probeUnprivilegedUserns } from './linux-userns.js';
-import { resolveClaudeSetupToken } from './claude-account-token.js';
+import { resolveClaudeSetupToken, seedClaudeWorkerHomeIdentity } from './claude-account-token.js';
 import { applyAddDirs } from './add-dir.js';
 import { applyActiveRulesPresetAtRun } from './rules/run-sync.js';
 import { applySystemResourcesAtRun } from './system-run-sync.js';
@@ -541,17 +541,6 @@ export const AGENT_COMMANDS = {
         jsonFlags: ['--json'],
         modelFlag: '--model',
     },
-    gemini: {
-        base: ['gemini'],
-        promptFlag: 'positional',
-        modeFlags: {
-            plan: ['--approval-mode', 'plan'],
-            edit: ['--approval-mode', 'auto_edit'],
-            skip: ['--yolo'],
-        },
-        jsonFlags: ['--output-format', 'stream-json'],
-        modelFlag: '--model',
-    },
     cursor: {
         base: ['cursor-agent'],
         promptFlag: '-p',
@@ -1943,6 +1932,14 @@ async function spawnAgentLeased(options) {
             process.stderr.write(`\x1b[31m${loginTrap}\x1b[0m\n`);
             return { exitCode: 1, stdout: '', stderr: loginTrap };
         }
+        // A credentialed run on a worker never needs Claude Code's first-run
+        // onboarding, and in a provider (setup-token) launch's shared version home
+        // nothing else completes it: the tab opened on the theme picker instead of
+        // the agent (yosemite-m1, 2026-09-28). A headed device keeps its own
+        // onboarding; the person at it answers it.
+        if (hasWorkerCredential && versionHome && !isHeadedDeviceRole(selfConfiguredDeviceRole())) {
+            seedClaudeWorkerHomeIdentity(versionHome);
+        }
     }
     // Budget live kill-switch (issue #346). For headless runs we incrementally
     // parse stream-json usage off stdout, accumulate cost, and kill the child the

package/dist/lib/feed/events.js

@@ -469,7 +469,6 @@ function sanitizePayload(payload, maxLength = DEFAULT_TRUNCATE_LENGTH) {
 const TERMINAL_CALLERS = {
     cc: 'claude', cl: 'claude',
     cx: 'codex',
-    gx: 'gemini', gm: 'gemini',
     cr: 'cursor',
     oc: 'opencode',
     sh: 'shell',

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

@@ -28,7 +28,6 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getBrowserRuntimeDir } from '../state.js';
 import { getEventsDir } from './events.js';
-import { listTaskBindings } from '../browser/task-index.js';
 import { buildBrowserSessionRows } from '../browser/sessions-list.js';
 import { buildComputerSessionRows, standaloneComputerActionsDir } from '../computer/sessions-list.js';
 import { boundBrowserRow, projectBrowserToolRow, projectComputerToolRow, sortToolRows } from './tools.js';
@@ -52,8 +51,12 @@ export function collectToolRows(scope, sources = {}) {
             return empty;
         }
     };
+    // Task→device binding is browser-cli's now (bound at `start`, PHNX-4101), so
+    // agents-cli keeps no separate binding index. Cross-device tasks are driven by
+    // browser-cli from THIS box, so their `tasks.json` is local and reached by
+    // `readLiveBrowserTasks` below. The `bindings` source stays a test seam.
     const bindings = new Map();
-    for (const binding of read(sources.bindings ?? listTaskBindings, []))
+    for (const binding of read(sources.bindings ?? (() => []), []))
         bindings.set(binding.name, binding);
     const liveTasks = new Map();
     for (const task of read(sources.liveTasks ?? (() => readLiveBrowserTasks()), []))

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

@@ -56,11 +56,27 @@ export interface FleetSharedDeviceState {
     sessions?: {
         rows: SessionMirrorRow[];
     };
+    /**
+     * Per-account auth verdict rows, written by the account-state daemon service
+     * (`account-state-daemon-service.ts`) and read by `readSharedAccountVerdicts`.
+     * Opaque here: the envelope carries them across the exchange unchanged.
+     */
+    accounts?: {
+        rows: unknown[];
+    };
+    /**
+     * Epoch ms this box received the envelope from its owner over the SSH
+     * exchange. Present ONLY in a peer's file on this box, never in a device's own
+     * file. auth-sync reads it per peer to know that peer has replied at all.
+     */
+    receivedAt?: number;
 }
 interface FleetSharedStatePatch {
     usage?: FleetSharedDeviceState['usage'];
     auth?: FleetSharedDeviceState['auth'];
     sessions?: FleetSharedDeviceState['sessions'];
+    accounts?: FleetSharedDeviceState['accounts'];
+    receivedAt?: number;
 }
 interface FleetSharedStateReadResult {
     states: FleetSharedDeviceState[];
@@ -71,6 +87,13 @@ interface FleetSharedStateReadResult {
 }
 /** Path owned by one device in the conflict-free tracked device-doc tree. */
 export declare function fleetSharedStatePath(device: string, userAgentsDir?: string): string;
+/**
+ * Validate an already-parsed envelope. `owner` pins the `device` field when the
+ * caller knows whose envelope this must be (a file under `devices/<owner>/`);
+ * an envelope arriving over the exchange names its own owner, so the caller
+ * passes none and checks `device` against the dialed peer afterwards.
+ */
+export declare function parseFleetSharedDeviceStateEnvelope(parsed: unknown, owner?: string): FleetSharedDeviceState;
 export declare function updateFleetSharedDeviceState(device: string, patch: FleetSharedStatePatch, userAgentsDir?: string): {
     changed: boolean;
     path: string;
@@ -89,4 +112,26 @@ export declare function updateFleetSharedDeviceStateAsync(device: string, patch:
 }>;
 /** Read every valid peer-owned state file; malformed peers fail separately. */
 export declare function readFleetSharedDeviceStates(userAgentsDir?: string): FleetSharedStateReadResult;
+/**
+ * This device's own envelope as it stands on disk — what the usage-sync exchange
+ * sends to peers and what `__usage-ingest --reply` prints back. A device that has
+ * never published anything yields the bare `{version, device}` envelope, so a
+ * peer still learns the device exists and answered.
+ */
+export declare function readOwnFleetSharedDeviceState(device: string, userAgentsDir?: string): FleetSharedDeviceState;
+/**
+ * Store a PEER's envelope, received over the SSH exchange, in that peer's file on
+ * this box, stamped with `receivedAt`. Merges field-by-field onto whatever the
+ * file already holds, so a partial envelope (a placement probe sends usage only)
+ * refreshes that field without erasing the peer's last auth verdict, session
+ * digests, or account rows. The five readers of `devices/<peer>/daemon-state.json`
+ * (usage merge, poller claims, auth verdicts, session mirror, account catalog)
+ * are unchanged by the transport swap. Async because it runs on the daemon's
+ * usage-sync tick once per peer reply: the sync lock would `sleepSync` the event
+ * loop for up to 30 s under contention (see {@link updateFleetSharedDeviceStateAsync}).
+ */
+export declare function storePeerFleetSharedDeviceState(state: FleetSharedDeviceState, userAgentsDir?: string, receivedAt?: number): Promise<{
+    changed: boolean;
+    path: string;
+}>;
 export {};