@phnx-labs/agents-cli 1.22.66 → 1.22.69

package/dist/lib/daemon-health.js

@@ -23,6 +23,7 @@
 import * as fs from 'fs';
 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_SECRETS_BROKER = 'secrets-broker';
@@ -61,15 +62,19 @@ function readAll() {
  * dropped health update, never escape as an unhandled rejection that would
  * hit the process-wide handler and take down every OTHER service too.
  */
-function writeAll(records) {
+function updateAll(update) {
     try {
         const healthPath = getHealthPath();
-        fs.mkdirSync(path.dirname(healthPath), { recursive: true });
-        fs.writeFileSync(healthPath, JSON.stringify(records), 'utf-8');
-        try {
-            fs.chmodSync(healthPath, 0o600);
-        }
-        catch { /* best effort */ }
+        ensureLockTarget(healthPath, '{}');
+        withFileLock(healthPath, () => {
+            const records = readAll();
+            update(records);
+            atomicWriteFileSync(healthPath, JSON.stringify(records), { encoding: 'utf-8', mode: 0o600 });
+            try {
+                fs.chmodSync(healthPath, 0o600);
+            }
+            catch { /* best effort */ }
+        });
     }
     catch { /* see docblock above — health recording must never crash a caller */ }
 }
@@ -78,23 +83,23 @@ function blankRecord(subsystem) {
 }
 /** Record a successful subsystem check-in — clears the failure streak. */
 export function recordSubsystemOk(subsystem, at = new Date().toISOString()) {
-    const all = readAll();
-    const existing = all[subsystem] ?? blankRecord(subsystem);
-    all[subsystem] = { ...existing, subsystem, consecutiveFailures: 0, lastOkAt: at };
-    writeAll(all);
+    updateAll((all) => {
+        const existing = all[subsystem] ?? blankRecord(subsystem);
+        all[subsystem] = { ...existing, subsystem, consecutiveFailures: 0, lastOkAt: at };
+    });
 }
 /** Record a subsystem failure — bumps the consecutive-failure streak. */
 export function recordSubsystemError(subsystem, error, at = new Date().toISOString()) {
-    const all = readAll();
-    const existing = all[subsystem] ?? blankRecord(subsystem);
-    all[subsystem] = {
-        ...existing,
-        subsystem,
-        lastError: error,
-        lastErrorAt: at,
-        consecutiveFailures: existing.consecutiveFailures + 1,
-    };
-    writeAll(all);
+    updateAll((all) => {
+        const existing = all[subsystem] ?? blankRecord(subsystem);
+        all[subsystem] = {
+            ...existing,
+            subsystem,
+            lastError: error,
+            lastErrorAt: at,
+            consecutiveFailures: existing.consecutiveFailures + 1,
+        };
+    });
 }
 /**
  * Refine the reason on an already-counted failure, without bumping the streak.
@@ -109,12 +114,12 @@ export function recordSubsystemError(subsystem, error, at = new Date().toISOStri
  * subsystem is left alone rather than given a blank record to decorate.
  */
 export function recordSubsystemErrorReason(subsystem, error, at = new Date().toISOString()) {
-    const all = readAll();
-    const existing = all[subsystem];
-    if (!existing)
-        return;
-    all[subsystem] = { ...existing, lastError: error, lastErrorAt: at };
-    writeAll(all);
+    updateAll((all) => {
+        const existing = all[subsystem];
+        if (!existing)
+            return;
+        all[subsystem] = { ...existing, lastError: error, lastErrorAt: at };
+    });
 }
 /**
  * Record a `ServiceSupervisor` lifecycle-state transition, without touching
@@ -123,10 +128,10 @@ export function recordSubsystemErrorReason(subsystem, error, at = new Date().toI
  * status` runs as a separate process from the daemon (see module docblock).
  */
 export function recordSubsystemState(subsystem, state) {
-    const all = readAll();
-    const existing = all[subsystem] ?? blankRecord(subsystem);
-    all[subsystem] = { ...existing, subsystem, state };
-    writeAll(all);
+    updateAll((all) => {
+        const existing = all[subsystem] ?? blankRecord(subsystem);
+        all[subsystem] = { ...existing, subsystem, state };
+    });
 }
 /** Read one subsystem's health record, or null if it has never reported in. */
 export function readSubsystemHealth(subsystem) {

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 = 'secrets-broker' | 'scheduler' | 'monitors' | 'browser-ipc' | 'webhook-receiver' | 'self-heal' | 'keychain-reap' | 'account-state' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'browser-task-reap' | 'session-state';
+export type DaemonServiceId = 'secrets-broker' | 'scheduler' | 'catchup' | 'monitors' | 'browser-ipc' | 'webhook-receiver' | 'self-heal' | 'keychain-reap' | 'account-state' | 'account-auth' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'browser-task-reap' | 'session-state';
 /** Human-readable metadata for each service. */
 export interface DaemonServiceDef {
     id: DaemonServiceId;

package/dist/lib/daemon-services.js

@@ -22,6 +22,11 @@ export const DAEMON_SERVICES = [
         title: 'Routine scheduler',
         description: 'Fires cron-scheduled routines and catches up missed fires.',
     },
+    {
+        id: 'catchup',
+        title: 'Catch-up recovery',
+        description: 'Supervised pass that re-runs routines whose scheduled fire this device missed (sleep, wedge, or suspend). No-ops while the scheduler gate is off.',
+    },
     {
         id: 'monitors',
         title: 'Monitor engine',
@@ -49,8 +54,13 @@ export const DAEMON_SERVICES = [
     },
     {
         id: 'account-state',
-        title: 'Account state',
-        description: 'Refreshes account quota/usage and publishes the local fleet-status row.',
+        title: 'Account usage refresh',
+        description: 'Refreshes account quota/usage on its own tick (PHNX-3608: independent circuit breaker from account-auth).',
+    },
+    {
+        id: 'account-auth',
+        title: 'Account auth refresh',
+        description: 'Publishes this host\'s fleet-status row and refreshes auth health on its own slower tick (PHNX-3608: independent circuit breaker from account-state).',
     },
     {
         id: 'watchdog',

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

@@ -2,10 +2,12 @@
  * Daemon account-state tick bodies.
  *
  * These two bodies are the `refreshUsage` / `refreshAuth` implementations the
- * daemon's `account-state-service.ts` timers call directly, in-process, on a
- * plain `setInterval` (usage every 60s, auth every ~3 min). They are NOT
- * routines and are never fired through the scheduler — the daemon owns usage and
- * authentication health as first-party device state (RUSH-2451).
+ * supervised `AccountStateDaemonService` (daemon/account-state-daemon-service.ts)
+ * runs on its tick, in-process (usage every tick, auth on the slower ~3 min
+ * cadence). They are NOT routines and are never fired through the scheduler — the
+ * daemon owns usage and authentication health as first-party device state
+ * (RUSH-2451); the supervisor bounds each tick with a deadline + AbortSignal so a
+ * hung refresh is abandoned and restarted instead of latching (PHNX-3608).
  *
  * `refreshLocalFleetAuthState` is also called by `agents fleet`/`ssh` surfaces
  * that need a fresh local auth snapshot on demand; provider-level work is guarded
@@ -59,11 +61,12 @@ export declare function shouldReuseCachedAuthProbe(force: boolean, cached: AuthP
  */
 export declare function refreshLocalFleetAuthState(opts?: {
     force?: boolean;
+    signal?: AbortSignal;
 }): Promise<{
     row: FleetStatusRow;
     authRows: import('./auth-health.js').AuthProbeRow[];
 }>;
-export declare function runFleetCacheWarmTick(): Promise<void>;
+export declare function runFleetCacheWarmTick(signal?: AbortSignal): Promise<void>;
 /**
  * Usage refresh: keep the usage cache the `agents run` router reads
  * (RUSH-2061, readOnly hot path) fresh, WITHOUT the hot path ever fetching.
@@ -71,7 +74,7 @@ export declare function runFleetCacheWarmTick(): Promise<void>;
  * accounts it holds credentials for, straight from the provider APIs
  * (RUSH-3193 #15; no cross-host broadcast).
  */
-export declare function runUsageRefreshTick(): Promise<void>;
+export declare function runUsageRefreshTick(signal?: AbortSignal): Promise<void>;
 /**
  * Active-sessions warm (RUSH-2062 / RUSH-2484): publish THIS host's live session
  * rows so `agents sessions watch` (and the extension that tails it) receive

package/dist/lib/daemon-ticks.js

@@ -2,10 +2,12 @@
  * Daemon account-state tick bodies.
  *
  * These two bodies are the `refreshUsage` / `refreshAuth` implementations the
- * daemon's `account-state-service.ts` timers call directly, in-process, on a
- * plain `setInterval` (usage every 60s, auth every ~3 min). They are NOT
- * routines and are never fired through the scheduler — the daemon owns usage and
- * authentication health as first-party device state (RUSH-2451).
+ * supervised `AccountStateDaemonService` (daemon/account-state-daemon-service.ts)
+ * runs on its tick, in-process (usage every tick, auth on the slower ~3 min
+ * cadence). They are NOT routines and are never fired through the scheduler — the
+ * daemon owns usage and authentication health as first-party device state
+ * (RUSH-2451); the supervisor bounds each tick with a deadline + AbortSignal so a
+ * hung refresh is abandoned and restarted instead of latching (PHNX-3608).
  *
  * `refreshLocalFleetAuthState` is also called by `agents fleet`/`ssh` surfaces
  * that need a fresh local auth snapshot on demand; provider-level work is guarded
@@ -62,6 +64,7 @@ export function shouldReuseCachedAuthProbe(force, cached, now, maxAgeMs = AUTH_P
  */
 export async function refreshLocalFleetAuthState(opts) {
     const force = opts?.force === true;
+    const signal = opts?.signal;
     const { machineId } = await import('./machine-id.js');
     const { probeLocalFleetAuth, readFleetAuthRows, writeFleetAuthRows } = await import('./auth-health.js');
     const { getCliVersion } = await import('./version.js');
@@ -89,7 +92,7 @@ export async function refreshLocalFleetAuthState(opts) {
             // Fleet status publishes every tick regardless — it does not ride that endpoint.
             const cached = readFleetAuthRows(self);
             const reuse = shouldReuseCachedAuthProbe(force, cached, requestedAt);
-            const authRows = reuse ? cached : await probeLocalFleetAuth({ cliVersion: getCliVersion(), forceLive: force });
+            const authRows = reuse ? cached : await probeLocalFleetAuth({ cliVersion: getCliVersion(), forceLive: force, signal });
             if (!reuse)
                 writeFleetAuthRows(self, authRows);
             const row = await publishLocalFleetStatus(self);
@@ -97,8 +100,8 @@ export async function refreshLocalFleetAuthState(opts) {
         },
     });
 }
-export async function runFleetCacheWarmTick() {
-    const result = await refreshLocalFleetAuthState();
+export async function runFleetCacheWarmTick(signal) {
+    const result = await refreshLocalFleetAuthState({ signal });
     // A waiter receives the already-published fleet row. The auth-row count is
     // available only to the process that performed the provider probes.
     const row = result.row;
@@ -112,7 +115,7 @@ export async function runFleetCacheWarmTick() {
  * accounts it holds credentials for, straight from the provider APIs
  * (RUSH-3193 #15; no cross-host broadcast).
  */
-export async function runUsageRefreshTick() {
+export async function runUsageRefreshTick(signal) {
     const { runUsageRefresh, buildLocalUsageAccounts } = await import('./usage-refresh.js');
     const { writeClaudeUsageCache, readClaudeUsageCache } = await import('./accounting/usage.js');
     const { usageRateLimitedUntil } = await import('./usage-backoff.js');
@@ -124,6 +127,9 @@ export async function runUsageRefreshTick() {
         // so a recent capture means the account is already fresh at zero API cost —
         // the refresher re-derives headroom from it and skips the API fetch.
         readCachedSnapshot: (usageKey) => readClaudeUsageCache(usageKey),
+        // Thread the supervisor deadline into each provider fetch so the tick's I/O
+        // is bounded by deadlineMs, not just each fetch's own 5s timeout (PHNX-3608).
+        signal,
     });
     const { listProfiles } = await import('./profiles.js');
     const { refreshDueByokUsage } = await import('./byok-usage.js');

package/dist/lib/devices/health.d.ts

@@ -12,9 +12,37 @@
  * separate copy on purpose: the CLI does not import across packages.
  */
 import type { DeviceProfile } from './registry.js';
-/** Default per-device probe budget. Short enough that the list never hangs on a
- * wedged box, long enough for a cold relayed SSH handshake. */
+/** Default per-device probe budget, for a device reachable over a DIRECT
+ * Tailscale path. Short enough that the list never hangs on a wedged box. */
 export declare const PROBE_TIMEOUT_MS = 2500;
+/**
+ * Probe budget for a device whose last handshake was DERP-relayed
+ * ({@link DeviceTailscale.direct} === false).
+ *
+ * This constant used to not exist: 2.5s was applied to every device and its
+ * docstring claimed to be "long enough for a cold relayed SSH handshake". That
+ * was false, and on a fleet with no direct paths it broke `--device auto`
+ * outright (PHNX-3682). Measured on a 9-box relayed fleet, probed in parallel
+ * with cold paths: 1686/1805/1914/2688/2706/2749/3082/5586/6588 ms — six of nine
+ * over budget, every one of them healthy (rc=0 within 10s). Warm, the same
+ * probes take 512-872ms, which is what made the failure intermittent.
+ *
+ * A relayed hop pays DERP path setup on top of the TCP+SSH handshake, so it
+ * gets the same budget the readiness probe already allows
+ * (`READY_PROBE_TIMEOUT_MS`) rather than the direct-path one.
+ */
+export declare const RELAYED_PROBE_TIMEOUT_MS = 8000;
+/**
+ * The probe budget for one device. A relayed peer gets
+ * {@link RELAYED_PROBE_TIMEOUT_MS}; a direct (or unknown-path) peer keeps the
+ * tight {@link PROBE_TIMEOUT_MS}. Windows keeps its own larger budget, which
+ * already exceeds both.
+ *
+ * `direct` is only meaningful when a tailscale snapshot exists — a
+ * `via:"manual"` device never gets a peer entry, so absence is "unknown path",
+ * not "relayed", and must not silently widen every manual device's budget.
+ */
+export declare function probeBudgetMs(device: DeviceProfile): number;
 /** Windows probe budget. The first CIM query of a PowerShell session pays a
  * "Preparing modules for first use" cost on top of PowerShell startup, which
  * routinely blows the 2.5s POSIX budget on a relayed connection. */
@@ -35,6 +63,14 @@ export declare function localProbeInvocation(platform: NodeJS.Platform): {
 export interface DeviceStats {
     host: string;
     reachable: boolean;
+    /**
+     * The probe exceeded its budget rather than being refused or unresolvable.
+     * Only meaningful when `reachable` is false — it separates "this box did not
+     * answer in time" from "this box actively could not be reached", so callers
+     * report a slow link honestly instead of calling a healthy device offline
+     * (PHNX-3682).
+     */
+    timedOut?: boolean;
     loadAvg1?: number;
     ncpu?: number;
     /** Load normalized to core count (the "has room" number): loadAvg1 / ncpu *

package/dist/lib/devices/health.js

@@ -13,9 +13,43 @@
  */
 import { execFile } from 'child_process';
 import { buildSshInvocation, writeAskpassShim } from './connect.js';
-/** Default per-device probe budget. Short enough that the list never hangs on a
- * wedged box, long enough for a cold relayed SSH handshake. */
+/** Default per-device probe budget, for a device reachable over a DIRECT
+ * Tailscale path. Short enough that the list never hangs on a wedged box. */
 export const PROBE_TIMEOUT_MS = 2_500;
+/**
+ * Probe budget for a device whose last handshake was DERP-relayed
+ * ({@link DeviceTailscale.direct} === false).
+ *
+ * This constant used to not exist: 2.5s was applied to every device and its
+ * docstring claimed to be "long enough for a cold relayed SSH handshake". That
+ * was false, and on a fleet with no direct paths it broke `--device auto`
+ * outright (PHNX-3682). Measured on a 9-box relayed fleet, probed in parallel
+ * with cold paths: 1686/1805/1914/2688/2706/2749/3082/5586/6588 ms — six of nine
+ * over budget, every one of them healthy (rc=0 within 10s). Warm, the same
+ * probes take 512-872ms, which is what made the failure intermittent.
+ *
+ * A relayed hop pays DERP path setup on top of the TCP+SSH handshake, so it
+ * gets the same budget the readiness probe already allows
+ * (`READY_PROBE_TIMEOUT_MS`) rather than the direct-path one.
+ */
+export const RELAYED_PROBE_TIMEOUT_MS = 8_000;
+/**
+ * The probe budget for one device. A relayed peer gets
+ * {@link RELAYED_PROBE_TIMEOUT_MS}; a direct (or unknown-path) peer keeps the
+ * tight {@link PROBE_TIMEOUT_MS}. Windows keeps its own larger budget, which
+ * already exceeds both.
+ *
+ * `direct` is only meaningful when a tailscale snapshot exists — a
+ * `via:"manual"` device never gets a peer entry, so absence is "unknown path",
+ * not "relayed", and must not silently widen every manual device's budget.
+ */
+export function probeBudgetMs(device) {
+    if (device.shell === 'powershell')
+        return WIN_PROBE_TIMEOUT_MS;
+    return device.tailscale && device.tailscale.direct === false
+        ? RELAYED_PROBE_TIMEOUT_MS
+        : PROBE_TIMEOUT_MS;
+}
 /** Windows probe budget. The first CIM query of a PowerShell session pays a
  * "Preparing modules for first use" cost on top of PowerShell startup, which
  * routinely blows the 2.5s POSIX budget on a relayed connection. */
@@ -227,10 +261,14 @@ export function probeDeviceStats(device, opts = {}) {
         execFile('ssh', args, {
             encoding: 'utf-8',
             env: { ...process.env, ...env },
-            timeout: opts.timeoutMs ?? (isWin ? WIN_PROBE_TIMEOUT_MS : PROBE_TIMEOUT_MS),
+            timeout: opts.timeoutMs ?? probeBudgetMs(device),
         }, (err, stdout) => {
-            if (err || !stdout)
-                return resolve({ host, reachable: false, fetchedAt });
+            // execFile kills an over-budget child with a signal; that is a slow link,
+            // not an unreachable box, and the two must not read the same downstream.
+            if (err || !stdout) {
+                const timedOut = Boolean(err && err.killed);
+                return resolve(timedOut ? { host, reachable: false, timedOut, fetchedAt } : { host, reachable: false, fetchedAt });
+            }
             resolve(isWin ? parseWinProbeOutput(host, stdout, fetchedAt) : parseProbeOutput(host, stdout, fetchedAt));
         });
     });

package/dist/lib/devices/registry.js

@@ -21,6 +21,7 @@ import { getDevicesRegistryPath, readMeta, updateMeta } from '../state.js';
 import { atomicWriteJsonSync } from '../fs-atomic.js';
 import { machineId } from '../machine-id.js';
 import { addIgnoredEntry, unionDeviceIgnored } from './device-docs.js';
+import { logAndContinueOnLockCompromised } from '../lock-compromise.js';
 /**
  * Whether a fan-out should dial this device, honouring the preference stated on
  * {@link DeviceProfile.reachability}: the live SSH probe wins over the cached
@@ -141,6 +142,7 @@ async function withRegistryLock(p, fn) {
     const release = await lockfile.lock(p, {
         retries: { retries: 60, minTimeout: 25, maxTimeout: 250, factor: 1.5 },
         stale: 10_000,
+        onCompromised: logAndContinueOnLockCompromised('devices registry'),
     });
     try {
         return await fn();

package/dist/lib/devices/worker-pick.d.ts

@@ -2,7 +2,7 @@ import { type DevicePlacementSignal } from '../teams/scheduler.js';
 /** Why a candidate was dropped, for the fail-loud error message. */
 export interface WorkerExclusion {
     device: string;
-    reason: 'unreachable' | 'overloaded' | 'wrong-platform' | 'interactive';
+    reason: 'unreachable' | 'probe timed out' | 'overloaded' | 'wrong-platform' | 'interactive';
 }
 export interface WorkerPickPlan {
     /** The chosen device name. Never the local box unless it is an auto-pool member. */

package/dist/lib/devices/worker-pick.js

@@ -79,7 +79,10 @@ export async function resolveWorkerDevice(opts = {}) {
     const eligible = onPlatform.filter((device) => {
         const signal = signals.get(device);
         if (signal?.reachable !== true) {
-            excluded.push({ device, reason: 'unreachable' });
+            // A probe killed for exceeding its budget says nothing about whether the
+            // box is up — on a relayed fleet it usually is. Report the two apart so
+            // the message points at the link, not at a fleet outage (PHNX-3682).
+            excluded.push({ device, reason: signal?.timedOut ? 'probe timed out' : 'unreachable' });
             return false;
         }
         if (signal.headroom === 'loaded') {

package/dist/lib/exec.js

@@ -40,6 +40,7 @@ import { resolveHarnessAdapter, stripForeignConfigDir } from './harness/index.js
 import { resolveConfigVersion } from './harness/exec-config-version.js';
 import { getAccountInfo } from './agents.js';
 import { getUsageLookupKey, noteClaudeSessionLimit, noteClaudeOutOfCredits, clearClaudeAccountRefusal, parseClaudeSessionLimitReset } from './accounting/usage.js';
+import { bootMark, flushBootProfile } from './boot-profile.js';
 /**
  * Map a raw mode string (CLI flag, YAML field, env var) to the canonical Mode.
  *
@@ -409,6 +410,17 @@ export function buildExecEnv(options) {
     // re-parsing harness-specific transcripts.
     result.AGENTS_RUN_MODE = resolveHeadlessMode(options.agent, normalizeMode(options.mode), resolveInteractive(options), options.modeWarningContext, options.modeWarningState);
     result.AGENTS_HISTORY_DIR = getHistoryDir();
+    // Durable origin version for a later native resume. The SessionStart hook joins
+    // this to the harness's real session id (like AGENTS_RUN_MODE), so recovery can
+    // pin the exact origin version even when the transcript carries no derivable one
+    // (codex's `.codex-homes/<version>/` home) — the "version not recorded" fallback
+    // to `/continue` this closes (PHNX-3626). Resolve the concrete version-home id
+    // the same way the spawn path does; only stamp a real one.
+    if (options.agent) {
+        const runVersion = options.version ?? resolveVersion(options.agent, options.cwd || process.cwd());
+        if (runVersion)
+            result.AGENTS_RUN_VERSION = runVersion;
+    }
     // So activity / feed posts stamp the right harness without re-detecting.
     // A custom-harness run (`agents run deepseek`) must stamp the PROFILE name,
     // not the host CLI (`claude`) — otherwise sessions and feed posts cannot
@@ -1722,6 +1734,7 @@ async function emitRunLaunch(ctx) {
     }
 }
 async function spawnAgent(options) {
+    bootMark('spawn-agent:enter');
     // Assign a known session id up front for agents that accept one, so the
     // launcher can record an EXACT pid -> session mapping (see pid-registry) —
     // otherwise the headless `ag sessions --active` path can only guess
@@ -1856,6 +1869,7 @@ async function spawnAgent(options) {
     });
     if (tmuxWrap.kind === 'wrap') {
         timer.mark('startup');
+        flushBootProfile('spawn');
         try {
             const result = await runInTmux(options, executable, args);
             timer.end({ exitCode: result.exitCode, status: result.exitCode === 0 ? 'success' : 'failed' });
@@ -1887,6 +1901,7 @@ async function spawnAgent(options) {
         const useShell = process.platform === 'win32' && (!path.isAbsolute(executable) || executable.endsWith('.cmd'));
         const spawnCommand = useShell ? composeWin32CommandLine(executable, args) : executable;
         const spawnArgs = useShell ? [] : args;
+        flushBootProfile('spawn');
         const child = spawn(spawnCommand, spawnArgs, {
             cwd: options.cwd || process.cwd(),
             stdio,

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

@@ -18,6 +18,9 @@ export type FeedWatchEnvelope = Base & {
     type: 'agent.upsert';
     rowKey: string;
     agent: SessionWatchRow;
+} | Base & {
+    type: 'agent.remove';
+    rowKey: string;
 } | Base & {
     type: 'attention.upsert';
     rowKey: string;

package/dist/lib/feed/watch.js

@@ -21,13 +21,20 @@ export class FeedWatchState {
     }
 }
 async function attentionFor(agent) {
-    if (!agent.sessionId)
+    // Durable Previous rows share the operator stream for Sessions history, but
+    // they are not live work and must never synthesize Needs-you attention.
+    if (!agent.sessionId || agent.previous || agent.context === 'recent')
         return undefined;
     const blockId = blockIdForSession(agent.sessionId);
     // ActiveSession.host names the terminal app; the feed contract's host is the
     // device scope. Normalize only the reconciler input so lifecycle/PR keys are
     // routable across the fleet while the projected agent row stays compatible.
-    const session = { ...agent, host: agent.sourceDevice, viewingIn: undefined };
+    const session = {
+        ...agent,
+        context: agent.context,
+        host: agent.sourceDevice,
+        viewingIn: undefined,
+    };
     return reconcileAttention({
         block: readBlock(blockId), session,
         resolution: readResolution(blockId),
@@ -49,7 +56,10 @@ export async function projectSessionEnvelope(event, state) {
         ];
     }
     if (event.type === 'remove')
-        return [state.emit({ type: 'attention.remove', scope: event.scope, rowKey: event.rowKey })];
+        return [
+            state.emit({ type: 'agent.remove', scope: event.scope, rowKey: event.rowKey }),
+            state.emit({ type: 'attention.remove', scope: event.scope, rowKey: event.rowKey }),
+        ];
     if (event.type === 'scope')
         return [state.emit({ type: 'scope', capturedAt: event.capturedAt, scope: event.scope, status: event.status, ...(event.reason ? { reason: event.reason } : {}) })];
     return [state.emit({ type: 'heartbeat', capturedAt: event.capturedAt, scope: event.scope })];

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

@@ -136,11 +136,56 @@ export interface SinkOutcome {
 export declare function shortHost(host: string | undefined): string | undefined;
 /** First 8 hex chars of a session id for the footer (readable, not a full uuid). */
 export declare function shortSessionChunk(session: string | undefined): string | undefined;
+/**
+ * Tap-to-view link for the session behind a post: the addressable console page
+ * ({@link https://prix.dev/console/sessions/<id>}, prix/web). The footer already
+ * carries a short session crumb for disambiguation; this rides the link trail so
+ * the owner can open the full transcript straight from an iMessage broadcast
+ * instead of hunting for it in the console.
+ *
+ * Accepts any real, path-safe session id — a Claude/Codex UUID *and* a native
+ * `ses_…` id from OpenCode or another harness. The console shard uploader
+ * (`traces/sync.ts`) syncs sessions with no harness filter, so all of them are
+ * addressable; a UUID-only gate would silently drop the link for every non-Claude
+ * harness (the whole point of the link). Reject only an id that could not resolve:
+ * one with a path separator (URL-unsafe, via {@link isValidMailboxId}) or the bare
+ * 8-char footer crumb (a truncated id that would 404).
+ */
+export declare function sessionConsoleUrl(session: string | undefined): string | undefined;
 /**
  * Scrub em/en dashes from outbound phone copy (house rule + iMessage readability).
  * Collapses whitespace; does not invent meaning.
  */
 export declare function scrubOutboundDashes(text: string): string;
+/**
+ * The rendering vocabulary a sink can display, which decides how the shared
+ * `{message}` surfaces its links (PHNX-3698):
+ *
+ *   - `mrkdwn` — Slack, which renders `<url|label>` as blue tappable text. The
+ *     session crumb and every ticket key the prose NAMES become inline labeled
+ *     links, so nothing rides a trailing naked-URL line.
+ *   - `plain` — iMessage, the owner-scoped rush message, a spawned `command:`
+ *     sink, desktop banners: none can render a labeled link and a dumped naked
+ *     URL reads as noise, so the message stays the human sentence with no URLs.
+ *
+ * The default is `plain`; only a Slack `channel:` sink opts into `mrkdwn`.
+ */
+export type SinkMessageFormat = 'plain' | 'mrkdwn';
+/**
+ * Only Slack renders `<url|label>`, so it is the one format that gets labeled
+ * links. iMessage / owner-scoped rush / command / desktop sinks stay `plain`
+ * (they can't turn `claude/6fc1db18` blue, and dumping the raw URL is worse than
+ * leaving the crumb unlinked — PHNX-3698).
+ *
+ * The argument is the **resolved provider name**, not the sink's declared
+ * channel: an operator can point an arbitrary channel name at the Slack provider
+ * through `notify.transports` (e.g. `eng-alerts -> slack`), and delivery keys off
+ * that resolved provider (`lookupTransport`), so the format decision must too —
+ * otherwise an aliased Slack sink would compose plain while delivering to Slack,
+ * or a name remapped AWAY from Slack would emit `<url|label>` markup a non-Slack
+ * transport shows literally. {@link resolveSinkProvider} does the mapping.
+ */
+export declare function sinkMessageFormat(provider: string | undefined): SinkMessageFormat;
 /**
  * Footer like "Sent from my iPhone" — who posted, a session crumb, which box.
  *
@@ -148,10 +193,15 @@ export declare function scrubOutboundDashes(text: string): string;
  *
  * Agent name first; session chunk for disambiguation when many groks run;
  * host last. Skip the uninformative default label `agent`.
+ *
+ * In `mrkdwn` the crumb (`agent/short`) becomes a Slack labeled link to the
+ * session's console page, so the human sentence reads identically while the
+ * crumb turns blue and taps through (PHNX-3698). `plain` keeps the bare sentence
+ * — it can't render a labeled link and must not dump the URL.
  */
-export declare function composeBroadcastFooter(ctx: FeedBroadcastContext): string | undefined;
+export declare function composeBroadcastFooter(ctx: FeedBroadcastContext, format?: SinkMessageFormat): string | undefined;
 export declare function truncateBroadcastBody(body: string): string;
-export declare function composeBroadcastMessage(ctx: FeedBroadcastContext): string;
+export declare function composeBroadcastMessage(ctx: FeedBroadcastContext, format?: SinkMessageFormat): string;
 /**
  * Substitute `{placeholder}` tokens in an argv template. Returns undefined when
  * the template needs a value this post does not have — the sink is then skipped
@@ -159,8 +209,13 @@ export declare function composeBroadcastMessage(ctx: FeedBroadcastContext): stri
  * would otherwise comment on nothing.
  */
 export declare function renderSinkArgv(template: string[], ctx: FeedBroadcastContext): string[] | undefined;
-/** Render one channel-message template with the same fail-closed placeholder contract as argv. */
-export declare function renderSinkMessage(template: string, ctx: FeedBroadcastContext): string | undefined;
+/**
+ * Render one channel-message template with the same fail-closed placeholder
+ * contract as argv. `format` (Slack `mrkdwn` vs `plain`) flows into the shared
+ * `{message}` var so a Slack sink gets labeled links and an iMessage/owner sink
+ * gets the plain sentence.
+ */
+export declare function renderSinkMessage(template: string, ctx: FeedBroadcastContext, format?: SinkMessageFormat): string | undefined;
 /**
  * Which sinks this post reaches, in config order. Pure — the dry-run listing and
  * the real fan-out plan through here, so what `--dry-run` shows is what runs.
@@ -168,8 +223,12 @@ export declare function renderSinkMessage(template: string, ctx: FeedBroadcastCo
  * A `channel:` sink is gated by the same `minLevel` rule as a `command:` sink —
  * one level check for both shapes, so a dry-run plan is truthful regardless of
  * which shape an operator's sink uses.
+ *
+ * `meta` is used only to resolve a channel name to its real provider for the
+ * mrkdwn/plain format decision (`notify.transports`), the same map delivery uses;
+ * it is optional so a test can plan without a config snapshot (identity mapping).
  */
-export declare function planFeedBroadcast(config: FeedBroadcastConfig | undefined, ctx: FeedBroadcastContext): PlannedSink[];
+export declare function planFeedBroadcast(config: FeedBroadcastConfig | undefined, ctx: FeedBroadcastContext, meta?: Meta): PlannedSink[];
 /**
  * The effective sink config for a post: the operator's `feed.broadcast`, or —
  * when that is unset or empty — an implicit fallback straight to