@phnx-labs/agents-cli 1.22.107 → 1.22.110

package/CHANGELOG.md

@@ -1,5 +1,101 @@
 # Changelog
 
+## 1.22.110
+
+- **Session rows are named by what YOU asked for, not by the agent's latest
+  message (PHNX-3797).** Every headline in `agents sessions`, the picker, and the
+  AGI EXT Sessions/Fleet list used to be the agent's last transcript line
+  ("Both seams verified on the real shipped artifacts…") — verbose, rolling, and
+  unrecognizable. The headline ladder is now `/rename` label → a
+  daemon-generated title → your own first message; the agent's live line stays in
+  the separate preview slot where a rolling status belongs. The new
+  `session-title` daemon service generates a short, descriptive **action + object
+  headline** ("Triage the AGI board", not just "Triage") with a cheap model
+  through a swappable `SessionTitleProvider` (cloud default; a local ollama-style
+  backend can be dropped in later without touching the tick), read-only plan mode,
+  **once** per session and
+  persists it in the session index against a hash of the message it came from, so
+  a titled session costs no further model calls and only re-titles when that first
+  message changes. Nothing generates per client or per tick: the value rides the
+  existing `sessions watch --json` stream and the fleet session mirror, so a
+  remote box's rows show the same title with no per-row SSH. Until the titler
+  reaches a session it shows your own words — never an agent line.
+  `agents sessions backfill titles [--session <id>] [--refresh]` runs it on
+  demand; `agents daemon services` can turn the service off.
+- **Session rows carry a ranked secondary line (PHNX-3797).** Beside the bold
+  headline, every live row now folds on `importantMessage` — the single most
+  important recent agent message, ranked so a pending **question** or a
+  **needs-you** block (plan review, permission, input-required) beats generic
+  current activity. It rides the same `sessions watch --json` / mirror feed as the
+  title (via the row spread), so AGI EXT renders a bold title over a dim secondary
+  line with no extra query; `agents sessions --active` prints the question /
+  needs-you line dim beneath the row.
+  Source: `src/lib/session/title.ts`, `src/lib/daemon/session-title-service.ts`,
+  `src/lib/session/active.ts`, `src/lib/session/db.ts`, `src/lib/session/mirror.ts`,
+  `src/commands/sessions.ts`, `src/commands/sessions-backfill.ts`.
+
+- Codex account sessions record their originating account after hook sync, including macOS homes relocated for Unix socket limits. Registration refreshes trust for the runtime home and removes the obsolete builtin tracker that could overwrite account metadata; unrelated hooks and explicit disabled states are preserved.
+
+- **Session resume preserves device and picker filters (PHNX-3940).** `sessions resume --device <host> <id>` and the equivalent device-after-ID form now open on the selected origin device. Agent, account, directory, time, and limit filters reach the shared picker; an unspecified limit remains 200. Repeated different devices produce an error.
+
+- **Usage snapshots stay fresh enough for balanced to auto-pick (PHNX-3940 W3).** A headed box polls only the accounts it holds native logins for; a setup-token-only worker never hits the usage endpoint. A changed snapshot is published immediately (statusline ingest or poll) instead of waiting for the 15-minute tick. `isUsageVerified` trusts a row that arrived via sync from the account's poller for that 15-minute cadence, and keeps the 5-minute bar for a local capture. `auth-sync` and `usage-sync` take the shared-repo lock on different offsets so they no longer starve each other. Source: `cli/src/lib/usage-refresh.ts`, `cli/src/lib/accounting/rotate.ts`, `cli/src/lib/accounting/usage-sync.ts`.
+
+## 1.22.109
+
+- **`agents sessions backup-setup` provisions the managed session-backup endpoint (PHNX-3726).** The operator command that deploys `sessions.agents-cli.sh` — the Cloudflare Worker + R2 bucket a signed-in user's `agents sessions export --to-r2` backs up to with no `r2.backups` bucket of their own. Mirrors `agents traces setup`: reads Cloudflare credentials from the `cloudflare` secrets bundle (`agents secrets exec cloudflare -- agents sessions backup-setup`), idempotent (re-running redeploys the current Worker template in place). It is NOT a per-user step — signing in with `agents auth login` is all a user does; this is how the first-party endpoint itself is deployed. The Worker it deploys is Phoenix-only with no static token (PHNX-3726). Source: `cli/src/commands/sessions-backup-setup.ts`, `cli/src/lib/session/sync/provision.ts` (+ `provision.test.ts`), `cli/docs/sessions.md`.
+
+- **`agents doctor` flags a leaked daemon no owner record names (W4, PHNX-3736).**
+  A headless e2e session launched `agents __daemon-run` under
+  `HOME=/tmp/pin-e2e-<pid>` and never stopped it; the daemon ran 4+ days,
+  invisible to the pid-file takeover because it keeps its own pid file under the
+  temp home. `agents doctor` now reports any same-uid `__daemon-run` whose pid is
+  neither the service manager's unit main PID nor the recorded `daemon.pid` —
+  checked against both the caller's HOME and the real account home, so a
+  test-harness caller never accuses the production daemon — as a `leaked-daemon`
+  warning carrying the process's HOME and start time, with a `kill <pid>`
+  remediation. Source: `cli/src/lib/daemon/leaked-daemons.ts`,
+  `cli/src/lib/devices/doctor-findings.ts`.
+
+- **`agents daemon start` refuses under a redirected HOME unless
+  `AGENTS_ALLOW_TEST_DAEMON=1` (W4, PHNX-3736).** RUSH-3021 gated auto-start from
+  a sandbox/test HOME but left the explicit `startDaemon()` open — the path the
+  e2e harness took to leak the `/tmp/pin-e2e-<pid>` daemon. The launch now throws
+  `RedirectedHomeDaemonError` (printed without a stack, exit 1); a deliberate
+  test/e2e launch opts in with `AGENTS_ALLOW_TEST_DAEMON=1` and owns stopping
+  what it starts. Reporting an already-running daemon — and therefore
+  `agents daemon stop` of a leaked one — is not gated. Auto-start side effects
+  (`routines add`, webhook fires, `monitors add`) state the refusal and leave
+  the foreground command green, the same tier split as the auto-start circuit
+  breaker; only the explicit start commands fail loud. Source:
+  `cli/src/lib/daemon/daemon.ts` (`startDaemon`).
+
+- **The managed share Worker now proxies same-origin human collaboration to Prix (PHNX-3835).** The Cloudflare Worker that fronts a managed share gains a `/__collab/*` transport so authorized humans can review a hosted artifact together (comments now; agent mentions/wake-up later). It stays the trust boundary exactly as the page GET does: every `/__collab` request loads the R2 object FIRST (a missing/just-deleted share 404s, so existence is never enumerable), re-derives the share id (`SHA-256(ownerId + NUL + normalized path)`), current revision (etag), owner, visibility, org domain, and producer provenance SERVER-SIDE from R2 metadata — the browser-supplied `share` is a lookup key only, never trusted as identity — then reuses the EXACT page read gate (me/org identity gate + private viewer-token gate) with every denial normalized to 404. Public/unlisted readers may read anonymously; every write additionally requires a verified signed-in Phoenix human; private still requires its share token. It proxies to the Prix `/v1/artifact-collaboration` routes (`context`, `threads` list/create, thread replies, comment/thread PATCH, SSE `events`, and a best-effort authenticated `purge` on share delete) with the service token in `Authorization` (never surfaced to the browser) plus trusted `X-Artifact-*` / `X-Phoenix-Actor-*` headers, preserves the client `Idempotency-Key` and `Last-Event-ID`, streams SSE through unbuffered (cancel/disconnect propagated), and marks every collaboration response `no-store`. A visibility downgrade is immediate (re-gated per request) and a deleted share drops its comments the instant the object is gone. The whole surface fails closed (404) when `PRIX_ARTIFACT_COLLAB_BASE` / `ARTIFACT_COLLAB_SERVICE_TOKEN` are absent — so BYO endpoints (no Phoenix identity) never expose it and the artifact page GET is unaffected — and stays dormant until an operator sets both secrets, which `agents artifacts share update`/`setup` now apply on a managed deploy (both or neither). Because the Worker template changed, already-deployed managed endpoints read `outdated` until re-run through `agents artifacts share update`. Source: `cli/src/lib/share/worker-template.ts`, `cli/src/lib/share/provision.ts`, `cli/src/lib/share/backend.ts`, `cli/src/commands/share.ts`, `cli/docs/share.md`.
+
+- **`agents sync --dry-run` no longer mutates every native home (PHNX-3923).** The umbrella verb (bare `agents sync`, including `--local`/`--yes`/`--json`) ignored `--dry-run` entirely: it ran the full reconcile, evicted central browser profiles, verified, and repaired — mutating every installed version home despite the preview flag. The umbrella composes only mutating stages (repo `git pull`, `refresh()` reconcile, device sync, `repairAfterSync`) with no non-mutating preview, so it now refuses `--dry-run` LOUD and up front — before any change — and points at the scoped path (`agents sync <agent> --dry-run`), which honors it non-destructively. `--json` reports `{ ok: false, mode: 'umbrella', dryRun: true, error, hint, installedAgents }`. Source: `cli/src/commands/sync.ts`.
+
+- Terminal session resumes preserve follow-up prompts, including spaces and shell characters. Remote terminals use the origin directory or explicit `--cwd`; run pickers retain `--remote-cwd` precedence, and home-relative paths expand on the target. An invalid remote directory or failed terminal launch reports failure.
+
+- Publishes the session-resume fixes from the unshipped 1.22.108 candidate: account homes refresh their session tracker, Codex hook trust follows registration, empty local picks are skipped, and remote picks are validated on their origin device. The 1.22.108 tag is preserved; npm publication resumes with this patch after correcting its release notes.
+
+- **`agents view` shows OpenCode's real model, account, plan, and last-active (PHNX-3982).** The OpenCode row was the only one in the table with nothing usable in it — `1.18.15 (default)  default  id:meta+openai+opencode-go` — while every other harness showed a model, an email, and a plan. Three separate reads were pointed at the wrong place. (1) The model came from `<home>/.opencode/settings.json`, which is agents-cli's own plugin-enablement file; OpenCode reads `~/.config/opencode/opencode.{jsonc,json}`, and ships no catalog default, so the row fell through to the literal placeholder `default`. Both spellings are now read comment-tolerantly, and when nothing is configured the row shows the model OpenCode itself will start with, from the selection it persists to `$XDG_STATE_HOME/opencode/model.json`. (2) The account showed only the provider join because the code asserted OpenCode's `auth.json` carries no identity — it does, for `type: 'oauth'` providers, in the same namespaced JWT claims `case 'codex'` already decodes, so the email and plan now render (secrets are never read out, only claims). (3) `lastActive` was blank because the per-file session walk finds nothing for a harness that keeps every session in one sqlite file; it now dates from `opencode.db`. Live usage *windows* remain unavailable for OpenCode — it records no rate-limit state locally and each provider would need its own reader. Source: `cli/src/lib/agent-spec/agents.ts`, `cli/src/lib/models.ts`.
+
+- **Codex trace error rates now reflect failed tool calls (PHNX-3761).** The tool-call index recognizes Codex's script completion and failure markers, preserves text across input blocks, and re-indexes older rows instead of reporting failed calls as unknown.
+
+- **`agents sessions --cloud <id>` and `agents cloud view` open OpenCode cloud transcripts (PHNX-3845).** Cloud discovery and fetch accept OpenCode sessions, and normalized cloud transcripts are parsed separately from local SQLite sessions. Both `bash` and `shell` tool names appear as command events.
+
+## 1.22.108
+
+- Account sync now refreshes the native session-tracking hook in every account home, replacing stale registrations from previous CLI installations so new sessions retain their account identity. Codex tracker installation also refreshes hook trust so headless runs can execute the registered hook.
+
+- Resume selection validates peer-owned transcripts on their origin device instead of treating a missing local copy as a missing session. Local empty picks are still skipped; explicit local replay still requires readable local content.
+
+- **The resume picker skips a local session with no transcript before opening a
+  tab (PHNX-4080).** Empty local selections are reported as skipped, and a batch
+  with nothing left to resume exits 1. Peer-owned sessions and mirror entries are
+  validated on their origin device. Explicit local replay still requires readable
+  local content; the executing device refuses recovery when no transcript exists.
+  Source: `src/commands/sessions-resume.ts`, `src/lib/session/recovery.ts`.
+
 ## 1.22.107
 
 - **A bare interactive run places itself like `--device auto` (PHNX-4083).**

