@phnx-labs/agents-cli 1.22.107 → 1.22.110

package/dist/lib/daemon/daemon.js

@@ -32,6 +32,7 @@ import { recordSubsystemOk, recordSubsystemError, recordSubsystemErrorReason, re
 import { ServiceSupervisor } from './supervisor.js';
 import { SessionIndexService } from './session-index-service.js';
 import { SessionSummarizerService } from './session-summarizer-service.js';
+import { SessionTitleService } from './session-title-service.js';
 import { MonitorEngineService } from './monitor-engine-service.js';
 import { AccountUsageService, AccountAuthService } from './account-state-daemon-service.js';
 import { CatchupService } from './catchup-service.js';
@@ -77,6 +78,16 @@ 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';
+/**
+ * The service-manager identifiers of the REAL install's daemon — never
+ * namespaced. A caller under a redirected HOME (a test/e2e harness) uses these
+ * to recognize the box's production daemon as owned, where
+ * `daemonSystemdUnitName()`/`daemonServiceLabel()` would name only its own
+ * sandbox job (W4, PHNX-3736).
+ */
+export function productionDaemonServiceNames() {
+    return { systemdUnit: SYSTEMD_UNIT, launchdLabel: PLIST_NAME };
+}
 /**
  * RUSH-2639 (residual): launchd/systemd route `unload`/`load`/`list` by the
  * service identifier ALONE, never by the plist/unit file's path. Baking the
@@ -286,8 +297,8 @@ function getSystemdUnitPath() {
     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() {
-    const pidPath = getPidPath();
+export function readDaemonPid(daemonDir) {
+    const pidPath = daemonDir ? path.join(daemonDir, PID_FILE) : getPidPath();
     if (!fs.existsSync(pidPath))
         return null;
     try {
@@ -1060,6 +1071,12 @@ export async function runDaemon() {
         supervisor.register(new AttentionNotifyService());
     else
         log('INFO', 'Attention-notify service disabled');
+    // Session titles (PHNX-3797) — generates each session row's headline once,
+    // with a cheap model, off the request path.
+    if (isEnabled('session-title'))
+        supervisor.register(new SessionTitleService());
+    else
+        log('INFO', 'Session-title service disabled');
     // Watchdog, device-probe, and self-heal are all periodic services managed
     // by the ServiceSupervisor (RUSH-3193 P3). Each is gated the same way as
     // the socket services above; state-dir-check is registered separately,
@@ -1655,19 +1672,27 @@ export { getAgentsBinPath };
  * the daemon hasn't yet written its pid file but launchd/systemd already report
  * it running — so a start never has to surface a null PID for a daemon that is
  * in fact up. Returns null when the service isn't running or the query fails.
+ *
+ * `names` defaults to THIS process's (possibly sandbox-namespaced) job; a
+ * caller under a redirected HOME passes `productionDaemonServiceNames()` to
+ * ask after the real install's unit instead. Read-only either way.
  */
-function readServiceManagerPid(platform = os.platform()) {
-    const reg = serviceManagerRegistrationAllowed();
-    if (!reg.allowed)
+export function readServiceManagerPid(platform = os.platform(), names) {
+    const resolved = names ?? { systemdUnit: daemonSystemdUnitName(), launchdLabel: daemonServiceLabel() };
+    // The registration gate exists because a sandboxed process must not REGISTER
+    // or tear down jobs in the real per-user service manager. Asking after an
+    // explicitly named job is read-only — in particular the production unit from
+    // a redirected-HOME caller (W4) — and mutates nothing, so it is let through.
+    if (names === undefined && !serviceManagerRegistrationAllowed().allowed)
         return null;
     try {
         if (platform === 'linux') {
-            const out = execFileSync('systemctl', ['--user', 'show', '-p', 'MainPID', '--value', daemonSystemdUnitName()], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+            const out = execFileSync('systemctl', ['--user', 'show', '-p', 'MainPID', '--value', resolved.systemdUnit], { 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', daemonServiceLabel()], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+            const out = execFileSync('launchctl', ['list', resolved.launchdLabel], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
             const m = out.match(/"PID"\s*=\s*(\d+)/);
             if (m) {
                 const pid = parseInt(m[1], 10);
@@ -1678,12 +1703,47 @@ function readServiceManagerPid(platform = os.platform()) {
     catch { /* not running / manager unavailable */ }
     return null;
 }
+/**
+ * Thrown when a daemon LAUNCH is attempted under a redirected HOME without the
+ * explicit test opt-in (W4, PHNX-3736). `bootstrap.ts` prints the message
+ * without a stack — this is user-actionable, not an engineering bug.
+ */
+export class RedirectedHomeDaemonError extends Error {
+    name = 'RedirectedHomeDaemonError';
+}
+/**
+ * W4 (PHNX-3736): never LAUNCH a daemon under a redirected (sandbox/test) HOME
+ * without an explicit opt-in. A daemon started there keeps its own pid file
+ * under the temp home, so the real install's pid-file takeover can never see
+ * it — the leaked `HOME=/tmp/pin-e2e-<pid>` daemon that ran 4+ days on
+ * yosemite-s1 was launched exactly this way by a headless e2e session that
+ * never cleaned up. RUSH-3021 closed this for `ensureDaemonStarted`'s
+ * AUTO-start path but left the explicit `startDaemon()` open, which is the
+ * path the e2e harness took.
+ *
+ * Placed after the `already-running` early-return: reporting a live daemon (so
+ * `daemon stop` can still kill a leaked one) must stay possible under any
+ * HOME. `AGENTS_ALLOW_TEST_DAEMON=1` is the deliberate test/e2e seam — a
+ * harness that sets it owns stopping what it starts.
+ */
+function assertDaemonLaunchHomeAllowed() {
+    const suffix = isolatedHomeSuffix();
+    if (!suffix)
+        return;
+    if (process.env.AGENTS_ALLOW_TEST_DAEMON === '1')
+        return;
+    throw new RedirectedHomeDaemonError(`refusing to start the daemon under a redirected HOME (sandbox-${suffix}): ` +
+        `a daemon launched here keeps its own pid file under ${process.env.HOME}, invisible to the real ` +
+        `install's pid-file takeover, and outlives whatever launched it (PHNX-3736). ` +
+        `For a deliberate test/e2e launch set AGENTS_ALLOW_TEST_DAEMON=1 — and stop the daemon when done.`);
+}
 /** Start the daemon via launchd, systemd, or as a detached process. */
 export function startDaemon(agentsBin) {
     if (isDaemonRunning()) {
         const pid = readDaemonPid();
         return { pid, method: 'already-running' };
     }
+    assertDaemonLaunchHomeAllowed();
     const releaseLock = acquireStartLock();
     if (!releaseLock) {
         // Another process is already starting the daemon
@@ -1769,8 +1829,9 @@ export function ensureDaemonStarted() {
     // recursive teardown rm (ENOTEMPTY). Placed after the already-running branch
     // — reporting a live daemon stays allowed, same as the circuit breaker.
     // AGENTS_SERVICE_MANAGER_ALLOW_REDIRECTED_HOME=1 is the test seam for suites
-    // that exercise daemon startup deliberately; `agents daemon start` remains
-    // the operator override.
+    // that exercise daemon startup deliberately. The explicit `agents daemon
+    // start` path is gated separately by startDaemon's own redirected-HOME
+    // refusal (AGENTS_ALLOW_TEST_DAEMON=1, W4/PHNX-3736).
     if (!serviceManagerRegistrationAllowed().allowed)
         return null;
     // RUSH-2418: the auto-start circuit breaker. A daemon that dies during

package/dist/lib/daemon/leaked-daemons.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The daemon state dir for an ARBITRARY home — the same layout state.ts's
+ * DAEMON_DIR chain produces (`<home>/.agents/.cache/helpers/daemon`). A caller
+ * under a redirected HOME (a test/e2e harness) uses this to find the REAL
+ * install's daemon records. Kept here rather than exported from state.ts: any
+ * edit to state.ts selects its entire static-import closure into the required
+ * impact gate (186 files, 295s against the 240s budget, measured on this
+ * change's first CI run), so the helper cannot live there without a
+ * budget-policy change. If state.ts's layout ever moves, this must move with
+ * it — the two are the same address.
+ */
+export declare function getDaemonDirForHome(home: string): string;
+/** One live `__daemon-run` process from the box-wide `ps` scan. */
+export interface DaemonRunProcess {
+    pid: number;
+    /** Owning uid from `ps`, or null when unavailable. */
+    uid: number | null;
+    /** Whitespace-tokenized argv (`ps` renders it unquoted). */
+    tokens: string[];
+}
+/**
+ * Every live `__daemon-run` process on this box, regardless of which install
+ * launched it or which state dir it serves. POSIX-only (uses `ps`); a no-op on
+ * Windows.
+ *
+ * `getDaemonLaunch` always spawns `<node> <entry> __daemon-run` with nothing
+ * after it — the ONLY argv `__daemon-run` ever appears in for a real daemon.
+ * A substring/regex test anywhere in the full command line is not enough: an
+ * `agents run claude "<prompt>"` invocation whose prompt happens to quote the
+ * literal text `__daemon-run` (this ticket's own brief does) matches that test
+ * too, and was observed producing false "duplicate daemon" rows. Requiring it
+ * to be the LAST whitespace-delimited token is the actual invariant.
+ *
+ * This raw box-wide scan is deliberately NOT the duplicate-detection scope
+ * (RUSH-2368): a `__daemon-run` under a different HOME serves a different
+ * `getDaemonDir()` and is not a duplicate of THIS device's daemon, however
+ * `ps` sees it — a leaked vitest fixture under its own `/tmp` HOME matched
+ * this scan and was reported as a stray to `kill`. Callers attach their own
+ * scope: `agents daemon status` gates on the instance registry,
+ * {@link findLeakedDaemons} on the owner records above.
+ */
+export declare function listDaemonRunProcesses(): DaemonRunProcess[];
+/** A `__daemon-run` process no owner record names. */
+export interface LeakedDaemon {
+    pid: number;
+    /** The HOME the process runs under, or null when it cannot be read. */
+    home: string | null;
+    /** The process's start time as `ps lstart` renders it, or null when unavailable. */
+    startedAt: string | null;
+    /** The launch entry (the argv token before `__daemon-run`), best-effort. */
+    entry: string | null;
+}
+/**
+ * Every `__daemon-run` process running as THIS uid that no owner record names:
+ * neither the service manager's unit main PID nor the recorded
+ * `<daemonDir>/daemon.pid`. Each result carries the process's HOME and start
+ * time so the report can show them. An empty list means no leak — including
+ * the common stopped-daemon case, where there is simply nothing running.
+ */
+export declare function findLeakedDaemons(): LeakedDaemon[];

package/dist/lib/daemon/leaked-daemons.js

@@ -0,0 +1,180 @@
+/**
+ * Leaked-daemon detection (W4, PHNX-3736).
+ *
+ * One daemon per device is the contract: the always-on process behind
+ * `agents __daemon-run` is either the service manager's unit main PID or the
+ * pid recorded in `<daemonDir>/daemon.pid`. Anything else running
+ * `__daemon-run` as this uid is a LEAK — a daemon nothing owns.
+ *
+ * The motivating incident ran 4+ days on yosemite-s1: a headless e2e session
+ * launched a daemon under `HOME=/tmp/pin-e2e-<pid>` and never stopped it. The
+ * pid-file takeover in `daemon.ts` could not see it because it keeps its own
+ * pid file under the temp home, and `agents daemon status`'s duplicate scope
+ * (`findSurvivingStateDirDaemons`, RUSH-2368) deliberately covers only this
+ * install's state dir — so the leak was invisible to every existing surface.
+ *
+ * Why flagging a different-HOME daemon here is not the RUSH-2368 harm: that
+ * incident taught that a `__daemon-run` under another HOME is not a DUPLICATE
+ * of this device's daemon and must never be told to `kill` from the duplicate
+ * path. This module does not accuse it of being a duplicate — it reports that
+ * NO owner record (unit main PID, recorded daemon.pid) names the pid at all,
+ * and shows the process's own HOME and start time so the operator can judge
+ * before acting. A different uid is never named: we cannot inspect its
+ * environment or signal it.
+ */
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { productionDaemonServiceNames, readDaemonPid, readServiceManagerPid } from './daemon.js';
+import { getDaemonDir } from '../state.js';
+/**
+ * The daemon state dir for an ARBITRARY home — the same layout state.ts's
+ * DAEMON_DIR chain produces (`<home>/.agents/.cache/helpers/daemon`). A caller
+ * under a redirected HOME (a test/e2e harness) uses this to find the REAL
+ * install's daemon records. Kept here rather than exported from state.ts: any
+ * edit to state.ts selects its entire static-import closure into the required
+ * impact gate (186 files, 295s against the 240s budget, measured on this
+ * change's first CI run), so the helper cannot live there without a
+ * budget-policy change. If state.ts's layout ever moves, this must move with
+ * it — the two are the same address.
+ */
+export function getDaemonDirForHome(home) {
+    return path.join(home, '.agents', '.cache', 'helpers', 'daemon');
+}
+/**
+ * Every live `__daemon-run` process on this box, regardless of which install
+ * launched it or which state dir it serves. POSIX-only (uses `ps`); a no-op on
+ * Windows.
+ *
+ * `getDaemonLaunch` always spawns `<node> <entry> __daemon-run` with nothing
+ * after it — the ONLY argv `__daemon-run` ever appears in for a real daemon.
+ * A substring/regex test anywhere in the full command line is not enough: an
+ * `agents run claude "<prompt>"` invocation whose prompt happens to quote the
+ * literal text `__daemon-run` (this ticket's own brief does) matches that test
+ * too, and was observed producing false "duplicate daemon" rows. Requiring it
+ * to be the LAST whitespace-delimited token is the actual invariant.
+ *
+ * This raw box-wide scan is deliberately NOT the duplicate-detection scope
+ * (RUSH-2368): a `__daemon-run` under a different HOME serves a different
+ * `getDaemonDir()` and is not a duplicate of THIS device's daemon, however
+ * `ps` sees it — a leaked vitest fixture under its own `/tmp` HOME matched
+ * this scan and was reported as a stray to `kill`. Callers attach their own
+ * scope: `agents daemon status` gates on the instance registry,
+ * {@link findLeakedDaemons} on the owner records above.
+ */
+export function listDaemonRunProcesses() {
+    if (process.platform === 'win32')
+        return [];
+    let out;
+    try {
+        out = execFileSync('ps', ['-eo', 'pid=,uid=,args='], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const line of out.split('\n')) {
+        const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+        if (!m)
+            continue;
+        const tokens = m[3].trim().split(/\s+/);
+        if (tokens.length === 0 || tokens[tokens.length - 1] !== '__daemon-run')
+            continue;
+        const pid = parseInt(m[1], 10);
+        if (isNaN(pid))
+            continue;
+        const uidParsed = parseInt(m[2], 10);
+        found.push({ pid, uid: isNaN(uidParsed) ? null : uidParsed, tokens });
+    }
+    return found;
+}
+/**
+ * The HOME of a live process, or null when unreadable. Linux reads
+ * `/proc/<pid>/environ`; macOS has no equivalent zero-dependency primitive, so
+ * it falls back to `ps -E`, which appends the environment to the command
+ * column. Both are best-effort: a null HOME must never turn into an accusation
+ * beyond "unknown".
+ */
+function processHome(pid) {
+    if (process.platform === 'linux') {
+        try {
+            const env = fs.readFileSync(`/proc/${pid}/environ`, 'utf-8');
+            for (const entry of env.split('\0')) {
+                if (entry.startsWith('HOME='))
+                    return entry.slice('HOME='.length) || null;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const out = execFileSync('ps', ['-E', '-o', 'command=', '-p', String(pid)], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const m = out.match(/(?:^|\s)HOME=(\S+)/);
+        return m ? m[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The start time of a live process as `ps lstart` renders it, or null (best-effort, POSIX only). */
+function processStartTime(pid) {
+    if (process.platform === 'win32')
+        return null;
+    try {
+        const out = execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Every `__daemon-run` process running as THIS uid that no owner record names:
+ * neither the service manager's unit main PID nor the recorded
+ * `<daemonDir>/daemon.pid`. Each result carries the process's HOME and start
+ * time so the report can show them. An empty list means no leak — including
+ * the common stopped-daemon case, where there is simply nothing running.
+ */
+export function findLeakedDaemons() {
+    const owned = new Set();
+    const recorded = readDaemonPid();
+    if (recorded)
+        owned.add(recorded);
+    const unitPid = readServiceManagerPid();
+    if (unitPid)
+        owned.add(unitPid);
+    // A caller under a redirected HOME (a test/e2e harness) must still recognize
+    // the REAL install's daemon as owned: its records live under the account
+    // home (`os.userInfo().homedir` reads the passwd record, ignoring $HOME),
+    // not under this process's HOME. Flagging the box's healthy production
+    // daemon as a leak would be the RUSH-2368 harm through a new door.
+    const realDaemonDir = getDaemonDirForHome(os.userInfo().homedir);
+    if (realDaemonDir !== getDaemonDir()) {
+        const realRecorded = readDaemonPid(realDaemonDir);
+        if (realRecorded)
+            owned.add(realRecorded);
+        const realUnitPid = readServiceManagerPid(os.platform(), productionDaemonServiceNames());
+        if (realUnitPid)
+            owned.add(realUnitPid);
+    }
+    const myUid = typeof process.getuid === 'function' ? process.getuid() : null;
+    const leaked = [];
+    for (const p of listDaemonRunProcesses()) {
+        if (owned.has(p.pid))
+            continue;
+        // Another uid's daemon is never named: we cannot read its environment
+        // reliably and could not signal it if we tried.
+        if (myUid !== null && p.uid !== null && p.uid !== myUid)
+            continue;
+        leaked.push({
+            pid: p.pid,
+            home: processHome(p.pid),
+            startedAt: processStartTime(p.pid),
+            entry: p.tokens.length >= 2 ? p.tokens[p.tokens.length - 2] : null,
+        });
+    }
+    return leaked;
+}

package/dist/lib/daemon/session-title-service.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Session-title service (PHNX-3797) — the ONE generator of session headlines.
+ *
+ * Every session row's headline used to be the agent's latest transcript line.
+ * This service replaces it with a user-anchored NAME: it sweeps the local
+ * session index for recent sessions whose title is still the raw first user
+ * message, asks a {@link SessionTitleProvider} (the cloud cheap-model call by
+ * default) for a short action+object headline, and persists it
+ * (`lib/session/title.ts`). Because the value lands in the index, every consumer
+ * — the CLI list, the picker, `sessions watch --json`, the fleet mirror, AGI EXT
+ * — reads one title that was generated exactly once.
+ *
+ * Cost is bounded by construction, not by hope: at most
+ * {@link SESSION_TITLE_MAX_PER_TICK} generations per tick, only for sessions
+ * inside the display window, only for rows whose stored source key no longer
+ * matches their user text (so a titled session is a pure DB read forever after),
+ * and never for the titler's own spawned sessions. When the harness is missing
+ * or signed out every attempt fails, so the service backs off exponentially
+ * instead of respawning two processes a minute forever — the rows simply keep
+ * showing the user's own words, which is the honest fallback.
+ */
+import type { DaemonServiceId } from '../daemon-services.js';
+import { type SessionTitleRunner } from '../session/title.js';
+import { BasePeriodicService, type DaemonContext } from './service.js';
+export declare class SessionTitleService extends BasePeriodicService {
+    private readonly run?;
+    readonly id: DaemonServiceId;
+    readonly intervalMs: number;
+    readonly deadlineMs = 110000;
+    /** Let the box settle (shims, PATH, index warm) before spawning a harness. */
+    readonly startupDelayMs = 60000;
+    /** Ticks still to skip before the next attempt; 0 = attempt this tick. */
+    private skipTicks;
+    /** Skip count applied after the next all-failed sweep. */
+    private backoff;
+    /** `run` is the model-call seam (defaults to the real subprocess); tests inject one. */
+    constructor(run?: SessionTitleRunner | undefined);
+    protected onStart(_ctx: DaemonContext): Promise<void>;
+    protected onStop(): Promise<void>;
+    protected onTick(ctx: DaemonContext, signal: AbortSignal): Promise<void>;
+}

package/dist/lib/daemon/session-title-service.js

@@ -0,0 +1,76 @@
+/**
+ * Session-title service (PHNX-3797) — the ONE generator of session headlines.
+ *
+ * Every session row's headline used to be the agent's latest transcript line.
+ * This service replaces it with a user-anchored NAME: it sweeps the local
+ * session index for recent sessions whose title is still the raw first user
+ * message, asks a {@link SessionTitleProvider} (the cloud cheap-model call by
+ * default) for a short action+object headline, and persists it
+ * (`lib/session/title.ts`). Because the value lands in the index, every consumer
+ * — the CLI list, the picker, `sessions watch --json`, the fleet mirror, AGI EXT
+ * — reads one title that was generated exactly once.
+ *
+ * Cost is bounded by construction, not by hope: at most
+ * {@link SESSION_TITLE_MAX_PER_TICK} generations per tick, only for sessions
+ * inside the display window, only for rows whose stored source key no longer
+ * matches their user text (so a titled session is a pure DB read forever after),
+ * and never for the titler's own spawned sessions. When the harness is missing
+ * or signed out every attempt fails, so the service backs off exponentially
+ * instead of respawning two processes a minute forever — the rows simply keep
+ * showing the user's own words, which is the honest fallback.
+ */
+import { runSessionTitleTick, SESSION_TITLE_MAX_PER_TICK } from '../session/title.js';
+import { BasePeriodicService } from './service.js';
+/** Cadence of the sweep. Slow on purpose: a title is not a live signal. */
+const SESSION_TITLE_TICK_MS = 2 * 60_000;
+/** Above the worst case (limit x the per-generation subprocess timeout), below the interval. */
+const SESSION_TITLE_DEADLINE_MS = 110_000;
+/** Ticks skipped after the first all-failed sweep, doubling up to the ceiling. */
+const SESSION_TITLE_BACKOFF_START = 2;
+/** ~1h at the tick cadence — long enough that a signed-out box stays quiet. */
+const SESSION_TITLE_BACKOFF_MAX = 30;
+export class SessionTitleService extends BasePeriodicService {
+    run;
+    id = 'session-title';
+    intervalMs = SESSION_TITLE_TICK_MS;
+    deadlineMs = SESSION_TITLE_DEADLINE_MS;
+    /** Let the box settle (shims, PATH, index warm) before spawning a harness. */
+    startupDelayMs = 60_000;
+    /** Ticks still to skip before the next attempt; 0 = attempt this tick. */
+    skipTicks = 0;
+    /** Skip count applied after the next all-failed sweep. */
+    backoff = 0;
+    /** `run` is the model-call seam (defaults to the real subprocess); tests inject one. */
+    constructor(run) {
+        super();
+        this.run = run;
+    }
+    async onStart(_ctx) { }
+    async onStop() { }
+    async onTick(ctx, signal) {
+        if (this.skipTicks > 0) {
+            this.skipTicks--;
+            return;
+        }
+        const result = await runSessionTitleTick({
+            limit: SESSION_TITLE_MAX_PER_TICK,
+            signal,
+            ...(this.run ? { run: this.run } : {}),
+        });
+        if (result.generated > 0) {
+            // A success clears the backoff: whatever was broken is working again.
+            this.backoff = 0;
+            ctx.log('INFO', `session-title: generated ${result.generated} title(s) (${result.cached} already current)`);
+            return;
+        }
+        if (result.failed > 0) {
+            this.backoff = this.backoff === 0
+                ? SESSION_TITLE_BACKOFF_START
+                : Math.min(this.backoff * 2, SESSION_TITLE_BACKOFF_MAX);
+            this.skipTicks = this.backoff;
+            ctx.log('WARN', `session-title: ${result.failed} generation(s) produced no title; backing off ${this.backoff} tick(s)`);
+        }
+        // Nothing generated and nothing failed = every recent session is titled.
+        // That is the steady state, and it logs nothing.
+    }
+}

package/dist/lib/daemon/usage-sync-service.d.ts

@@ -32,13 +32,21 @@ import type { DaemonServiceId } from '../daemon-services.js';
  * freshness gate is the CONSUMER of this producer's cadence: it skips the
  * pushes when the last exchange is older than one usage-sync interval, so it
  * must track this constant rather than its own equal-by-coincidence literal.
+ * Sourced from `usage-sync.ts`'s `USAGE_SYNC_INTERVAL_MS` rather than a
+ * second literal, so the two files can't drift out of sync with each other.
  */
 export declare const USAGE_SYNC_TICK_MS: number;
+/**
+ * Offset from auth-sync's 60s kickoff so the two never contend for the
+ * shared-repo lock. Auth fires at T+1m, T+16m, …; usage at T+8m, T+23m, …
+ * The git exchange deadline is 45s, so a 7-minute gap is the whole point.
+ */
+export declare const USAGE_SYNC_KICKOFF_MS: number;
 export declare class UsageSyncService extends BasePeriodicService {
     readonly id: DaemonServiceId;
     readonly intervalMs: number;
     readonly deadlineMs: number;
-    readonly startupDelayMs = 90000;
+    readonly startupDelayMs: number;
     protected onStart(_ctx: DaemonContext): Promise<void>;
     protected onStop(): Promise<void>;
     protected onTick(ctx: DaemonContext): Promise<void>;

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

@@ -26,15 +26,23 @@
  * deadline and circuit breaker.
  */
 import { BasePeriodicService } from './service.js';
+import { USAGE_SYNC_INTERVAL_MS } from '../accounting/usage-sync.js';
 /**
  * The usage-sync tick cadence. Exported because auth-sync's credential-push
  * freshness gate is the CONSUMER of this producer's cadence: it skips the
  * pushes when the last exchange is older than one usage-sync interval, so it
  * must track this constant rather than its own equal-by-coincidence literal.
+ * Sourced from `usage-sync.ts`'s `USAGE_SYNC_INTERVAL_MS` rather than a
+ * second literal, so the two files can't drift out of sync with each other.
  */
-export const USAGE_SYNC_TICK_MS = 15 * 60_000;
+export const USAGE_SYNC_TICK_MS = USAGE_SYNC_INTERVAL_MS;
 const USAGE_SYNC_DEADLINE_MS = 2 * 60_000;
-const USAGE_SYNC_KICKOFF_MS = 90_000;
+/**
+ * Offset from auth-sync's 60s kickoff so the two never contend for the
+ * shared-repo lock. Auth fires at T+1m, T+16m, …; usage at T+8m, T+23m, …
+ * The git exchange deadline is 45s, so a 7-minute gap is the whole point.
+ */
+export const USAGE_SYNC_KICKOFF_MS = 8 * 60_000;
 export class UsageSyncService extends BasePeriodicService {
     id = 'usage-sync';
     intervalMs = USAGE_SYNC_TICK_MS;

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

@@ -7,7 +7,7 @@
  * enabled without pulling in the whole daemon lifecycle.
  */
 /** Every service the daemon can host. IDs are kebab-case and stable. */
-export type DaemonServiceId = 'scheduler' | 'catchup' | 'monitors' | 'browser-ipc' | 'webhook-receiver' | 'self-heal' | 'self-update' | 'account-state' | 'account-auth' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'browser-task-reap' | 'session-state' | 'session-summarizer' | 'attention-notify' | 'harness-update';
+export type DaemonServiceId = 'scheduler' | 'catchup' | 'monitors' | 'browser-ipc' | 'webhook-receiver' | 'self-heal' | 'self-update' | 'account-state' | 'account-auth' | 'watchdog' | 'device-probe' | 'state-dir-check' | 'session-index' | 'session-title' | 'auth-sync' | 'usage-sync' | 'daemon-heartbeat' | 'tmux-reap' | 'browser-task-reap' | 'session-state' | 'session-summarizer' | 'attention-notify' | 'harness-update';
 /** Human-readable metadata for each service. */
 export interface DaemonServiceDef {
     id: DaemonServiceId;

package/dist/lib/daemon-services.js

@@ -107,6 +107,11 @@ export const DAEMON_SERVICES = [
         title: 'Attention desktop banners',
         description: 'Posts one actionable desktop banner per new attention item (question / permission / plan review / stall) so the macOS helper can answer it through agents feed answer (PHNX-4004).',
     },
+    {
+        id: 'session-title',
+        title: 'Session titles',
+        description: 'Generates the short technical title shown as each session row\'s headline, once per session, with a cheap model — so a row is named by what the user asked for, never by the agent\'s latest message.',
+    },
     {
         id: 'auth-sync',
         title: 'Auth bundle sync',

package/dist/lib/daemon-ticks.js

@@ -145,6 +145,7 @@ 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');
+    const { machineId } = await import('./machine-id.js');
     const r = await runUsageRefresh({
         listAccounts: buildLocalUsageAccounts,
         writeUsageCache: writeClaudeUsageCache,
@@ -156,6 +157,11 @@ export async function runUsageRefreshTick(signal) {
         // 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,
+        pollerDevice: machineId(),
+        onSnapshotsChanged: async () => {
+            const { pushUsageSnapshotNow } = await import('./accounting/usage-sync.js');
+            await pushUsageSnapshotNow();
+        },
     });
     const { listProfiles } = await import('./profiles.js');
     const { refreshDueByokUsage } = await import('./byok-usage.js');

package/dist/lib/devices/doctor-findings.d.ts

@@ -1,6 +1,7 @@
 import type { AgentId } from '../types.js';
 import type { DuplicateVersionHook } from '../hooks/install.js';
 import type { AgentsBinaryShadow } from '../binary-shadow.js';
+import type { LeakedDaemon } from '../daemon/leaked-daemons.js';
 import type { RcSecretFinding } from '../secrets-types.js';
 import type { OwnerSinkStatus } from '../channels/owner-sink.js';
 import { type WindowsSshEnrollmentAudit } from './windows-ssh-enrollment.js';
@@ -13,7 +14,7 @@ export type FindingSeverity = 'critical' | 'warning';
  *  the JSON consumer group by kind. */
 /** Every finding class. Severity is NOT annotated here — {@link FINDING_SEVERITY}
  *  below owns it, and a second copy in these comments is a fourth place to drift. */
-export declare const ALL_FINDING_KINDS: readonly ["logged-out", "logout-unprovable", "missing-hook", "missing-plugin", "unwired-hook", "hook-runtime-broken", "hook-runtime-visibility-unavailable", "cli-missing", "missing-resource", "content-drift", "never-synced", "stale", "repo-behind", "repo-drift", "fleet-resource-gap", "host-cli-missing", "host-cli-invalid", "version-skew", "orphan", "duplicate-hook", "duplicate-hook-drift", "rc-secret-export", "env-secret-export", "auth-bundle-wrong-backend", "exec-policy", "ssh-key-enrollment", "stale-cli", "binary-shadow", "owner-sink-unreachable"];
+export declare const ALL_FINDING_KINDS: readonly ["logged-out", "logout-unprovable", "missing-hook", "missing-plugin", "unwired-hook", "hook-runtime-broken", "hook-runtime-visibility-unavailable", "cli-missing", "missing-resource", "content-drift", "never-synced", "stale", "repo-behind", "repo-drift", "fleet-resource-gap", "host-cli-missing", "host-cli-invalid", "version-skew", "orphan", "duplicate-hook", "duplicate-hook-drift", "rc-secret-export", "env-secret-export", "auth-bundle-wrong-backend", "exec-policy", "ssh-key-enrollment", "stale-cli", "binary-shadow", "owner-sink-unreachable", "leaked-daemon"];
 /**
  * The severity each kind is emitted with - the SINGLE source of truth, read by
  * the builders below and asserted against both prose rubrics by
@@ -124,6 +125,11 @@ export interface LocalFindingInputs {
     ownerSink?: OwnerSinkStatus;
     /** `agents` binaries that shadow the currently running CLI (RUSH-2431). */
     binaryShadows?: AgentsBinaryShadow[];
+    /** `__daemon-run` processes no owner record names — neither the service
+     *  manager's unit main PID nor the recorded daemon.pid (W4, PHNX-3736).
+     *  Collected by `findLeakedDaemons` in the command (it runs `ps` and reads
+     *  /proc, so it stays out of this pure module). */
+    leakedDaemons?: LeakedDaemon[];
 }
 /**
  * Fold this machine's signals into findings. Missing hooks/plugins and unwired