@phnx-labs/agents-cli 1.22.24 → 1.22.25

package/dist/commands/feed.js

@@ -16,6 +16,7 @@ import { notifyUrgentBlock } from '../lib/notify.js';
 import { gcMailbox } from '../lib/mailbox-gc.js';
 import { isValidMailboxId } from '../lib/mailbox.js';
 import { getActiveSessions } from '../lib/session/active.js';
+import { backfillActiveRowsFromMeta } from './sessions.js';
 import { mailboxIdForActiveSession } from '../lib/mailbox-target.js';
 import { GLYPH, masthead } from '../lib/comms-render.js';
 import { discoverSessions } from '../lib/session/discover.js';
@@ -154,7 +155,7 @@ export function prepareLocalFeedBlocks(localBlocks, opts) {
 }
 function renderBlock(b, localHost, indent = '') {
     const host = b.host !== localHost ? chalk.yellow(` [${b.host}]`) : '';
-    const runtime = chalk.gray(b.runtime);
+    const runtime = chalk.gray(formatFeedRuntime(b));
     const age = chalk.gray(relTime(b.ts));
     const cls = b.blockClass ? chalk.gray(`(${b.blockClass})`) : '';
     const consequence = b.consequence && b.consequence !== 'normal' ? chalk.red(`[${b.consequence}]`) : '';
@@ -218,6 +219,21 @@ function renderBlock(b, localHost, indent = '') {
     }
     console.log();
 }
+/** Specific host app + routine provenance for one feed row. */
+export function formatFeedRuntime(block) {
+    const host = {
+        ghostty: 'Ghostty',
+        iterm: 'iTerm',
+        terminal: 'terminal',
+        kitty: 'Kitty',
+        codium: 'VSCodium',
+        code: 'VS Code',
+        cursor: 'Cursor',
+    }[block.runtime.toLowerCase()] ?? block.runtime;
+    if (block.origin !== 'routine')
+        return host;
+    return `${host} · routine${block.routineName ? `:${block.routineName}` : ''}`;
+}
 /** Human summary line for one outcome rollup. */
 export function formatOutcomeHeader(group) {
     const { agents, open, answered, parked } = group.counts;
@@ -251,6 +267,9 @@ export function sessionHintsFromActive(sessions) {
         prUrl: s.pr?.url,
         worktreeSlug: s.worktree?.slug,
         project: s.cwd ? projectKeyFromCwd(s.cwd) : undefined,
+        host: s.host,
+        origin: s.origin,
+        routineName: s.routineName,
     }));
 }
 /**
@@ -489,6 +508,7 @@ export function registerFeedCommand(program) {
                 console.error(chalk.yellow('Feed: session index is locked; skipping local outcome enrichment'));
             }
             sessionMetas = loaded.metas;
+            backfillActiveRowsFromMeta(sessions, new Map(sessionMetas.map((meta) => [meta.id, meta])));
         }
         const localSignals = buildSessionSignals(sessions, sessionMetas);
         if (opts.pause || opts.kill) {

package/dist/commands/focus.js

@@ -16,7 +16,7 @@ import fs from 'node:fs';
 import chalk from 'chalk';
 import { confirm } from '@inquirer/prompts';
 import { gatherLiveTargets, pickLiveTarget, pickLiveTargets, jumpTo, probeAttachRail, refuseFallback } from './go.js';
-import { buildSessionRecoveryCommand, filterSessionsByQuery, formatLiveStatusHeadline, formatPickerLabel, pickerColumnsFor, resumeSessionInPlace, resolveSessionMetadataValue, resolveSessionAgentName, requestedLiveStatuses, } from './sessions.js';
+import { buildSessionRecoveryCommand, filterSessionsByQuery, formatLiveStatusHeadline, formatPickerLabel, isRunningLiveSession, pickerColumnsFor, resumeSessionInPlace, resolveSessionMetadataValue, resolveSessionAgentName, requestedLiveStatuses, } from './sessions.js';
 import { resolveBackend, CONFIRM_THRESHOLD } from './sessions-resume.js';
 import { runOnPeer } from '../lib/session/remote-list.js';
 import { discoverSessions } from '../lib/session/discover.js';
@@ -276,7 +276,7 @@ export async function focusAction(id, opts) {
 }
 /** A retained pane is not attachable merely because tmux can still display it. */
 export function isAttachableLiveSession(session) {
-    return session.pidAlive !== false && session.status !== 'closed' && session.status !== 'crashed';
+    return isRunningLiveSession(session);
 }
 const FOCUS_AGENT_SHORTHANDS = ['claude', 'codex', 'kimi', 'antigravity', 'grok', 'opencode'];
 function focusOptionAgent(opts) {

package/dist/commands/menubar.js

@@ -137,6 +137,14 @@ export function registerMenubarCommands(program) {
       again, run \`agents menubar disable\`.
     `,
     });
