@phnx-labs/agents-cli 1.22.39 → 1.22.40

package/dist/lib/{daemon.js → daemon/daemon.js}

@@ -10,29 +10,31 @@ import { spawn, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { getDaemonDir } from './state.js';
-import { isAlive, killTree, backgroundSpawnOptions, waitForExit } from './platform/index.js';
-import { listJobs as listAllJobs } from './routines.js';
-import { syncAllProjectRoutines } from './routines-project.js';
-import { JobScheduler } from './scheduler.js';
-import { MonitorEngine } from './monitors/engine.js';
-import { executeJobDetached, monitorRunningJobs, listLiveRoutineChildren } from './runner.js';
-import { detectOverdueJobs, notifyOverdue } from './overdue.js';
-import { runCatchup } from './catchup.js';
-import { notifyRoutineStart, notifyRoutineFinish, notifyRoutineStartFailed } from './routine-notify.js';
-import { notifyOwnerRoutineFinish, notifyOwnerRoutineStartFailed } from './routine-notify-owner.js';
-import { BrowserService } from './browser/service.js';
-import { BrowserIPCServer, getSocketPath as getBrowserIpcSocketPath } from './browser/ipc.js';
-import { secretsBrokerSocketPath, brokerPidAlive } from './secrets/agent.js';
-import { redactSecrets } from './redact.js';
-import { getAgentsBinPath, getCliLaunch, BUN_VIRTUAL_ROOT } from './cli-entry.js';
-import { isSchedulerEnabled, assertSchedulerEnabled, isDaemonEnabled, getConfigValue } from './device-config.js';
-import { reapTerminalRoutineProcesses } from './routine-process-cleanup.js';
-import { recordSubsystemOk, recordSubsystemError, recordSubsystemErrorReason, readSubsystemHealth, SUBSYSTEM_SECRETS_BROKER, SUBSYSTEM_BROWSER_IPC, SUBSYSTEM_DAEMON_START } from './daemon-health.js';
-import { startAccountStateService } from './account-state-service.js';
-import { runActiveSessionsWarmTick, runFleetCacheWarmTick, runUsageRefreshTick } from './daemon-ticks.js';
-import { emit, emitRoutineEnd } from './events.js';
-import { readDaemonServicesConfig } from './daemon-services.js';
+import { getDaemonDir } from '../state.js';
+import { isolatedHomeSuffix, namespacedServiceLabel, serviceManifestHomeEnv } from '../service-manifest.js';
+import { isAlive, killTree, backgroundSpawnOptions, waitForExit } from '../platform/index.js';
+import { listJobs as listAllJobs } from '../scheduling/routines.js';
+import { syncAllProjectRoutines } from '../routines-project.js';
+import { JobScheduler } from '../scheduler.js';
+import { MonitorEngine } from '../monitors/engine.js';
+import { executeJobDetached, monitorRunningJobs, listLiveRoutineChildren } from '../runner.js';
+import { detectOverdueJobs, notifyOverdue } from '../overdue.js';
+import { runCatchup } from '../catchup.js';
+import { notifyRoutineStart, notifyRoutineFinish, notifyRoutineStartFailed } from '../routine-notify.js';
+import { notifyOwnerRoutineFinish, notifyOwnerRoutineStartFailed } from '../routine-notify-owner.js';
+import { BrowserService } from '../browser/service.js';
+import { BrowserIPCServer, getSocketPath as getBrowserIpcSocketPath } from '../browser/ipc.js';
+import { startHostedWebhookReceivers } from '../daemon-webhooks.js';
+import { secretsBrokerSocketPath, brokerPidAlive } from '../secrets/agent.js';
+import { redactSecrets } from '../redact.js';
+import { getAgentsBinPath, getCliLaunch, BUN_VIRTUAL_ROOT } from '../cli-entry.js';
+import { isSchedulerEnabled, assertSchedulerEnabled, isDaemonEnabled, getConfigValue, resolveBrowserTaskIdleMs } from '../device-config.js';
+import { reapTerminalRoutineProcesses } from '../routine-process-cleanup.js';
+import { recordSubsystemOk, recordSubsystemError, recordSubsystemErrorReason, readSubsystemHealth, SUBSYSTEM_SECRETS_BROKER, SUBSYSTEM_BROWSER_IPC, SUBSYSTEM_DAEMON_START } from '../daemon-health.js';
+import { startAccountStateService } from '../account-state-service.js';
+import { runActiveSessionsWarmTick, runFleetCacheWarmTick, runSessionIndexWarmTick, runUsageRefreshTick } from '../daemon-ticks.js';
+import { emit, emitRoutineEnd } from '../feed/events.js';
+import { readDaemonServicesConfig } from '../daemon-services.js';
 const PID_FILE = 'daemon.pid';
 const LIFETIME_FILE = 'daemon.lifetime';
 const LOCK_FILE = 'daemon.lock';
@@ -42,6 +44,46 @@ const LOG_MAX_SIZE = 5 * 1024 * 1024; // 5 MB
 const LOG_ROTATE_COUNT = 3;
 const PLIST_NAME = 'com.phnx-labs.agents-daemon';
 const SYSTEMD_UNIT = 'agents-daemon.service';
+/**
+ * RUSH-2639 (residual): launchd/systemd route `unload`/`load`/`list` by the
+ * service identifier ALONE, never by the plist/unit file's path. Baking the
+ * caller's HOME into the plist content (the earlier RUSH-2639 fix, above)
+ * keeps the STARTED daemon inside its sandbox, but every hermetic-test
+ * instance and every real interactive install still share the one literal
+ * `PLIST_NAME`/`SYSTEMD_UNIT` string. `startDaemonLocked`'s own `unload`
+ * before `load` is written to be a no-op ("not loaded, expected") for a
+ * plist that has never been loaded — but confirmed on darwin: when a
+ * DIFFERENT plist is already loaded under that same label, `unload
+ * <this-instance's-own-never-loaded-path>` still tears down the OTHER job
+ * (verified directly against real launchctl with two throwaway plists
+ * sharing one label — the second job's own `unload` silently kills the
+ * first, still alive under a different path). On a machine running several
+ * hermetic test forks at once (CI) — or a developer's own suite next to
+ * their real always-on daemon — that "other job" is a live daemon with
+ * DIFFERENT baked-in state.
+ *
+ * Namespace the identifier itself whenever HOME has been redirected away
+ * from the account's real home. `os.userInfo().homedir` reads the OS/passwd
+ * record directly and ignores `$HOME` (unlike `os.homedir()`, which honors
+ * it), so comparing the two detects exactly this redirection — true for
+ * every hermetic test process, false for every real interactive/production
+ * invocation, so a real user's daemon keeps registering under the unchanged
+ * production identifier.
+ *
+ * The rule itself now lives in `service-manifest.ts` — the daemon was the first
+ * manifest to need it, not the only one — and is re-exported here because it is
+ * part of this module's published surface.
+ */
+export { isolatedHomeSuffix };
+/** launchd Label for this process's daemon — namespaced under a redirected HOME. */
+export function daemonServiceLabel() {
+    return namespacedServiceLabel(PLIST_NAME);
+}
+/** systemd --user unit name for this process's daemon — namespaced under a redirected HOME. */
+export function daemonSystemdUnitName() {
+    const suffix = isolatedHomeSuffix();
+    return suffix ? `agents-daemon-sandbox-${suffix}.service` : SYSTEMD_UNIT;
+}
 const MONITOR_TICK_MS = 60_000;
 /**
  * How often to re-scan for missed fires. Deliberately slower than the monitor
@@ -73,6 +115,8 @@ const BROKER_SELF_HEAL_TICK_MS = 60_000;
 const KEYCHAIN_REAP_TICK_MS = 5 * 60_000;
 // RUSH-2501: reap tmux sessions whose panes are all dead every 5 minutes.
 const DEAD_PANE_REAP_TICK_MS = 5 * 60_000;
+// RUSH-2622: close abandoned browser-task tabs every 5 minutes.
+const BROWSER_TASK_REAP_TICK_MS = 5 * 60_000;
 const STATE_DIR_CHECK_TICK_MS = 60_000;
 // Watchdog nudges this host's own stalled sessions; device-probe refreshes
 // registered devices' reachability and surfaces newly appeared tailnet nodes.
@@ -84,6 +128,10 @@ const DEVICE_PROBE_TICK_MS = 3 * 60_000;
 // Matches DEFAULT_ACTIVE_CACHE_MAX_AGE_MS (15s) so long-lived watchers never
 // outlive the publisher (RUSH-2484 — CLI-owned continuous publish).
 const ACTIVE_SESSIONS_WARM_TICK_MS = 15_000;
+// Incrementally scan this host's transcript dirs into the local index so a
+// locally-started session is indexed within seconds, not on the next unrelated
+// `agents sessions*` call (RUSH-2682 — indexing was lazy, nothing scheduled it).
+const SESSION_INDEX_WARM_TICK_MS = 20_000;
 const WEDGE_THRESHOLD_TICKS = 3;
 /**
  * Crash-loop prevention (RUSH-2418). Three layers, because none of them alone
@@ -221,10 +269,10 @@ export function getDaemonLogPath() {
     return path.join(ensureDaemonDir(), LOG_FILE);
 }
 function getLaunchdPlistPath() {
-    return path.join(os.homedir(), 'Library', 'LaunchAgents', `${PLIST_NAME}.plist`);
+    return path.join(os.homedir(), 'Library', 'LaunchAgents', `${daemonServiceLabel()}.plist`);
 }
 function getSystemdUnitPath() {
-    return path.join(os.homedir(), '.config', 'systemd', 'user', `${SYSTEMD_UNIT}`);
+    return path.join(os.homedir(), '.config', 'systemd', 'user', daemonSystemdUnitName());
 }
 /** Read the stored daemon PID from disk. Returns null if not present or invalid. */
 export function readDaemonPid() {
@@ -668,6 +716,7 @@ export function warnEphemeralDaemonRoot(resolveBin = getAgentsBinPath) {
 let healing = false;
 let reapingKeychain = false;
 let reapingDeadPanes = false;
+let reapingBrowserTasks = false;
 /**
  * Resource self-heal: fill missing resources, repair invalid manifests, and
  * fast-forward pristine stale plugins. Conservative 'safe' mode: never
@@ -684,7 +733,7 @@ async function runHealCheck() {
         return;
     healing = true;
     try {
-        const { runSelfHeal, selfHealChangedAnything, selfHealNeedsAttention, summarizeSelfHeal } = await import('./self-heal/registry.js');
+        const { runSelfHeal, selfHealChangedAnything, selfHealNeedsAttention, summarizeSelfHeal } = await import('../self-heal/registry.js');
         if (!fs.existsSync(getDaemonDir()))
             return;
         const report = await runSelfHeal({ mode: 'safe' });
@@ -709,7 +758,7 @@ async function runKeychainReap() {
         return;
     reapingKeychain = true;
     try {
-        const { reapOrphanedKeychainProcesses } = await import('./secrets/reaper.js');
+        const { reapOrphanedKeychainProcesses } = await import('../secrets/reaper.js');
         const result = reapOrphanedKeychainProcesses();
         if (result.reaped > 0) {
             log('WARN', `Reaped ${result.reaped} keychain orphan/stuck process(es)`);
@@ -738,8 +787,8 @@ async function runDeadPaneReap() {
         return;
     reapingDeadPanes = true;
     try {
-        const { reapDeadTmuxPanes } = await import('./tmux/session.js');
-        const { getDefaultSocketPath } = await import('./tmux/paths.js');
+        const { reapDeadTmuxPanes } = await import('../tmux/session.js');
+        const { getDefaultSocketPath } = await import('../tmux/paths.js');
         const result = await reapDeadTmuxPanes(getDefaultSocketPath());
         for (const w of result.warnings)
             log('WARN', `Dead-pane reaper: ${w}`);
@@ -761,6 +810,35 @@ async function runDeadPaneReap() {
         reapingDeadPanes = false;
     }
 }
+/**
+ * RUSH-2622: close abandoned browser-task tabs — a task whose owning agent
+ * session has exited, or one idle past `browser.task-idle-minutes` (default 30,
+ * 0 disables idle reaping only). Same policy `agents browser gc` triggers on
+ * demand; this is the periodic side, and the daemon is the single executor so
+ * no UI surface can race it. `service` is the daemon's own long-lived
+ * BrowserService — the browser IPC server it started earlier in `runDaemon()`.
+ *
+ * Runs every BROWSER_TASK_REAP_TICK_MS (5 min).
+ */
+async function runBrowserTaskReap(service) {
+    if (reapingBrowserTasks)
+        return;
+    reapingBrowserTasks = true;
+    try {
+        const result = await service.reapAbandoned({ idleMs: resolveBrowserTaskIdleMs() });
+        if (result.closed.length > 0) {
+            log('INFO', `Browser-task reaper: closed ${result.closed.length} task(s)`);
+            for (const c of result.closed)
+                log('INFO', `  ${c.task} (${c.reason}, profile ${c.profile})`);
+        }
+    }
+    catch (err) {
+        log('ERROR', `Browser-task reaper failed: ${err.message}`);
+    }
+    finally {
+        reapingBrowserTasks = false;
+    }
+}
 /**
  * One monitor tick: write heartbeat + drain the running-job monitor + reap
  * stale terminal routine process groups. Runs on MONITOR_TICK_MS.
@@ -793,18 +871,37 @@ export async function runDaemon() {
     log('INFO', `Daemon started (PID: ${process.pid})`);
     anchorDaemonCwd();
     warnEphemeralDaemonRoot();
-    // Fold legacy per-device config stores into the central
-    // fleet.devices.<name>.config block (idempotent, cheap no-op once folded).
-    // The daemon boots via `agents __daemon-run`, which bypasses bootstrap's
-    // migration sentinel — so the daemon runs this itself so its scheduler/
-    // watchdog gates read the converged store.
+    // Converge the device-config/pins stores (legacy central block /
+    // auto-launch.json / tracked-doc pins → per-device docs + pins file).
+    // Idempotent, cheap no-op once folded. The daemon boots via
+    // `agents __daemon-run`, which bypasses bootstrap's migration sentinel — so
+    // the daemon runs this itself so its scheduler/watchdog gates read the
+    // converged store.
     try {
-        const { migrateDeviceConfigToCentral } = await import('./devices/config-migration.js');
-        migrateDeviceConfigToCentral();
+        const { migrateDeviceConfigStores } = await import('../devices/config-migration.js');
+        migrateDeviceConfigStores();
     }
     catch (err) {
         log('WARN', `device config migration failed: ${err.message}`);
     }
+    // Version-skew one-shot (RUSH-2435): retrofit the current pane-died hook onto
+    // any managed tmux session a pre-fix binary left with a stale one. The 5-min
+    // `tmux-reconcile` routine that used to run this on a poll was deleted
+    // (RUSH-2495) — startup + `ensureSessionHookRepaired` at attach time
+    // (tmux/session.ts) now cover what that poll used to. Idempotent and
+    // non-destructive: a session already at the current schema is a no-op.
+    try {
+        const { reconcileSessionHooks } = await import('../tmux/session.js');
+        const { isTmuxInstalled } = await import('../tmux/binary.js');
+        if (isTmuxInstalled()) {
+            const r = await reconcileSessionHooks();
+            if (r.reconciled > 0)
+                log('INFO', `tmux: retrofitted pane-died hook on ${r.reconciled}/${r.scanned} session(s)`);
+        }
+    }
+    catch (err) {
+        log('WARN', `tmux hook reconcile failed: ${err.message}`);
+    }
     // Per-service toggles live outside device-config so they can be checked by
     // service clients (e.g. secrets) without loading the whole config stack.
     let servicesConfig = readDaemonServicesConfig();
@@ -842,7 +939,7 @@ export async function runDaemon() {
     let hostedBroker = null;
     if (isEnabled('secrets-broker')) {
         try {
-            const { agentPing, startHostedBroker } = await import('./secrets/agent.js');
+            const { agentPing, startHostedBroker } = await import('../secrets/agent.js');
             if ((await agentPing()).reachable) {
                 log('INFO', 'Secrets broker already running (standalone); daemon not hosting it');
             }
@@ -1028,6 +1125,35 @@ export async function runDaemon() {
     };
     void runActiveSessionsWarm();
     const activeSessionsWarmInterval = setInterval(() => { void runActiveSessionsWarm(); }, ACTIVE_SESSIONS_WARM_TICK_MS);
+    // Session-index warm (RUSH-2682): keep THIS host's transcript index current so
+    // a locally-started session is discoverable within seconds. Incremental +
+    // single-flight (the DB scan claim), overlap-guarded so a slow scan never
+    // stacks on the next tick.
+    let sessionIndexWarmInFlight = false;
+    const runSessionIndexWarm = async () => {
+        if (sessionIndexWarmInFlight)
+            return;
+        sessionIndexWarmInFlight = true;
+        try {
+            const { indexed, claimed } = await runSessionIndexWarmTick();
+            // Log only when the tick did something. A silent tick is what let it
+            // report 0 forever unnoticed (RUSH-2691); a line on every idle 20s tick
+            // would drown the log, so the steady state (claimed, nothing changed)
+            // stays quiet and both interesting outcomes are visible.
+            if (!claimed)
+                log('INFO', 'session-index warm: skipped, another process holds the scan claim');
+            else if (indexed > 0)
+                log('INFO', `session-index warm: indexed ${indexed} transcript(s)`);
+        }
+        catch (err) {
+            log('WARN', `session-index warm failed: ${err.message}`);
+        }
+        finally {
+            sessionIndexWarmInFlight = false;
+        }
+    };
+    void runSessionIndexWarm();
+    const sessionIndexWarmInterval = setInterval(() => { void runSessionIndexWarm(); }, SESSION_INDEX_WARM_TICK_MS);
     // Watchdog: nudge this host's own stalled agent sessions. Gated on the
     // `watchdog.enabled` device-config flag (`agents watchdog enable`), so the
     // timer always fires but only does work when the user opted in. Overlap-safe
@@ -1042,7 +1168,7 @@ export async function runDaemon() {
             try {
                 if (getConfigValue('watchdog.enabled').value !== true)
                     return;
-                const { runWatchdogPass } = await import('./watchdog/service.js');
+                const { runWatchdogPass } = await import('../watchdog/service.js');
                 const result = await runWatchdogPass({ nudge: true });
                 log('INFO', `watchdog: ${result.counts.total} live, ${result.counts.stalled} stalled, ${result.counts.nudged} nudged`);
                 emit('watchdog.action', {
@@ -1081,8 +1207,8 @@ export async function runDaemon() {
                 return;
             deviceProbeInFlight = true;
             try {
-                const { runDeviceSync } = await import('./devices/sync.js');
-                const { reconcilePendingSentinels, pruneDismissedPendingSentinels, } = await import('./devices/pending.js');
+                const { runDeviceSync } = await import('../devices/sync.js');
+                const { reconcilePendingSentinels, pruneDismissedPendingSentinels, } = await import('../devices/pending.js');
                 const dev = await runDeviceSync({ soft: true, mode: 'refresh' });
                 if (!dev.ok) {
                     await pruneDismissedPendingSentinels();
@@ -1204,7 +1330,7 @@ export async function runDaemon() {
     // (cdp:// profile silently driven via stale ssh tunnel) or fail to
     // bind because the ports are still claimed.
     try {
-        const { reapOrphanedProcesses } = await import('./browser/runtime-state.js');
+        const { reapOrphanedProcesses } = await import('../browser/runtime-state.js');
         const result = reapOrphanedProcesses();
         if (result.reaped > 0) {
             log('INFO', `Reaped ${result.reaped} orphan process(es) from prior daemon(s)`);
@@ -1232,6 +1358,25 @@ export async function runDaemon() {
     else {
         log('INFO', 'Browser IPC service disabled');
     }
+    // 5th hosted service: signed webhook receiver(s) + their funnel (RUSH-2548).
+    // Started after the broker (above) so it resolves each receiver's signing
+    // secret headlessly — no AGENTS_SECRETS_PASSPHRASE, no nohup. Binds nothing
+    // unless daemon/webhooks.yaml declares a receiver, so an unconfigured box no-ops.
+    let webhookReceivers = null;
+    if (isEnabled('webhook-receiver')) {
+        try {
+            webhookReceivers = await startHostedWebhookReceivers({ log });
+            log('INFO', webhookReceivers.count > 0
+                ? `Webhook receiver hosting ${webhookReceivers.count} receiver(s)`
+                : 'Webhook receiver service enabled; no receivers declared in daemon/webhooks.yaml');
+        }
+        catch (err) {
+            log('WARN', `Webhook receiver host skipped: ${err.message}`);
+        }
+    }
+    else {
+        log('INFO', 'Webhook receiver service disabled');
+    }
     runMonitorTick();
     const monitorInterval = setInterval(runMonitorTick, MONITOR_TICK_MS);
     // Resource safety check: see runHealCheck above. Runs ~every 6h plus once
@@ -1264,7 +1409,7 @@ export async function runDaemon() {
                 return;
             selfHealingBroker = true;
             try {
-                const { agentPing, startHostedBroker } = await import('./secrets/agent.js');
+                const { agentPing, startHostedBroker } = await import('../secrets/agent.js');
                 const reachable = (await agentPing()).reachable;
                 if (!shouldTakeOverBroker(hostedBroker != null, reachable))
                     return;
@@ -1296,6 +1441,15 @@ export async function runDaemon() {
     // 5-min cadence as the keychain reaper. Daemon-only (single executor).
     void runDeadPaneReap(); // kick-off on startup so the backlog clears immediately
     const deadPaneReapInterval = setInterval(() => { void runDeadPaneReap(); }, DEAD_PANE_REAP_TICK_MS);
+    // RUSH-2622: close abandoned browser-task tabs on the same 5-min cadence,
+    // reusing the daemon's own long-lived BrowserService instead of a second
+    // one. Only when browser IPC is actually up — there is no service to reap
+    // through otherwise.
+    let browserTaskReapInterval;
+    if (browserService) {
+        void runBrowserTaskReap(browserService); // kick-off on startup
+        browserTaskReapInterval = setInterval(() => { void runBrowserTaskReap(browserService); }, BROWSER_TASK_REAP_TICK_MS);
+    }
     // RUSH-2367: self-terminate if this daemon's own state dir has been removed
     // out from under it — the shape of a leaked test-fixture daemon whose /tmp
     // HOME was deleted by its test's own cleanup while the process itself
@@ -1432,6 +1586,7 @@ export async function runDaemon() {
         log('INFO', 'Daemon shutting down');
         accountStateService?.stop();
         clearInterval(activeSessionsWarmInterval);
+        clearInterval(sessionIndexWarmInterval);
         if (watchdogInterval)
             clearInterval(watchdogInterval);
         if (deviceProbeInterval)
@@ -1439,6 +1594,7 @@ export async function runDaemon() {
         stopScheduler();
         monitorEngine?.stop();
         await browserIPC?.stop();
+        await webhookReceivers?.close();
         clearInterval(monitorInterval);
         if (healInterval)
             clearInterval(healInterval);
@@ -1449,6 +1605,8 @@ export async function runDaemon() {
         if (keychainReapInterval)
             clearInterval(keychainReapInterval);
         clearInterval(deadPaneReapInterval);
+        if (browserTaskReapInterval)
+            clearInterval(browserTaskReapInterval);
         if (stateDirCheckInterval)
             clearInterval(stateDirCheckInterval);
         try {
@@ -1500,16 +1658,32 @@ export function writeOwnerOnlyServiceManifest(filePath, content) {
  * credential at all. Routine runs authenticate through the per-account
  * CLAUDE_CONFIG_DIR login on this device, exactly like an interactive
  * `agents run`, so no credential ever touches the service manifest.
+ *
+ * RUSH-2639: launchd does NOT inherit `launchctl load`'s caller's process
+ * environment — a spawned daemon only ever sees the login session's default
+ * env plus whatever this dict adds/overrides. Before this fix the dict carried
+ * only PATH, so HOME resolved to the launchd session's own value regardless of
+ * what HOME the process that generated (and loaded) the plist was running
+ * under. In production that's a no-op (the login session's HOME already is the
+ * real HOME), but under a hermetic test harness that redirects HOME to a
+ * fork-private sandbox, a launchd-started daemon silently escaped the sandbox
+ * and bootstrapped `~/.agents` (.cache/.history/.system/routines) in the
+ * developer's/runner's REAL home. Baking HOME (and the AGENTS_REAL_HOME seam
+ * every version-home consumer honors, see tests/setup.ts) into the plist at
+ * generation time makes the launchd child inherit the SAME home the caller
+ * resolved, exactly like the plain detached-spawn path already does via
+ * `env: {...process.env}`.
  */
 export function generateLaunchdPlist(agentsBin = getAgentsBinPath()) {
     const launch = getDaemonLaunch(agentsBin);
     const logPath = getDaemonLogPath();
+    const { HOME: home, AGENTS_REAL_HOME: realHome } = serviceManifestHomeEnv();
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>${PLIST_NAME}</string>
+  <string>${daemonServiceLabel()}</string>
   <key>ProgramArguments</key>
   <array>
 ${[launch.command, ...launch.args].map((arg) => `    <string>${xmlEscape(arg)}</string>`).join('\n')}
@@ -1528,6 +1702,10 @@ ${[launch.command, ...launch.args].map((arg) => `    <string>${xmlEscape(arg)}</
   <dict>
     <key>PATH</key>
     <string>${daemonPathValue(agentsBin, ['/usr/local/bin', '/usr/bin', '/bin', '/opt/homebrew/bin', `${os.homedir()}/.bun/bin`])}</string>
+    <key>HOME</key>
+    <string>${xmlEscape(home)}</string>
+    <key>AGENTS_REAL_HOME</key>
+    <string>${xmlEscape(realHome)}</string>
   </dict>
 </dict>
 </plist>`;
@@ -1543,10 +1721,18 @@ function systemdExecArg(value) {
  * credential at all. Routine runs authenticate through the per-account
  * CLAUDE_CONFIG_DIR login on this device, exactly like an interactive
  * `agents run`, so no credential ever touches the unit file.
+ *
+ * RUSH-2639: same seam as `generateLaunchdPlist` — a systemd --user unit is
+ * started by the user's systemd instance, not the process that generated the
+ * unit, so HOME is whatever that session provides unless this file pins it.
+ * Baking HOME (and AGENTS_REAL_HOME) in at generation time keeps a
+ * hermetic-test-started unit inside its sandbox instead of resolving against
+ * the real account home.
  */
 export function generateSystemdUnit(agentsBin = getAgentsBinPath()) {
     const launch = getDaemonLaunch(agentsBin);
     const execStart = [launch.command, ...launch.args].map(systemdExecArg).join(' ');
+    const { HOME: home, AGENTS_REAL_HOME: realHome } = serviceManifestHomeEnv();
     return `[Unit]
 Description=Agents Daemon - Scheduled Job Runner
 After=network.target
@@ -1559,6 +1745,8 @@ ExecStart=${execStart}
 Restart=always
 RestartSec=${DAEMON_THROTTLE_SECONDS}
 Environment=PATH=${daemonPathValue(agentsBin, ['/usr/local/bin', '/usr/bin', '/bin'])}
+Environment=HOME=${home}
+Environment=AGENTS_REAL_HOME=${realHome}
 
 [Install]
 WantedBy=default.target`;
@@ -1577,12 +1765,12 @@ export { getAgentsBinPath };
 function readServiceManagerPid(platform = os.platform()) {
     try {
         if (platform === 'linux') {
-            const out = execFileSync('systemctl', ['--user', 'show', '-p', 'MainPID', '--value', SYSTEMD_UNIT], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+            const out = execFileSync('systemctl', ['--user', 'show', '-p', 'MainPID', '--value', daemonSystemdUnitName()], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
             const pid = parseInt(out, 10);
             return !isNaN(pid) && pid > 0 ? pid : null;
         }
         if (platform === 'darwin') {
-            const out = execFileSync('launchctl', ['list', PLIST_NAME], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+            const out = execFileSync('launchctl', ['list', daemonServiceLabel()], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
             const m = out.match(/"PID"\s*=\s*(\d+)/);
             if (m) {
                 const pid = parseInt(m[1], 10);
@@ -1767,8 +1955,8 @@ function startDaemonLocked(agentsBin, releaseLock) {
             // itself at startup); owner-only to keep the PATH/log surface private.
             writeOwnerOnlyServiceManifest(unitPath, generateSystemdUnit(agentsBin));
             execFileSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf-8' });
-            execFileSync('systemctl', ['--user', 'enable', SYSTEMD_UNIT], { encoding: 'utf-8' });
-            execFileSync('systemctl', ['--user', 'start', SYSTEMD_UNIT], { encoding: 'utf-8' });
+            execFileSync('systemctl', ['--user', 'enable', daemonSystemdUnitName()], { encoding: 'utf-8' });
+            execFileSync('systemctl', ['--user', 'start', daemonSystemdUnitName()], { encoding: 'utf-8' });
             // Launch issued — the child needs this lock to claim (RUSH-2417).
             releaseLock();
             const pid = waitForPid(3000) ?? readServiceManagerPid();
@@ -2089,8 +2277,8 @@ export function stopDaemon() {
     }
     if (platform === 'linux') {
         try {
-            execFileSync('systemctl', ['--user', 'stop', SYSTEMD_UNIT], { encoding: 'utf-8' });
-            execFileSync('systemctl', ['--user', 'disable', SYSTEMD_UNIT], { encoding: 'utf-8' });
+            execFileSync('systemctl', ['--user', 'stop', daemonSystemdUnitName()], { encoding: 'utf-8' });
+            execFileSync('systemctl', ['--user', 'disable', daemonSystemdUnitName()], { encoding: 'utf-8' });
         }
         catch (err) {
             if (process.env.AGENTS_DEBUG) {

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

package/dist/lib/daemon-services.js

@@ -32,6 +32,11 @@ export const DAEMON_SERVICES = [
         title: 'Browser IPC',
         description: 'Keeps a supervised browser automation IPC socket available for sessions.',
     },
+    {
+        id: 'webhook-receiver',
+        title: 'Webhook receiver',
+        description: 'Hosts signed GitHub/Linear webhook ingress declared in daemon/webhooks.yaml, drawing signing secrets from the broker; binds nothing when no receivers are declared.',
+    },
     {
         id: 'self-heal',
         title: 'Self-heal registry',

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

@@ -48,3 +48,28 @@ export declare function runActiveSessionsWarmTick(opts?: {
 }): Promise<{
     sessions: number;
 }>;
+/**
+ * Session-index warm (RUSH-2682): incrementally scan THIS host's transcript dirs
+ * into the local SQLite index on a timer, so a session started HERE reaches this
+ * box's index within seconds instead of on the next unrelated `agents sessions*`
+ * call. Indexing was otherwise lazy — only `discoverSessions` writes the index,
+ * and nothing scheduled it — which inverted freshness: a peer's session arrived
+ * via sync in ~0s while a locally-started one sat unindexed for minutes.
+ *
+ * The scan is incremental (only files whose mtime/size changed) and single-flight
+ * across processes via the DB scan claim, so a foreground `agents sessions*` and
+ * this tick never double-scan. The daemon is the single scheduled executor,
+ * consistent with the one-scheduler rule.
+ *
+ * Calls `scanSessionsIncremental`, NOT `discoverSessions` (RUSH-2691). A bare
+ * `discoverSessions()` ends in a listing query that defaults its cwd filter to
+ * `process.cwd()` — the daemon's, i.e. `$HOME` — and caps at 50, so its row count
+ * described "sessions whose cwd is exactly $HOME", which is 0 on a normal box no
+ * matter how much the scan indexed. The tick reported that 0 every 20s while
+ * still paying for the query's existence check and Linear fetch. Scanning
+ * directly reports what was actually parsed and skips the query entirely.
+ */
+export declare function runSessionIndexWarmTick(): Promise<{
+    indexed: number;
+    claimed: boolean;
+}>;

package/dist/lib/daemon-ticks.js

@@ -77,7 +77,7 @@ export async function runUsageRefreshTick() {
         return;
     }
     const { runUsageRefresh, buildLocalUsageAccounts } = await import('./usage-refresh.js');
-    const { writeClaudeUsageCache } = await import('./usage.js');
+    const { writeClaudeUsageCache } = await import('./accounting/usage.js');
     const { usageRateLimitedUntil } = await import('./usage-backoff.js');
     const r = await runUsageRefresh({
         listAccounts: buildLocalUsageAccounts,
@@ -106,3 +106,33 @@ export async function runActiveSessionsWarmTick(opts = {}) {
     console.log(`active-sessions warm: ${r.sessions.length} session(s) published`);
     return { sessions: r.sessions.length };
 }
+/**
+ * Session-index warm (RUSH-2682): incrementally scan THIS host's transcript dirs
+ * into the local SQLite index on a timer, so a session started HERE reaches this
+ * box's index within seconds instead of on the next unrelated `agents sessions*`
+ * call. Indexing was otherwise lazy — only `discoverSessions` writes the index,
+ * and nothing scheduled it — which inverted freshness: a peer's session arrived
+ * via sync in ~0s while a locally-started one sat unindexed for minutes.
+ *
+ * The scan is incremental (only files whose mtime/size changed) and single-flight
+ * across processes via the DB scan claim, so a foreground `agents sessions*` and
+ * this tick never double-scan. The daemon is the single scheduled executor,
+ * consistent with the one-scheduler rule.
+ *
+ * Calls `scanSessionsIncremental`, NOT `discoverSessions` (RUSH-2691). A bare
+ * `discoverSessions()` ends in a listing query that defaults its cwd filter to
+ * `process.cwd()` — the daemon's, i.e. `$HOME` — and caps at 50, so its row count
+ * described "sessions whose cwd is exactly $HOME", which is 0 on a normal box no
+ * matter how much the scan indexed. The tick reported that 0 every 20s while
+ * still paying for the query's existence check and Linear fetch. Scanning
+ * directly reports what was actually parsed and skips the query entirely.
+ */
+export async function runSessionIndexWarmTick() {
+    const { scanSessionsIncremental } = await import('./session/discover.js');
+    const { claimed, scanned } = await scanSessionsIncremental();
+    // A skipped claim is not a failure — a foreground `agents sessions*` is
+    // scanning right now and this tick would be a duplicate.
+    if (!claimed)
+        return { indexed: 0, claimed: false };
+    return { indexed: scanned, claimed: true };
+}