package/dist/bootstrap.js

@@ -19,7 +19,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { detectDevBuild } from './lib/startup/dev-build.js';
-import { configureRootCommand } from './lib/startup/root-command.js';
+import { configureRootCommand, normalizeResumeDeviceArgs } from './lib/startup/root-command.js';
 import { bootMark } from './lib/boot-profile.js';
 // `ora`, `@inquirer/prompts`, `./commands/utils.js`, and the agents/versions/shims
 // modules are imported dynamically at their use sites: they are needed only on
@@ -877,7 +877,8 @@ program.on('command:*', (operands) => {
 // Parse the invocation shape up front: the first non-flag token is the command,
 // and the doc flags (--version/--help/-h) drive both the registration strategy
 // and whether the update check + background sync run at all.
-const passedArgs = process.argv.slice(2);
+const passedArgs = normalizeResumeDeviceArgs(process.argv.slice(2));
+process.argv.splice(2, process.argv.length - 2, ...passedArgs);
 // Commander owns `--version` on the root command and otherwise intercepts it
 // even after `sessions`, before the subcommand can parse its version filter.
 // Rewrite only that value-taking nested form; bare `agents --version` and every

package/dist/commands/browser-sessions-picker.js

@@ -18,6 +18,7 @@ import { buildPreview } from './sessions-picker.js';
 import { createSessionsPickerCommand } from './sessions-picker-factory.js';
 import { runBrowserSessions, buildBrowserSessionRows, matchesBrowserSessionRow, formatBytes, } from '../lib/browser/sessions-list.js';
 import { formatRelativeTime } from '../lib/session/relative-time.js';
+import { sessionHeadline } from '../lib/session/title.js';
 const KIND_LABEL = {
     screenshot: 'shots',
     pdf: 'pdf',
@@ -37,7 +38,7 @@ function rowLinkSummary(row) {
         return '';
     if (row.linkStatus === 'linked' && row.linkedSession) {
         const s = row.linkedSession;
-        return chalk.cyan(s.agent) + ' — ' + (s.label || s.topic || s.shortId);
+        return chalk.cyan(s.agent) + ' — ' + (sessionHeadline(s) || s.shortId);
     }
     if (row.linkStatus === 'unresolved') {
         return chalk.yellow(`owner ${row.owner ?? 'unknown'} (session not indexed here)`);

package/dist/commands/computer-sessions-picker.js

@@ -21,10 +21,11 @@ import { buildPreview } from './sessions-picker.js';
 import { createSessionsPickerCommand } from './sessions-picker-factory.js';
 import { runComputerSessions, printComputerSessionRows, buildComputerSessionRows, matchesComputerSessionRow, formatRowActions, } from '../lib/computer/sessions-list.js';
 import { formatRelativeTime } from '../lib/session/relative-time.js';
+import { sessionHeadline } from '../lib/session/title.js';
 function rowLinkSummary(row) {
     if (row.linkStatus === 'linked' && row.linkedSession) {
         const s = row.linkedSession;
-        return chalk.cyan(s.agent) + ' — ' + (s.label || s.topic || s.shortId);
+        return chalk.cyan(s.agent) + ' — ' + (sessionHeadline(s) || s.shortId);
     }
     if (row.linkStatus === 'unresolved') {
         return chalk.yellow(`owner ${row.agent ?? 'unknown'} (session not indexed here)`);

package/dist/commands/cost.js

@@ -5,6 +5,7 @@ import { queryUsageRollup, topSessionsByCost, } from '../lib/session/db.js';
 import { formatUsd, PRICING_VERSION } from '../lib/pricing/index.js';
 import { formatDuration } from '../lib/session/render.js';
 import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
+import { sessionHeadline } from '../lib/session/title.js';
 /** Register `agents insights cost` under the insights parent. */
 export function registerCostCommand(insightsCmd) {
     addHostOption(insightsCmd.command('cost'))
@@ -99,7 +100,7 @@ async function costAction(options) {
         for (const t of top) {
             const cost = formatUsd(t.costUsd).padStart(costW);
             const dur = t.durationMs > 0 ? formatDuration(t.durationMs) : '—';
-            const label = (t.meta.label || t.meta.topic || '(untitled)').replace(/\s+/g, ' ').trim();
+            const label = (sessionHeadline(t.meta) || '(untitled)').replace(/\s+/g, ' ').trim();
             const proj = showProject && t.meta.project ? chalk.gray(` ${t.meta.project}`) : '';
             const prefix = `  ${chalk.green(cost)}  ${chalk.gray(t.meta.shortId)}  ${chalk.cyan(t.meta.agent.padEnd(7))} `;
             const suffix = proj + chalk.gray(`  ${dur}`);

package/dist/commands/daemon.js

@@ -21,7 +21,8 @@ import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { setHelpSections } from '../lib/help.js';
-import { getDaemonStatus, isDaemonRunning, isDaemonWedged, readDaemonLog, startDaemon, stopDaemon, signalDaemonReload, findSurvivingStateDirDaemons, getDaemonLogPath, isDaemonAutostartCircuitOpen, } from '../lib/daemon/daemon.js';
+import { getDaemonStatus, isDaemonRunning, isDaemonWedged, readDaemonLog, startDaemon, stopDaemon, signalDaemonReload, findSurvivingStateDirDaemons, getDaemonLogPath, isDaemonAutostartCircuitOpen, RedirectedHomeDaemonError, } from '../lib/daemon/daemon.js';
+import { listDaemonRunProcesses } from '../lib/daemon/leaked-daemons.js';
 import { getConfigValue, setConfigValue, isDaemonEnabled } from '../lib/device-config.js';
 import { readSubsystemHealth, readAllSubsystemHealth, SUBSYSTEM_BROWSER_IPC, SUBSYSTEM_DAEMON_START, } from '../lib/daemon-health.js';
 import { DAEMON_SERVICE_IDS, listDaemonServiceStates, setDaemonServiceEnabled, getDaemonServicesConfigPath, queueDaemonServiceRestart, } from '../lib/daemon-services.js';
@@ -32,6 +33,27 @@ import { parseDuration } from '../lib/hooks/cache.js';
 import { registerFunnelCommand } from './funnel.js';
 import { DEFAULT_WEBHOOK_PORT, DEFAULT_WEBHOOK_RATE_LIMIT, addHostedReceiver, getDaemonWebhooksConfigPath, hostedReceiverPort, readDaemonWebhooksConfig, removeHostedReceiver, } from '../lib/daemon-webhooks.js';
 import { parseFunnelPort } from '../lib/funnel.js';
+// ─── Process scanning — which install owns the pid, and every duplicate ──────
+/**
+ * startDaemon for the explicit start/restart commands: the redirected-HOME
+ * refusal (W4, PHNX-3736) is user-actionable, not an engineering bug, so it
+ * prints without a stack and exits 1. Anything else (a genuinely unspawnable
+ * binary) still throws. Kept local to this command rather than in bootstrap's
+ * catch list — a bootstrap.ts edit selects the 54s non-interactive suite into
+ * the required impact gate, and this change's budget cannot carry it.
+ */
+function startDaemonClean() {
+    try {
+        return startDaemon();
+    }
+    catch (err) {
+        if (err instanceof RedirectedHomeDaemonError) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+        throw err;
+    }
+}
 /**
  * Provably absent, or null when unknowable.
  *
@@ -188,19 +210,14 @@ function entryFromTokens(tokens) {
     return tokens.length >= 2 ? tokens[tokens.length - 2] : null;
 }
 /**
- * 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.
+ * Every live `__daemon-run` process on this box, enriched with display
+ * metadata (entry/version/entryMissing). The raw `ps` scan and its
+ * last-token `__daemon-run` invariant live in
+ * `lib/daemon/leaked-daemons.ts` (`listDaemonRunProcesses`) — shared with the
+ * doctor's leaked-daemon detection so the two can never disagree on what a
+ * daemon process is.
  *
- * This raw box-wide scan is deliberately NOT the duplicate-detection scope
+ * This 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
@@ -209,35 +226,14 @@ function entryFromTokens(tokens) {
  * `findSurvivingStateDirDaemons` has already confirmed as real duplicates.
  */
 function scanDaemonProcesses() {
-    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 args = m[3].trim();
-        const tokens = args.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);
-        const uid = isNaN(uidParsed) ? null : uidParsed;
-        const entry = entryFromTokens(tokens);
-        const version = entry ? resolveVersionNear(entry, pid) : null;
+    for (const p of listDaemonRunProcesses()) {
+        const entry = entryFromTokens(p.tokens);
+        const version = entry ? resolveVersionNear(entry, p.pid) : null;
         // Asks whether the code is on disk for the NEXT launch -- what a restart and
         // every other reader will see -- not what this pid currently has mapped.
         const entryMissing = entry ? entryAbsent(entry) : false;
-        found.push({ pid, entry, version, entryMissing, uid });
+        found.push({ pid: p.pid, entry, version, entryMissing, uid: p.uid });
     }
     return found;
 }
@@ -905,6 +901,15 @@ export function registerDaemonCommand(program) {
       'agents daemon start' still starts it explicitly, same as
       'systemctl start' on a disabled unit.
 
+      Under a redirected HOME (a test/e2e harness), 'agents daemon start'
+      REFUSES to launch: a daemon started there keeps its own pid file under
+      the temp home and leaks, invisible to the real install (W4, PHNX-3736).
+      'daemon restart' inherits the same guard — it stops first, so run it
+      with the same opt-in. A deliberate test launch sets
+      AGENTS_ALLOW_TEST_DAEMON=1 — and the harness owns stopping what it
+      started. 'agents doctor' flags any leaked daemon that already exists,
+      with its HOME and start time.
+
       'agents daemon services enable|disable|restart <id>' applies live (no
       daemon restart) for supervisor-managed services that were registered at
       boot. browser-ipc is also registered while disabled, specifically so a
@@ -924,7 +929,7 @@ export function registerDaemonCommand(program) {
     cmd.command('start')
         .description('Start the daemon. Bypasses daemon.enabled — this is the deliberate override.')
         .action(() => {
-        const result = startDaemon();
+        const result = startDaemonClean();
         if (result.method === 'already-running') {
             console.log(chalk.yellow(`Daemon already running (PID: ${result.pid})`));
         }
@@ -977,7 +982,7 @@ export function registerDaemonCommand(program) {
             for (const s of stop.surviving)
                 console.log(chalk.red(`  surviving: ${s}`));
         }
-        const result = startDaemon();
+        const result = startDaemonClean();
         if (result.pid)
             console.log(chalk.green(`Daemon started (PID: ${result.pid}, ${result.method})`));
         else

package/dist/commands/doctor.js

@@ -16,6 +16,7 @@ import { hostIdentityArgs, sshTargetFor } from '../lib/hosts/types.js';
 import { deviceIdentityArgs } from '../lib/devices/connect.js';
 import { machineId, normalizeHost } from '../lib/session/sync/config.js';
 import { findAmbiguousDevicePins } from '../lib/scheduling/routines.js';
+import { findLeakedDaemons } from '../lib/daemon/leaked-daemons.js';
 import chalk from 'chalk';
 import { checkAllClis, collectTeamsDoctorData } from '../lib/teams/agents.js';
 import { AGENTS, ALL_AGENT_IDS, resolveAgentName, formatAgentError, getAccountInfo } from '../lib/agents.js';
@@ -478,6 +479,10 @@ async function runDevicesDoctor(opts) {
                 // remote boxes self-report it in their own `agents doctor --json`.
                 ownerSink: await probeOwnerSink(readMeta()),
                 binaryShadows: detectAgentsBinaryShadows(),
+                // A `__daemon-run` no unit main PID or daemon.pid owns (W4, PHNX-3736) —
+                // the /tmp/pin-e2e leak class the registry-scoped duplicate check cannot
+                // see. Local only: a remote box self-reports in its own doctor.
+                leakedDaemons: findLeakedDaemons(),
             }));
             accounts[localName] = r.inventory?.signIn ?? {};
             continue;
@@ -1478,6 +1483,8 @@ export function registerDoctorCommand(program) {
                 // Can the owner-delivery lane (feed/notify) escalate a block from this
                 // box? A factory that cannot escalate is not healthy (RUSH-2262).
                 ownerSink: await probeOwnerSink(readMeta()),
+                // A `__daemon-run` no unit main PID or daemon.pid owns (W4, PHNX-3736).
+                leakedDaemons: findLeakedDaemons(),
             });
             if (opts.json) {
                 const overviewPayload = {

package/dist/commands/exec.js

@@ -986,6 +986,8 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 throw new Error('--resume cannot be combined with --session-id, --loop, --fallback, --resume-checkpoint, or --lease.');
             }
             const { sessionsResumeAction } = await import('./sessions-resume.js');
+            const { toRemotePortable } = await import('../lib/project-root.js');
+            const device = options.host || options.device || options.on || options.computer;
             await sessionsResumeAction(undefined, prompt, {
                 agent: normalizedAgentSpec.split('#')[0] === RUN_AUTO_KEYWORD ? undefined : normalizedAgentSpec.split('#')[0],
                 account: options.account,
@@ -993,9 +995,9 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 mode: command.getOptionValueSource('mode') === 'default' ? undefined : options.mode,
                 interactive: options.interactive,
                 headless: options.headless,
-                cwd: options.cwd,
+                cwd: device ? options.remoteCwd ?? (options.cwd ? toRemotePortable(options.cwd) : undefined) : options.cwd,
                 quiet: options.quiet,
-                device: options.host || options.device || options.on || options.computer,
+                device,
                 runArgs: rawArgs.slice(2),
             });
             return;

package/dist/commands/fork.js

@@ -97,10 +97,12 @@ export async function runFork(sessionArg, options, deps = defaultDeps()) {
         return;
     }
     const digest = data?.preview ?? undefined;
-    // Most sessions have no explicit --name label; fall back to the auto-derived
-    // topic the rest of the CLI shows, not the raw short id (forkLabelFor is the
-    // shared 3-tier resolver, and preview's --json now carries `topic`).
-    const label = forkLabelFor({ label: source.label, topic: source.topic, shortId: source.shortId });
+    // Most sessions have no explicit --name label; fall back to the shared headline
+    // ladder the rest of the CLI shows, not the raw short id. Pass `source` whole
+    // rather than re-listing fields: an object literal that omits `generatedTitle`
+    // still type-checks (the key is optional) and would silently drop the
+    // daemon-generated title rung — the PHNX-3797 bug shape.
+    const label = forkLabelFor(source);
     const recap = buildForkRecap({
         agent: source.agent,
         label,

package/dist/commands/logs.js

@@ -29,6 +29,7 @@ import { listTasks } from '../lib/hosts/tasks.js';
 import { itemPicker } from '../lib/picker.js';
 import { stats, getLogsPath, rotate, } from '../lib/feed/events.js';
 import { addEventsReadOptions, runEventsCommand } from './events.js';
+import { sessionHeadline } from '../lib/session/title.js';
 /** Compact one-line label used by both the picker and the non-TTY list. */
 function candidateLabel(c) {
     if (c.kind === 'task') {
@@ -40,7 +41,7 @@ function candidateLabel(c) {
     }
     const s = c.session;
     const ver = s.version ? chalk.gray(`@${s.version}`) : '';
-    const title = s.label || s.topic || '';
+    const title = sessionHeadline(s) || '';
     return `${chalk.gray('sess')} ${s.shortId.padEnd(9)} ${(s.agent + ver).padEnd(14)} ${chalk.gray(s.timestamp.slice(0, 16))}  ${title.slice(0, 40)}`;
 }
 /** Emit a host-dispatch task's log as JSON: `{ kind, task, log }`. */

package/dist/commands/monitors.js

@@ -12,7 +12,7 @@ import { withAliases } from '../lib/verbs.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
-import { isDaemonRunning, signalDaemonReload, startDaemon, } from '../lib/daemon/daemon.js';
+import { isDaemonRunning, signalDaemonReload, startDaemon, RedirectedHomeDaemonError, } from '../lib/daemon/daemon.js';
 import { findDuplicateMonitor, monitorFingerprint } from '../lib/monitors/fingerprint.js';
 import { gatherFleetMonitors, NO_MONITOR_FANOUT_ENV } from '../lib/monitors/remote.js';
 import { listMonitors, readMonitor, writeMonitor, deleteMonitor, setMonitorEnabled, getMonitorPath, validateMonitor, monitorRunsOnThisDevice, requiresSingleOwner, monitorSharedInputOwner, parseInterval, } from '../lib/monitors/config.js';
@@ -246,7 +246,20 @@ function ensureDaemonRunning() {
         stderrLine(chalk.gray('Daemon reloaded'));
         return true;
     }
-    const result = startDaemon();
+    let result;
+    try {
+        result = startDaemon();
+    }
+    catch (err) {
+        // The redirected-HOME refusal (W4) is an auto-start policy, not a failure
+        // of the monitor just added — state it and leave the foreground command
+        // green. Anything else (a genuinely unspawnable binary) still fails loud.
+        if (err instanceof RedirectedHomeDaemonError) {
+            stderrLine(chalk.yellow(err.message));
+            return true;
+        }
+        throw err;
+    }
     if (result.pid) {
         console.log(chalk.green(`Daemon started (PID: ${result.pid}). It will watch monitors in the background.`));
         console.log(chalk.gray('Disable only monitor polling with: agents daemon services disable monitors'));

package/dist/commands/routines.js

@@ -10,7 +10,7 @@ import ora from 'ora';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
-import { isDaemonRunning, signalDaemonReload, startDaemon, readDaemonLog, getDaemonStatus, getDaemonLogPath, } from '../lib/daemon/daemon.js';
+import { isDaemonRunning, signalDaemonReload, startDaemon, readDaemonLog, getDaemonStatus, getDaemonLogPath, RedirectedHomeDaemonError, } from '../lib/daemon/daemon.js';
 import { isDaemonServiceEnabled, setDaemonServiceEnabled } from '../lib/daemon-services.js';
 import { assertSchedulerEnabled, assertDaemonEnabled, isDaemonEnabled, isSchedulerEnabled, } from '../lib/device-config.js';
 import { parseAgentVersionSpec, isAgentHardDeprecated, hardDeprecationError, ROUTINE_AGENT_IDS } from '../lib/agents.js';
@@ -327,7 +327,22 @@ function ensureSchedulerRunning(opts = {}) {
         }
         return;
     }
-    const result = startDaemon();
+    let result;
+    try {
+        result = startDaemon();
+    }
+    catch (err) {
+        // The redirected-HOME refusal (W4) is an auto-start policy, not a failure
+        // of the routine just added — state it and leave the foreground command
+        // green, the same tier split as the auto-start circuit breaker. Anything
+        // else (a genuinely unspawnable binary) still fails loud.
+        if (err instanceof RedirectedHomeDaemonError) {
+            if (!opts.quiet)
+                log(chalk.yellow(err.message));
+            return;
+        }
+        throw err;
+    }
     if (opts.quiet)
         return;
     if (result.pid) {
@@ -1851,9 +1866,22 @@ export function registerRoutinesCommands(program) {
                 console.log(chalk.yellow(`Daemon is disabled (daemon.enabled=false) — run(s) below fire but are not monitored. Re-enable with: agents daemon enable`));
             }
             else {
-                const started = startDaemon();
-                if (started.pid) {
-                    console.log(chalk.gray(`Started scheduler (PID: ${started.pid}) so webhook runs are monitored.`));
+                try {
+                    const started = startDaemon();
+                    if (started.pid) {
+                        console.log(chalk.gray(`Started scheduler (PID: ${started.pid}) so webhook runs are monitored.`));
+                    }
+                }
+                catch (err) {
+                    // Same contract as the daemon.enabled=false branch above: a refused
+                    // auto-start (W4's redirected-HOME guard) never cancels the fire —
+                    // the runs below fire but are not monitored. Anything else rethrows.
+                    if (err instanceof RedirectedHomeDaemonError) {
+                        console.log(chalk.yellow(err.message));
+                    }
+                    else {
+                        throw err;
+                    }
                 }
             }
         }
@@ -2185,7 +2213,19 @@ export function registerRoutinesCommands(program) {
             process.exit(1);
         }
         setDaemonServiceEnabled('scheduler', true);
-        const result = startDaemon();
+        let result;
+        try {
+            result = startDaemon();
+        }
+        catch (err) {
+            // The redirected-HOME refusal (W4) is user-actionable — print it
+            // without a stack, same as the asserts above.
+            if (err instanceof RedirectedHomeDaemonError) {
+                console.error(chalk.red(err.message));
+                process.exit(1);
+            }
+            throw err;
+        }
         if (result.method === 'already-running') {
             // Signal a reload even here: if the daemon booted while this device had
             // scheduler.enabled=false, the reload re-evaluates the gate and boots

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

@@ -1,5 +1,6 @@
 import type { Command } from 'commander';
 import { type ToolIndexCoverage } from '../lib/session/tool-index.js';
+import { type SessionTitleRunner } from '../lib/session/title.js';
 export interface ToolBackfillMachineResult {
     machine: string;
     indexedFiles: number;
@@ -61,5 +62,34 @@ export interface ResourceBackfillEnvelope {
  * resource_scan_ledger so reruns skip completed transcripts.
  */
 export declare function runResourceBackfill(options: ResourceBackfillOptions): Promise<ResourceBackfillEnvelope>;
+interface TitleBackfillOptions {
+    session?: string;
+    limit?: string;
+    refresh?: boolean;
+    json?: boolean;
+    /** The injectable model call (`SessionTitleRunner`); not a CLI flag — tests pass it. */
+    run?: SessionTitleRunner;
+}
+export interface TitleBackfillEnvelope {
+    schemaVersion: 1;
+    kind: 'titles-backfill';
+    generatedAt: string;
+    machine: string;
+    scanned: number;
+    cached: number;
+    generated: number;
+    failed: number;
+    titles: Array<{
+        id: string;
+        title: string;
+    }>;
+}
+/**
+ * Generate session headlines NOW instead of waiting for the daemon's sweep — the
+ * explicit-refresh half of PHNX-3797. Same code path the `session-title` service
+ * ticks, so there is one generator: this only changes when it runs, how many it
+ * does, and (with `--refresh`) whether an already-current title is regenerated.
+ */
+export declare function runTitlesBackfill(options: TitleBackfillOptions): Promise<TitleBackfillEnvelope>;
 export declare function registerSessionsBackfillCommand(sessionsCmd: Command): void;
 export {};