+    menubar
+        .command('snapshot', { hidden: true })
+        .description('Emit the consolidated AGI Menu polling snapshot.')
+        .option('--json', 'Emit machine-readable JSON')
+        .action(async () => {
+        const { computeMenubarSnapshot } = await import('../lib/menubar/snapshot.js');
+        process.stdout.write(`${JSON.stringify(await computeMenubarSnapshot())}\n`);
+    });
     menubar
         .command('enable')
         .description('Install and start AGI Menu (launches at login)')

package/dist/commands/routines.d.ts

@@ -46,5 +46,8 @@ export declare function groupRoutineJobsByDevice(jobs: JobConfig[], registry: De
  */
 export declare function groupRoutineJobsByProject(jobs: JobConfig[], knownProjectNames: Set<string>): RoutineListGroup[];
 export declare function buildRunsJson(runs: RunMeta[]): Record<string, unknown>[];
+/** Build the exact structured routine rows shared by `routines list --json`
+ * and the one-process AGI Menu snapshot. */
+export declare function buildRoutineListJson(): Record<string, unknown>[];
 /** Register the `agents routines` command tree. */
 export declare function registerRoutinesCommands(program: Command): void;

package/dist/commands/routines.js

@@ -405,6 +405,72 @@ function runMetaJson(run) {
 export function buildRunsJson(runs) {
     return runs.map(runMetaJson);
 }
+/** Build the exact structured routine rows shared by `routines list --json`
+ * and the one-process AGI Menu snapshot. */
+export function buildRoutineListJson() {
+    try {
+        monitorRunningJobs();
+    }
+    catch { /* best-effort orphan reap */ }
+    const jobs = listAllJobs(process.cwd());
+    if (jobs.length === 0)
+        return [];
+    const scheduler = new JobScheduler(async () => { });
+    scheduler.loadAll();
+    try {
+        const overdueSet = new Set();
+        try {
+            for (const job of detectOverdueJobs())
+                overdueSet.add(job.name);
+        }
+        catch {
+            // Best-effort indicator; never block the list on detection errors.
+        }
+        const now = new Date();
+        const knownProjectNames = new Set(listProjectDefs().map((project) => project.name));
+        return jobs.map((job) => {
+            const latestRun = localLatestRun(job);
+            const enabledDevices = devicesWithRoutineEnabled(job.name);
+            return {
+                name: job.name,
+                agent: job.agent ?? null,
+                workflow: job.workflow ?? null,
+                command: job.command ?? null,
+                repo: job.repo ?? null,
+                schedule: job.schedule ?? null,
+                scheduleHuman: fireConditionLabel(job),
+                trigger: job.trigger ?? null,
+                timezone: job.timezone ?? null,
+                devices: enabledDevices,
+                enabledDevices,
+                host: job.host ?? null,
+                hostStrategy: resolveHostStrategy(job),
+                source: job.source ?? null,
+                sourceRepo: job.source?.repo ?? job.repo ?? null,
+                sourceBranch: job.source?.branch ?? null,
+                runOnce: Boolean(job.runOnce),
+                catchup: job.catchup !== false,
+                oneShot: isOneShotRoutine(job),
+                expired: isPastOneShotRoutine(job, now),
+                runsHere: jobRunsOnThisDevice(job),
+                enabled: job.enabled,
+                overdue: overdueSet.has(job.name),
+                nextRun: nextRunForDisplay(job, scheduler)?.toISOString() ?? null,
+                nextRunHuman: nextRunLabel(job, scheduler, now),
+                lastStatus: latestRun?.status ?? null,
+                exitCode: latestRun?.exitCode ?? null,
+                failureReason: latestRun?.errorMessage ?? null,
+                lastRunStartedAt: latestRun?.startedAt ?? null,
+                lastRunCompletedAt: latestRun?.completedAt ?? null,
+                projects: job.projects ?? [],
+                projectGroup: computeProjectGroup(job.projects, knownProjectNames),
+            };
+        });
+    }
+    finally {
+        scheduler.stopAll();
+    }
+}
 /** Detect Ctrl+C or premature stream close during an interactive prompt. */
 function isPromptCancelled(err) {
     return (err instanceof Error &&
@@ -554,6 +620,10 @@ export function registerRoutinesCommands(program) {
             console.error(chalk.red(`Unsupported --group-by '${options.groupBy}'. Use: project (default) or device`));
             process.exit(1);
         }
+        if (options.json) {
+            process.stdout.write(JSON.stringify(buildRoutineListJson()) + '\n');
+            return;
+        }
         try {
             monitorRunningJobs();
         }
@@ -579,53 +649,6 @@ export function registerRoutinesCommands(program) {
         catch {
             // Best-effort indicator; never block the list on detection errors.
         }
-        // Machine-readable path: same data the table renders, but structured.
-        // The menu bar helper relies on this so it never reimplements cron math.
-        if (options.json) {
-            const nowJson = new Date();
-            const knownProjectNames = new Set(listProjectDefs().map((p) => p.name));
-            const payload = jobs.map((job) => {
-                const latestRun = localLatestRun(job);
-                const enabledDevices = devicesWithRoutineEnabled(job.name);
-                return {
-                    name: job.name,
-                    agent: job.agent ?? null,
-                    workflow: job.workflow ?? null,
-                    command: job.command ?? null,
-                    repo: job.repo ?? null,
-                    schedule: job.schedule ?? null,
-                    scheduleHuman: fireConditionLabel(job),
-                    trigger: job.trigger ?? null,
-                    timezone: job.timezone ?? null,
-                    devices: enabledDevices,
-                    enabledDevices,
-                    host: job.host ?? null,
-                    hostStrategy: resolveHostStrategy(job),
-                    source: job.source ?? null,
-                    sourceRepo: job.source?.repo ?? job.repo ?? null,
-                    sourceBranch: job.source?.branch ?? null,
-                    runOnce: Boolean(job.runOnce),
-                    catchup: job.catchup !== false,
-                    oneShot: isOneShotRoutine(job),
-                    expired: isPastOneShotRoutine(job, nowJson),
-                    runsHere: jobRunsOnThisDevice(job),
-                    enabled: job.enabled,
-                    overdue: overdueSet.has(job.name),
-                    nextRun: nextRunForDisplay(job, scheduler)?.toISOString() ?? null,
-                    nextRunHuman: nextRunLabel(job, scheduler, nowJson),
-                    lastStatus: latestRun?.status ?? null,
-                    exitCode: latestRun?.exitCode ?? null,
-                    failureReason: latestRun?.errorMessage ?? null,
-                    lastRunStartedAt: latestRun?.startedAt ?? null,
-                    lastRunCompletedAt: latestRun?.completedAt ?? null,
-                    projects: job.projects ?? [],
-                    projectGroup: computeProjectGroup(job.projects, knownProjectNames),
-                };
-            });
-            scheduler.stopAll();
-            process.stdout.write(JSON.stringify(payload) + '\n');
-            return;
-        }
         console.log(chalk.bold('Scheduled Jobs\n'));
         // OSC 8 hyperlink helper — renders as a clickable link in supporting terminals.
         // Guarded on process.stdout.isTTY so that piped/redirected output never

package/dist/commands/run-cloud.js

@@ -91,7 +91,7 @@ export function resolveRunCloudProvider(agentId, explicitProvider) {
         return resolveProvider(explicitProvider);
     if (!nativeProviderForAgent(agentId)) {
         throw new RunCloudError(`${agentId} has no native cloud. Cloud-capable agents: ${cloudCapableAgentIds().join(', ')}. ` +
-            `Override with --provider <id> (rush | codex | factory | antigravity | host).`);
+            `Override with --provider <id> (rush | codex | cursor | factory | antigravity | host).`);
     }
     return resolveProvider(undefined, agentId);
 }

package/dist/commands/sessions-browser.d.ts

@@ -147,7 +147,7 @@ export declare function liveSessionToMeta(a: ActiveSession, self: string): Sessi
  * `--active --json` listed it. Live sessions the pool lacks are appended as their
  * own rows, then the whole set is grouped local-machine-first.
  */
-export declare function mergeLiveIntoPool(rows: SessionMeta[], live: Map<string, ActiveSession>, self: string): SessionMeta[];
+export declare function mergeLiveIntoPool(rows: SessionMeta[], live: Map<string, ActiveSession>, self: string, includeUnindexed?: boolean): SessionMeta[];
 /**
  * Whether to render the host-program column. It belongs to the running view
  * only, so this gates on the FILTER — not on the live index being populated.

package/dist/commands/sessions-browser.js

@@ -22,7 +22,7 @@ import { enrichTeamOrigins, safeTeamText } from '../lib/session/team-filter.js';
 import { listFavorites, toggleFavorite } from '../lib/session/favorites.js';
 import { machineId, normalizeHost } from '../lib/session/sync/config.js';
 import { buildPreview } from './sessions-picker.js';
-import { formatPickerLabel, pickerColumnsFor, ticketLabel, mergeLocalFirst, gatherActiveSessions, liveHostLabel, LIVE_ROW_PREFIX, cleanPreview, handlePickedSession, shouldIncludeLocal, remoteHostsToDial, matchesTeam, formatLiveStatusHeadline, matchesLiveStatus, parseAgentFilter, } from './sessions.js';
+import { formatPickerLabel, pickerColumnsFor, ticketLabel, mergeLocalFirst, gatherActiveSessions, liveHostLabel, LIVE_ROW_PREFIX, cleanPreview, handlePickedSession, shouldIncludeLocal, remoteHostsToDial, matchesTeam, formatLiveStatusHeadline, isRunningLiveSession, matchesLiveStatus, parseAgentFilter, } from './sessions.js';
 /**
  * Complete a seed into the filter the picker actually runs on.
  *
@@ -73,6 +73,8 @@ function poolCacheKey(f) {
 }
 /** Pool size when a team filter is active; one team's rows can sit anywhere. */
 const WHOLE_TEAM_POOL_LIMIT = 5000;
+/** A cold peer may need to resolve an installed-version alias and scan its index. */
+const BROWSER_PEER_TIMEOUT_MS = 30_000;
 /** Ordered window cycle for the `W` key. `undefined` = all time. */
 const WINDOW_CYCLE = [undefined, '1d', '7d', '30d'];
 /** Return the next value in `[undefined, ...options]`, wrapping. */
@@ -309,7 +311,9 @@ async function fetchRawPool(f, self, local, hosts, fixedFilters = false) {
             // --in-team itself, which a peer on an older build would reject as an
             // unknown option and fail the whole fan-out.
             const forwarded = remotePoolArgs(f, fixedFilters);
-            const remoteResult = await gatherRemoteList(forwarded, remoteHosts);
+            const remoteResult = await gatherRemoteList(forwarded, remoteHosts, {
+                timeoutMs: BROWSER_PEER_TIMEOUT_MS,
+            });
             unreachable = remoteResult.unreachable;
             if (remoteResult.sessions.length > 0)
                 rows = mergeLocalFirst([...rows, ...remoteResult.sessions], self);
@@ -423,7 +427,12 @@ export function liveSessionToMeta(a, self) {
  * `--active --json` listed it. Live sessions the pool lacks are appended as their
  * own rows, then the whole set is grouped local-machine-first.
  */
-export function mergeLiveIntoPool(rows, live, self) {
+export function mergeLiveIntoPool(rows, live, self, includeUnindexed = true) {
+    // A latest/oldest selector is resolved by the peer's transcript query. A live
+    // row absent from that result has no proof it belongs to the resolved version,
+    // so callers using an alias fail closed instead of widening the selector.
+    if (!includeUnindexed)
+        return rows;
     const known = new Set(rows.map((r) => r.id));
     const extra = [];
     for (const [key, a] of live) {
@@ -483,8 +492,15 @@ export function applyFilters(rows, live, f, self, favorites) {
         const cwd = process.cwd();
         out = out.filter((r) => !!r.cwd && (r.cwd === cwd || r.cwd.startsWith(cwd + '/')));
     }
-    if (f.running)
-        out = out.filter((r) => live.has(r.id));
+    // The live registry retains dead rows so explicit --closed/--crashed filters
+    // can recover them. Bare --active means currently active; a lifecycle filter
+    // intentionally replaces that default predicate with its exact status union.
+    if (f.running && f.statuses.length === 0) {
+        out = out.filter((r) => {
+            const active = live.get(r.id);
+            return !!active && isRunningLiveSession(active);
+        });
+    }
     if (f.statuses.length > 0) {
         out = out.filter((r) => {
             const active = live.get(r.id);
@@ -507,8 +523,9 @@ export async function collectSessionCandidates(initial, opts = {}) {
         const { sessions } = await gatherActiveSessions({ local: opts.local ?? false, hosts });
         liveById = indexLiveRows(sessions, self);
     }
+    const includeUnindexedLive = !filter.agent?.match(/@(latest|oldest)$/);
     const rows = filter.running || opts.includeLive
-        ? mergeLiveIntoPool(pool.rows, liveById, self)
+        ? mergeLiveIntoPool(pool.rows, liveById, self, includeUnindexedLive)
         : pool.rows;
     const sessions = applyFilters(rows, liveById, filter, self, listFavorites());
     return { sessions, liveById, self, unreachable: pool.unreachable };
@@ -618,7 +635,10 @@ export async function runSessionBrowser(initial = {}, opts = {}) {
             liveCache = live;
         // Live sessions the transcript pool lacks become rows of their own, so the
         // running view lists every active session, not just the ones already indexed.
-        const rows = f.running && live ? mergeLiveIntoPool(pool.rows, live, self) : pool.rows;
+        const includeUnindexedLive = !f.agent?.match(/@(latest|oldest)$/);
+        const rows = f.running && live
+            ? mergeLiveIntoPool(pool.rows, live, self, includeUnindexedLive)
+            : pool.rows;
         agentsInPool = distinct(rows.map((r) => r.agent));
         devicesInPool = distinct(rows.map((r) => r.machine ?? self));
         // Both ends of the lineage seed the cycle: teams a row spawned, and teams a

package/dist/commands/sessions-resume.js

@@ -14,7 +14,8 @@ import { discoverSessions } from '../lib/session/discover.js';
 import { filterTeamSessions } from '../lib/session/team-filter.js';
 import { multiItemPicker, itemPicker } from '../lib/picker.js';
 import { buildPreview } from './sessions-picker.js';
-import { filterSessionsByQuery, formatPickerLabel, pickerColumnsFor, buildSessionRecoveryCommand, resumeSessionInPlace, parseAgentFilter, } from './sessions.js';
+import { formatPickerLabel, pickerColumnsFor, buildSessionRecoveryCommand, resumeSessionInPlace, parseAgentFilter, } from './sessions.js';
+import { sessionMatchesQuery } from './sessions-browser.js';
 import { openSurfaces, availableBackends, detectCurrentBackend, currentContext, } from '../lib/terminal/index.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { setHelpSections } from '../lib/help.js';
@@ -111,7 +112,7 @@ async function sessionsResumeAction(query, options) {
         chosen = await multiItemPicker({
             message: 'Select sessions to resume:',
             items: sessions,
-            filter: (q) => (q.trim() ? filterSessionsByQuery(sessions, q) : sessions),
+            filter: (q) => (q.trim() ? sessions.filter((s) => sessionMatchesQuery(s, q)) : sessions),
             labelFor: (s, q) => formatPickerLabel(s, q, cols),
             keyFor: (s) => s.id,
             buildPreview,

package/dist/commands/sessions.d.ts

@@ -131,7 +131,7 @@ export declare function formatActiveRowDescription(s: ActiveSession): string;
  */
 export declare function indexActiveBySessionId(active: ActiveSession[]): Map<string, ActiveSession>;
 /** The SessionMeta fields the live-row backfill reads — the enrichment a running process cannot report. */
-type BackfillMeta = Pick<SessionMeta, 'version' | 'timestamp' | 'label' | 'ticketId' | 'prUrl' | 'prNumber'>;
+export type BackfillMeta = Pick<SessionMeta, 'version' | 'timestamp' | 'label' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName'>;
 /**
  * Backfill display-only fields onto live rows from the indexed SessionMeta, by
  * full session id (RUSH-2205). A running process reports no agent version, and a
@@ -141,6 +141,8 @@ type BackfillMeta = Pick<SessionMeta, 'version' | 'timestamp' | 'label' | 'ticke
  * the DB read that builds `metaById` is the caller's concern.
  */
 export declare function backfillActiveRowsFromMeta(sessions: ActiveSession[], metaById: Map<string, BackfillMeta>): void;
+/** Add indexed display metadata to active rows for non-renderer consumers. */
+export declare function backfillActiveRowsFromIndex(sessions: ActiveSession[]): void;
 /**
  * The live decoration for a listing row: a status glyph and the latest-turn
  * preview, when the session is still running. `●` running / `◐` waiting on the
@@ -184,6 +186,16 @@ export declare function liveStatusWord(a: ActiveSession | undefined): string;
  * stays excluded rather than inventing a human who can answer.
  */
 export declare function isAwaitingUser(s: ActiveSession): boolean;
+/**
+ * Whether a row belongs in an unqualified `--active` view.
+ *
+ * The live registry deliberately retains terminally-dead rows long enough for
+ * `--closed` / `--crashed` and recovery to find them. Presence in that registry
+ * therefore is not, by itself, evidence that a session is still active.
+ * Explicit lifecycle filters bypass this predicate and select those retained
+ * rows through {@link matchesLiveStatus} instead.
+ */
+export declare function isRunningLiveSession(s: ActiveSession): boolean;
 /**
  * The tracker/PR ref for a session's dedicated column: the ticket id when known,
  * else `PR#<n>`, else empty. Pulled out of the trailing badge blob so refs align

package/dist/commands/sessions.js

@@ -411,6 +411,10 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
             if (!Number.isNaN(ts))
                 s.startedAtMs = ts;
         }
+        if (!s.origin && m.origin)
+            s.origin = m.origin;
+        if (!s.routineName && m.routineName)
+            s.routineName = m.routineName;
     }
 }
 /**
@@ -435,6 +439,10 @@ function loadBackfillMetaFor(sessions) {
     }
     return byId;
 }
+/** Add indexed display metadata to active rows for non-renderer consumers. */
+export function backfillActiveRowsFromIndex(sessions) {
+    backfillActiveRowsFromMeta(sessions, loadBackfillMetaFor(sessions));
+}
 /**
  * The live decoration for a listing row: a status glyph and the latest-turn
  * preview, when the session is still running. `●` running / `◐` waiting on the
@@ -527,6 +535,20 @@ export function isAwaitingUser(s) {
         return false;
     return s.status === 'input_required' || s.activity === 'waiting_input';
 }
+/**
+ * Whether a row belongs in an unqualified `--active` view.
+ *
+ * The live registry deliberately retains terminally-dead rows long enough for
+ * `--closed` / `--crashed` and recovery to find them. Presence in that registry
+ * therefore is not, by itself, evidence that a session is still active.
+ * Explicit lifecycle filters bypass this predicate and select those retained
+ * rows through {@link matchesLiveStatus} instead.
+ */
+export function isRunningLiveSession(s) {
+    if (s.status === 'closed' || s.status === 'crashed')
+        return false;
+    return s.pidAlive !== false;
+}
 /** Width of the live status column — `crashed` is the longest word it renders. */
 const LIVE_STATUS_W = 8;
 /** The colored, space-padded status cell for a listing row (empty when not live). */
@@ -1275,14 +1297,14 @@ async function renderActiveSessions(asJson, waitingOnly = false, opts = {}) {
     // gate: exit non-zero when the union contains a session awaiting the user.
     const statusFiltered = opts.statuses?.length
         ? merged.filter((session) => opts.statuses.some((status) => matchesLiveStatus(session, status)))
-        : merged;
+        : merged.filter(isRunningLiveSession);
     const sessions = statusFiltered;
     // Backfill agent version + ticket/PR/label/created onto the live rows from the
     // historical index (RUSH-2205) — a running process reports none of these, and
     // an orphan row usually lacks them. Done before both the JSON and human paths
     // so every consumer (incl. the SSH fan-out's remote --json) sees enriched rows;
     // transcripts sync across the fleet, so a remote row resolves from the local DB.
-    backfillActiveRowsFromMeta(sessions, loadBackfillMetaFor(sessions));
+    backfillActiveRowsFromIndex(sessions);
     if (asJson) {
         // Resolve who is watching each local tmux pane before serializing: `viewingIn`
         // is how a consumer distinguishes a session someone is looking at from one

package/dist/commands/setup-watchdog.js

@@ -3,17 +3,12 @@ import { spawnSync } from 'node:child_process';
 import { getCliLaunch } from '../lib/cli-entry.js';
 import { loadDevices } from '../lib/devices/registry.js';
 import { machineId, normalizeHost } from '../lib/machine-id.js';
-import { devicesWithRoutineEnabled } from '../lib/routine-activation.js';
-import { readJob, setJobEnabled } from '../lib/routines.js';
+import { getConfigValue, setConfigValue } from '../lib/device-config.js';
 import { isPromptCancelled, requireInteractiveSelection } from './utils.js';
-const ROUTINE = 'watchdog';
 export async function runWatchdogSetupWizard() {
-    if (!readJob(ROUTINE)) {
-        throw new Error("Built-in routine 'watchdog' is missing. Run: agents repo pull system");
-    }
     const registry = await loadDevices();
     const devices = [...new Set([...Object.keys(registry), machineId()].map(normalizeHost))].sort();
-    const enabled = new Set(devicesWithRoutineEnabled(ROUTINE).map(normalizeHost));
+    const enabled = new Set(devices.filter((device) => getConfigValue('watchdog.enabled', { device }).value === true));
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         requireInteractiveSelection('watchdog devices', ['agents watchdog on', 'agents watchdog on --host <device>']);
     }
@@ -27,10 +22,10 @@ export async function runWatchdogSetupWizard() {
         for (const device of devices) {
             const on = selectedSet.has(device);
             if (device === normalizeHost(machineId())) {
-                setJobEnabled(ROUTINE, on);
+                setConfigValue('watchdog.enabled', on);
                 continue;
             }
-            const launch = getCliLaunch(['routines', on ? 'resume' : 'pause', ROUTINE, '--host', device]);
+            const launch = getCliLaunch(['watchdog', on ? 'on' : 'off', '--host', device]);
             const result = spawnSync(launch.command, launch.args, { stdio: 'inherit', env: process.env });
             if ((result.status ?? 1) !== 0)
                 throw new Error(`Could not configure watchdog on ${device}`);
@@ -49,6 +44,6 @@ export async function runWatchdogSetupWizard() {
 }
 export function registerSetupWatchdogCommand(setup) {
     setup.command('watchdog')
-        .description('Choose the devices where the built-in watchdog routine runs.')
+        .description('Choose the devices where the daemon watchdog pass runs.')
         .action(runWatchdogSetupWizard);
 }

package/dist/commands/setup.js

@@ -319,7 +319,7 @@ export function registerSetupCommand(program) {
         agents setup share       # provision or join a Cloudflare share endpoint
         agents setup secrets     # choose secrets backend/policy defaults + import
         agents setup fleet       # discover Tailscale devices + configure SSH access
-        agents setup watchdog    # choose which devices run the watchdog routine
+        agents setup watchdog    # choose which devices run the daemon watchdog pass
 
       To install CLIs from agents.yaml and sync resources into version homes:
         agents sync --local -y

package/dist/commands/teams.js

@@ -47,8 +47,9 @@ const AGENT_NAMES = {
     antigravity: 'Antigravity',
     kimi: 'Kimi',
     droid: 'Droid',
+    warp: 'Warp',
 };
-const VALID_AGENTS = ['claude', 'codex', 'cursor', 'opencode', 'grok', 'antigravity', 'kimi', 'droid'];
+const VALID_AGENTS = ['claude', 'codex', 'cursor', 'opencode', 'grok', 'antigravity', 'kimi', 'droid', 'warp'];
 // 'full' kept as historical alias for 'skip'; normalized to 'skip' downstream.
 const VALID_MODES = ['plan', 'edit', 'auto', 'skip', 'full'];
 const VALID_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'auto'];
@@ -1279,7 +1280,7 @@ export function registerTeamsCommands(program) {
         .alias('a')
         .description("Add a teammate to work on a task. Runs in background; returns immediately. Use 'status' to check in.")
         .option('-n, --name <name>', 'Friendly name for this teammate (e.g. alice). Required if using --after. Unique within team.')
-        .option('-m, --mode <mode>', `Permissions: plan (read-only) | edit (can write files) | auto (smart classifier auto-approves safe ops) | skip (bypass all permission prompts). 'full' accepted as alias for skip. Teammates run headless: plan works headless on claude/codex/droid/opencode; kimi/grok/cursor/antigravity have no headless plan mode and auto-downgrade a plan request to auto.`, 'edit')
+        .option('-m, --mode <mode>', `Permissions: plan (read-only) | edit (can write files) | auto (smart classifier auto-approves safe ops) | skip (bypass all permission prompts). 'full' accepted as alias for skip. Teammates run headless: plan works headless on claude/codex/cursor/droid/opencode; kimi/grok/antigravity have no headless plan mode and auto-downgrade a plan request to auto.`, 'edit')
         .option('-e, --effort <effort>', `Reasoning intensity: ${VALID_EFFORTS.join('|')}`, 'medium')
         .option('--model <model>', 'Cost tier (cheap|default|best|ultra) or a concrete id (e.g. claude-opus-4-8); tiers resolve per harness+version to a supported model')
         .option('--env <key=value>', 'Set an environment variable for this teammate (repeatable for multiple vars)', (val, prev) => [...prev, val], [])

package/dist/commands/watchdog.d.ts

@@ -10,12 +10,11 @@
  *   agents watchdog --nudge            one tick, actually injects (explicit opt-in)
  *   agents watchdog --watch            manual poll loop (dry unless --nudge)
  *   agents watchdog --json             machine-readable tick output (for the menu-bar)
- *   agents watchdog on|off             turn the always-on watchdog routine on/off
+ *   agents watchdog on|off             turn the device-local daemon pass on/off
  *   agents watchdog policy <id> <p>    per-session policy: off | keep | handsoff
  *
- * The always-on watchdog is a daemon-fired ROUTINE, not a private sentinel + a
- * hand-rolled loop. Its immutable definition comes from the system DotAgents
- * repo; on/off only changes this device's routine membership.
+ * The agents daemon is the sole automatic watchdog scheduler. The menu bar reads
+ * persisted state; it never runs a tick.
  */
 import type { Command } from 'commander';
 /** Register the `agents watchdog` command tree. */