@phnx-labs/agents-cli 1.22.112 → 1.22.114

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 1.22.114
+
+- **`agents projects prs <project>` — every open PR across a project's repos (PHNX-3999).** Reads the whole open PR board (drafts included, no author filter) straight from GitHub over REST, paginated, for the project's own attached repos only — unlike `projects status`, whose `openPrs` only carries PRs the fleet's sessions opened. `--repo <owner/repo>` restricts to one attached repo; `--repo … --number <n>` lazily enriches exactly that PR with its head-SHA checks and reviewDecision. A per-repo fetch failure is reported and marks the result partial, never relabeled as zero open PRs. Source: `cli/src/lib/github/project-prs.ts`, `cli/src/commands/projects.ts`.
+- **AGI Menu preferences are registered `agents config` keys (PHNX-3999).** Thirteen user-scope `menubar.menu.*` keys (defaultProject, workingRowsShown, showPreviews, projectPriorityFilter, hideCompletedMilestones, bannerWhenNeedsYou, includeOtherDeviceRequests, groupBy [none/project/agent/device], thenBy, projectScope, projectSort, ticketSort, showPullRequests) that get/set/unset/list through the existing `agents config` surface and sync fleet-wide via the central `agents.yaml`. `config list --json` emits `{key,value,hint}` and omits unset keys, so the menu falls back to its own defaults. `agents menubar snapshot --json` also carries a `menuPreferences` map (effective value per key, `defaultProject` omitted when unset) so the menu reads them from the snapshot it already polls, not a second mechanism; on macOS a one-shot, sentinel-gated migration lifts legacy `com.phnx-labs.agents-menubar` UserDefaults into config without overriding an already-set value. Source: `cli/src/lib/device-config.ts`, `cli/src/lib/config-keys.ts`, `cli/src/commands/config.ts`, `cli/src/lib/menubar/snapshot.ts`, `cli/src/lib/menubar/migrate-prefs.ts`.
+- **Devices carry a `formFactor` hardware fact (PHNX-3999).** A new shared device-scope config key (`laptop`/`desktop`/`server`/`unknown`) set explicitly per device — never inferred from the OS platform — surfaced in `agents menubar snapshot --json` so the menu can draw a factual hardware icon. Source: `cli/src/lib/device-config.ts`, `cli/src/lib/menubar/snapshot.ts`.
+- **A prose "needs-you" question is split into the ask and its context (PHNX-3999).** The session state engine used to flatten a whole trailing report into one line (`oneLine(content)`), losing the actual question and its Markdown. `extractProseQuestion` now separates the trailing ask (`StructuredQuestion.text` / `BlockQuestion.text`) from the preceding report (`context`, Markdown + newlines preserved), so an operator surface can lead with the question and show the report as context. It keeps multiple/multiline asks together, peels a same-paragraph lead-in into context, and never treats a `?` inside a code span, fenced block, or blockquote as the question. The freshness decay is unchanged. Source: `cli/src/lib/session/state.ts`, `cli/src/lib/feed/feed.ts`, `cli/src/lib/feed/attention.ts`.
+
+- Install AGI Menu 1.4.0 with Sessions device filters, in-place project details, synced preferences, native Quick Look, and question-first request cards.
+
+- **Codex custom agents keep their backslashes.** `agents subagents` wrote the
+  Codex TOML body inside `"""` and escaped only the closing quotes, so a
+  Windows path or a regex in an `AGENT.md` was mangled by TOML's backslash
+  escapes. Backslashes are now doubled first. Fixed alongside four other CodeQL
+  findings (terminal-escape scrubbing is a linear scan, prompt tag stripping is
+  a fixpoint, R2 key decoding is single-pass, and share-page asset inlining
+  treats any non-`file:` scheme as remote); none of those change behaviour on
+  ordinary input. Source: `cli/src/lib/subagents.ts`, `cli/src/lib/redact.ts`,
+  `cli/src/lib/session/prompt.ts`, `cli/src/lib/session/sync/r2.ts`,
+  `cli/src/lib/share/html.ts`.
+
+- **`agents computer --device` and `agents secrets --device` forward the standalone engines' own `--host` address (PHNX-4090).** `computer`, `secrets`, and `browser` are extracted CLIs with no fleet registry of their own (PHNX-4075, PHNX-3989); they share one address grammar (`ssh://[user@]host`, `vnc://host[:port]`, `tcp://host:port`, or a bare `user@host`/alias) via a copied `lib/address.ts`. A device's `computer.host` config (`agents config set devices.<name>.computer.host <address>`, next to `defaultBrowserProfile`) selects the transport — `vnc://`/`tcp://` for a non-Windows desktop, or `ssh://` still resolved against the fleet identity; with none set, `--device` falls back to the historical Windows-only ssh tunnel. `agents computer`'s `withDeviceFlag` is gone, replaced by `withHostFlag` + `resolveDeviceHost`; `agents secrets`'s passthrough gained `rewriteDeviceToHost`. An explicit `--host` on the command line always wins over `--device`; `agents view --device <name>` is unaffected — it still SSHes the whole command. Source: `src/lib/address.ts`, `src/commands/computer.ts`, `src/commands/secrets-passthrough.ts`, `src/lib/device-config.ts`, `src/lib/config-keys.ts`.
+
+- **Removed `agents pty`; use the standalone `term` CLI instead (PHNX-4091).** The
+  PTY engine (`agents pty`, its unix-socket sidecar, and the `sessions inject --pty`
+  target) moved to `@phnx-labs/term-cli` (`npm i -g @phnx-labs/term-cli`), published
+  separately with the same verbs, flags, and JSON shapes. The OAuth device-code
+  driver (`agents fleet login`, `agents auth mint`) now spawns the standalone
+  `term` binary instead of an in-repo pty sidecar. Source: `cli/src/lib/term-client.ts`.
+
+## 1.22.113
+
+- **Remote sessions have one execution-owned row (PHNX-3939).** Fleet session and feed streams reconcile launcher observations with the worker's state, retaining terminal/viewing metadata separately. Reconnects and stale history cannot replace a genuine worker row. Registry cleanup retains records whose PID namespace cannot be verified; nested agent runs keep launch lineage without claiming their parent's editor terminal.
+- **Codex forks retain their child identity.** Full and incremental scans keep the first native metadata record. Reindexing repairs cold files and removes a stale parent binding to child bytes even when the parent rollout is absent. Team descendants also keep their immediate parent lineage without inheriting its editor ownership.
+- **Nested daemon starts preserve shared session state.** Legacy migration and reboot recovery require the initial host namespace or kernel-verified live daemon ownership before touching singleton state. Foreign snapshots remain read-only, and invisible processes are never treated as dead. Automatic reuse of a private-container HOME across namespaces is unsupported, including after the prior namespace exits; writers fail safely with a diagnostic.
+
+- Repair session indexes whose schema version is current but whose identity columns are missing, preserving existing session metadata (PHNX-3940).
+
 ## 1.22.112
 
 - **Runs expand portable home paths on the executing device (PHNX-3940).** A remote resume terminal could open successfully while its child failed to start because `--cwd '$HOME'` was treated as a literal directory. The shared run path now expands `$HOME` and `~` locally, while preserving those anchors until remote dispatch reaches its target. This fixes direct runs and resumed conversations alike.

package/README.md

@@ -1544,21 +1544,20 @@ See the publication boundary in [observability](cli/docs/observability.md).
 
 ## PTY
 
-<p align="center">
-  <img src="assets/pty.svg" alt="agents pty: give an agent a real terminal for REPLs and TUIs; a sidecar server holds sessions alive between CLI calls." width="100%" />
-</p>
-
+Real pseudoterminals for REPLs, TUIs, and interactive programs moved to the
+standalone [`term` CLI](https://github.com/phnx-labs/term-cli)
+(`npm i -g @phnx-labs/term-cli`), published separately (PHNX-4091). Same
+verbs, flags, and JSON shapes `agents pty` used to have:
 
 ```bash
-# Give agents a real terminal for REPLs, TUIs, interactive programs.
-SID=$(agents pty start)
-agents pty exec $SID "python3"
-agents pty screen $SID                # Clean text, no ANSI -- what a human sees
-agents pty write $SID "print('hello')\n"
-agents pty stop $SID
+SID=$(term start)
+term exec $SID "python3"
+term screen $SID                # Clean text, no ANSI -- what a human sees
+term write $SID "print('hello')\n"
+term stop $SID
 ```
 
-A sidecar server holds sessions alive between CLI calls. `screen` renders via xterm-headless. Sessions auto-clean after 30 minutes idle.
+`term`'s own sidecar server holds sessions alive between CLI calls and renders `screen` via a headless terminal emulator; sessions auto-clean after 30 minutes idle. See [term-cli's README](https://github.com/phnx-labs/term-cli#readme) for the full command reference.
 
 ---
 

package/dist/cli/command-registry.d.ts

@@ -24,73 +24,13 @@ export { KNOWN_TOP_LEVEL_COMMANDS, RETIRED_TOP_LEVEL_COMMANDS } from '../lib/sta
 export type Registrar = (program: Command) => void;
 /** A thunk that dynamically imports a command module and returns its registrar. */
 export type ModuleLoader = () => Promise<Registrar>;
-export declare const loadView: ModuleLoader;
-export declare const loadInspect: ModuleLoader;
-export declare const loadFeedback: ModuleLoader;
-export declare const loadCommands: ModuleLoader;
-export declare const loadHooks: ModuleLoader;
-export declare const loadSkills: ModuleLoader;
-export declare const loadRules: ModuleLoader;
-export declare const loadMemory: ModuleLoader;
-export declare const loadPermissions: ModuleLoader;
-export declare const loadMcp: ModuleLoader;
-export declare const loadCli: ModuleLoader;
-export declare const loadSubagents: ModuleLoader;
-export declare const loadPlugins: ModuleLoader;
-export declare const loadWorkflows: ModuleLoader;
 export declare const loadVersions: ModuleLoader;
 export declare const loadUpdate: ModuleLoader;
-export declare const loadImport: ModuleLoader;
-export declare const loadPackages: ModuleLoader;
-export declare const loadRoutines: ModuleLoader;
-export declare const loadMonitors: ModuleLoader;
-export declare const loadProjects: ModuleLoader;
 export declare const loadRun: ModuleLoader;
-export declare const loadOpen: ModuleLoader;
-export declare const loadReconnect: ModuleLoader;
-export declare const loadFork: ModuleLoader;
-export declare const loadConfig: ModuleLoader;
-export declare const loadModels: ModuleLoader;
-export declare const loadModes: ModuleLoader;
 export declare const loadPrune: ModuleLoader;
-export declare const loadTrash: ModuleLoader;
-export declare const loadRestore: ModuleLoader;
 export declare const loadDoctor: ModuleLoader;
-export declare const loadRoute: ModuleLoader;
-export declare const loadHarness: ModuleLoader;
-export declare const loadSecrets: ModuleLoader;
-export declare const loadMenubar: ModuleLoader;
-export declare const loadSync: ModuleLoader;
-export declare const loadRefreshRules: ModuleLoader;
-export declare const loadFactory: ModuleLoader;
-export declare const loadInsights: ModuleLoader;
-export declare const loadTrace: ModuleLoader;
-export declare const loadPty: ModuleLoader;
-export declare const loadTmux: ModuleLoader;
-export declare const loadWatchdog: ModuleLoader;
-export declare const loadBrowser: ModuleLoader;
-export declare const loadComputer: ModuleLoader;
-export declare const loadLogs: ModuleLoader;
-export declare const loadEvents: ModuleLoader;
-export declare const loadSsh: ModuleLoader;
-export declare const loadRepo: ModuleLoader;
-export declare const loadSetup: ModuleLoader;
-export declare const loadUninstall: ModuleLoader;
-export declare const loadUpgrade: ModuleLoader;
 export declare const loadSessions: ModuleLoader;
 export declare const loadTeams: ModuleLoader;
-export declare const loadCloud: ModuleLoader;
-export declare const loadMessage: ModuleLoader;
-export declare const loadSend: ModuleLoader;
-export declare const loadFeed: ModuleLoader;
-export declare const loadMailboxes: ModuleLoader;
-export declare const loadArtifacts: ModuleLoader;
-export declare const loadWebhooks: ModuleLoader;
-export declare const loadHumans: ModuleLoader;
-export declare const loadAccounts: ModuleLoader;
-export declare const loadDaemon: ModuleLoader;
-export declare const loadAuth: ModuleLoader;
-export declare const loadTraces: ModuleLoader;
 export declare const loadReminders: ModuleLoader;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are

package/dist/cli/command-registry.js

@@ -26,78 +26,77 @@ export { KNOWN_TOP_LEVEL_COMMANDS, RETIRED_TOP_LEVEL_COMMANDS } from '../lib/sta
 // One loader per command module. Each dynamically imports the module and hands
 // back its register function. Kept as named consts so src/index.ts can compose
 // them into the exact main-branch registration order for the slow path.
-export const loadView = async () => (await import('../commands/view.js')).registerViewCommand;
-export const loadInspect = async () => (await import('../commands/inspect.js')).registerInspectCommand;
-export const loadFeedback = async () => (await import('../commands/feedback.js')).registerFeedbackCommand;
-export const loadCommands = async () => (await import('../commands/commands.js')).registerCommandsCommands;
-export const loadHooks = async () => (await import('../commands/hooks.js')).registerHooksCommands;
-export const loadSkills = async () => (await import('../commands/skills.js')).registerSkillsCommands;
-export const loadRules = async () => (await import('../commands/rules.js')).registerRulesCommands;
-export const loadMemory = async () => (await import('../commands/memory.js')).registerMemoryCommands;
-export const loadPermissions = async () => (await import('../commands/permissions.js')).registerPermissionsCommands;
-export const loadMcp = async () => (await import('../commands/mcp.js')).registerMcpCommands;
-export const loadCli = async () => (await import('../commands/cli.js')).registerCliCommands;
-export const loadSubagents = async () => (await import('../commands/subagents.js')).registerSubagentsCommands;
-export const loadPlugins = async () => (await import('../commands/plugins.js')).registerPluginsCommands;
-export const loadWorkflows = async () => (await import('../commands/workflows.js')).registerWorkflowsCommands;
+const loadView = async () => (await import('../commands/view.js')).registerViewCommand;
+const loadInspect = async () => (await import('../commands/inspect.js')).registerInspectCommand;
+const loadFeedback = async () => (await import('../commands/feedback.js')).registerFeedbackCommand;
+const loadCommands = async () => (await import('../commands/commands.js')).registerCommandsCommands;
+const loadHooks = async () => (await import('../commands/hooks.js')).registerHooksCommands;
+const loadSkills = async () => (await import('../commands/skills.js')).registerSkillsCommands;
+const loadRules = async () => (await import('../commands/rules.js')).registerRulesCommands;
+const loadMemory = async () => (await import('../commands/memory.js')).registerMemoryCommands;
+const loadPermissions = async () => (await import('../commands/permissions.js')).registerPermissionsCommands;
+const loadMcp = async () => (await import('../commands/mcp.js')).registerMcpCommands;
+const loadCli = async () => (await import('../commands/cli.js')).registerCliCommands;
+const loadSubagents = async () => (await import('../commands/subagents.js')).registerSubagentsCommands;
+const loadPlugins = async () => (await import('../commands/plugins.js')).registerPluginsCommands;
+const loadWorkflows = async () => (await import('../commands/workflows.js')).registerWorkflowsCommands;
 export const loadVersions = async () => (await import('../commands/versions.js')).registerVersionsCommands;
 export const loadUpdate = async () => (await import('../commands/update.js')).registerUpdateCommand;
-export const loadImport = async () => (await import('../commands/import.js')).registerImportCommand;
-export const loadPackages = async () => (await import('../commands/packages.js')).registerPackagesCommands;
-export const loadRoutines = async () => (await import('../commands/routines.js')).registerRoutinesCommands;
-export const loadMonitors = async () => (await import('../commands/monitors.js')).registerMonitorsCommands;
-export const loadProjects = async () => (await import('../commands/projects.js')).registerProjectsCommands;
+const loadImport = async () => (await import('../commands/import.js')).registerImportCommand;
+const loadPackages = async () => (await import('../commands/packages.js')).registerPackagesCommands;
+const loadRoutines = async () => (await import('../commands/routines.js')).registerRoutinesCommands;
+const loadMonitors = async () => (await import('../commands/monitors.js')).registerMonitorsCommands;
+const loadProjects = async () => (await import('../commands/projects.js')).registerProjectsCommands;
 export const loadRun = async () => (await import('../commands/exec.js')).registerRunCommand;
-export const loadOpen = async () => (await import('../commands/open.js')).registerOpenCommand;
-export const loadReconnect = async () => (await import('../commands/reconnect.js')).registerReconnectCommand;
-export const loadFork = async () => (await import('../commands/fork.js')).registerForkCommand;
-export const loadConfig = async () => (await import('../commands/config.js')).registerConfigCommand;
-export const loadModels = async () => (await import('../commands/models.js')).registerModelsCommand;
-export const loadModes = async () => (await import('../commands/modes.js')).registerModesCommand;
+const loadOpen = async () => (await import('../commands/open.js')).registerOpenCommand;
+const loadReconnect = async () => (await import('../commands/reconnect.js')).registerReconnectCommand;
+const loadFork = async () => (await import('../commands/fork.js')).registerForkCommand;
+const loadConfig = async () => (await import('../commands/config.js')).registerConfigCommand;
+const loadModels = async () => (await import('../commands/models.js')).registerModelsCommand;
+const loadModes = async () => (await import('../commands/modes.js')).registerModesCommand;
 export const loadPrune = async () => (await import('../commands/prune.js')).registerPruneCommand;
-export const loadTrash = async () => (await import('../commands/trash.js')).registerTrashCommands;
-export const loadRestore = async () => (await import('../commands/trash.js')).registerRestoreCommand;
+const loadTrash = async () => (await import('../commands/trash.js')).registerTrashCommands;
+const loadRestore = async () => (await import('../commands/trash.js')).registerRestoreCommand;
 export const loadDoctor = async () => (await import('../commands/doctor.js')).registerDoctorCommand;
-export const loadRoute = async () => (await import('../commands/route.js')).registerRouteCommands;
-export const loadHarness = async () => (await import('../commands/harness.js')).registerHarnessCommands;
+const loadRoute = async () => (await import('../commands/route.js')).registerRouteCommands;
+const loadHarness = async () => (await import('../commands/harness.js')).registerHarnessCommands;
 // PHNX-3989: `agents secrets` is a thin passthrough to the standalone
 // `secrets` CLI (secrets-passthrough.ts). The legacy in-repo engine and its
 // own command registrar are gone (Track D, tasks.md item 7) — the standalone
 // `@phnx-labs/secrets-cli` package is the only implementation.
-export const loadSecrets = async () => (await import('../commands/secrets-passthrough.js')).registerSecretsCommands;
-export const loadMenubar = async () => (await import('../commands/menubar.js')).registerMenubarCommands;
-export const loadSync = async () => (await import('../commands/sync.js')).registerSyncCommand;
-export const loadRefreshRules = async () => (await import('../commands/refresh-rules.js')).registerRefreshRulesCommand;
-export const loadFactory = async () => (await import('../commands/factory.js')).registerFactoryCommands;
-export const loadInsights = async () => (await import('../commands/insights.js')).registerInsightsCommand;
-export const loadTrace = async () => (await import('../commands/sessions-trace.js')).registerTraceCommand;
-export const loadPty = async () => (await import('../commands/pty.js')).registerPtyCommands;
-export const loadTmux = async () => (await import('../commands/tmux.js')).registerTmuxCommands;
-export const loadWatchdog = async () => (await import('../commands/watchdog.js')).registerWatchdogCommand;
-export const loadBrowser = async () => (await import('../commands/browser.js')).registerBrowserCommand;
-export const loadComputer = async () => (await import('../commands/computer.js')).registerComputerCommand;
-export const loadLogs = async () => (await import('../commands/logs.js')).registerLogsCommand;
-export const loadEvents = async () => (await import('../commands/events.js')).registerEventsCommand;
-export const loadSsh = async () => (await import('../commands/ssh.js')).registerSshCommands;
-export const loadRepo = async () => (await import('../commands/repo.js')).registerRepoCommands;
-export const loadSetup = async () => (await import('../commands/setup.js')).registerSetupCommand;
-export const loadUninstall = async () => (await import('../commands/uninstall.js')).registerUninstallCommands;
-export const loadUpgrade = async () => (await import('../commands/upgrade.js')).registerUpgradeCommand;
+const loadSecrets = async () => (await import('../commands/secrets-passthrough.js')).registerSecretsCommands;
+const loadMenubar = async () => (await import('../commands/menubar.js')).registerMenubarCommands;
+const loadSync = async () => (await import('../commands/sync.js')).registerSyncCommand;
+const loadRefreshRules = async () => (await import('../commands/refresh-rules.js')).registerRefreshRulesCommand;
+const loadFactory = async () => (await import('../commands/factory.js')).registerFactoryCommands;
+const loadInsights = async () => (await import('../commands/insights.js')).registerInsightsCommand;
+const loadTrace = async () => (await import('../commands/sessions-trace.js')).registerTraceCommand;
+const loadTmux = async () => (await import('../commands/tmux.js')).registerTmuxCommands;
+const loadWatchdog = async () => (await import('../commands/watchdog.js')).registerWatchdogCommand;
+const loadBrowser = async () => (await import('../commands/browser.js')).registerBrowserCommand;
+const loadComputer = async () => (await import('../commands/computer.js')).registerComputerCommand;
+const loadLogs = async () => (await import('../commands/logs.js')).registerLogsCommand;
+const loadEvents = async () => (await import('../commands/events.js')).registerEventsCommand;
+const loadSsh = async () => (await import('../commands/ssh.js')).registerSshCommands;
+const loadRepo = async () => (await import('../commands/repo.js')).registerRepoCommands;
+const loadSetup = async () => (await import('../commands/setup.js')).registerSetupCommand;
+const loadUninstall = async () => (await import('../commands/uninstall.js')).registerUninstallCommands;
+const loadUpgrade = async () => (await import('../commands/upgrade.js')).registerUpgradeCommand;
 export const loadSessions = async () => (await import('../commands/sessions.js')).registerSessionsCommands;
 export const loadTeams = async () => (await import('../commands/teams.js')).registerTeamsCommands;
-export const loadCloud = async () => (await import('../commands/cloud.js')).registerCloudCommands;
-export const loadMessage = async () => (await import('../commands/message.js')).registerMessageCommand;
-export const loadSend = async () => (await import('../commands/send.js')).registerSendCommand;
-export const loadFeed = async () => (await import('../commands/feed.js')).registerFeedCommand;
-export const loadMailboxes = async () => (await import('../commands/mailboxes.js')).registerMailboxesCommand;
+const loadCloud = async () => (await import('../commands/cloud.js')).registerCloudCommands;
+const loadMessage = async () => (await import('../commands/message.js')).registerMessageCommand;
+const loadSend = async () => (await import('../commands/send.js')).registerSendCommand;
+const loadFeed = async () => (await import('../commands/feed.js')).registerFeedCommand;
+const loadMailboxes = async () => (await import('../commands/mailboxes.js')).registerMailboxesCommand;
 // Registers the `artifacts` group (`share` + `setup` + nested `unshare`).
-export const loadArtifacts = async () => (await import('../commands/artifacts.js')).registerArtifactsCommands;
-export const loadWebhooks = async () => (await import('../commands/webhook.js')).registerWebhooksCommand;
-export const loadHumans = async () => (await import('../commands/humans.js')).registerHumansCommands;
-export const loadAccounts = async () => (await import('../commands/accounts.js')).registerAccountsCommand;
-export const loadDaemon = async () => (await import('../commands/daemon.js')).registerDaemonCommand;
-export const loadAuth = async () => (await import('../commands/auth.js')).registerAuthCommand;
-export const loadTraces = async () => (await import('../commands/traces.js')).registerTracesCommands;
+const loadArtifacts = async () => (await import('../commands/artifacts.js')).registerArtifactsCommands;
+const loadWebhooks = async () => (await import('../commands/webhook.js')).registerWebhooksCommand;
+const loadHumans = async () => (await import('../commands/humans.js')).registerHumansCommands;
+const loadAccounts = async () => (await import('../commands/accounts.js')).registerAccountsCommand;
+const loadDaemon = async () => (await import('../commands/daemon.js')).registerDaemonCommand;
+const loadAuth = async () => (await import('../commands/auth.js')).registerAuthCommand;
+const loadTraces = async () => (await import('../commands/traces.js')).registerTracesCommands;
 export const loadReminders = async () => (await import('../commands/reminders.js')).registerRemindersCommand;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
@@ -187,7 +186,6 @@ export const COMMAND_LOADERS = {
     // `agents trace` is a top-level alias of `agents sessions trace` (precedent:
     // `agents insights` aliases `agents sessions insights`). One implementation.
     trace: [loadTrace],
-    pty: [loadPty],
     tmux: [loadTmux],
     watchdog: [loadWatchdog],
     browser: [loadBrowser],

package/dist/commands/apply.d.ts

@@ -10,10 +10,6 @@
 import { Command } from 'commander';
 /** padEnd on the visible width, ignoring chalk color codes. Exported for tests. */
 export declare function stripPad(s: string, width: number): string;
-/**
- * Attach the reconcile options + action to a command node.
- */
-export declare function configureApplyCommand(cmd: Command): Command;
 /**
  * Canonical surface: `agents fleet apply` / `agents devices apply`.
  * Top-level `agents apply` is retired (RUSH-2981) — not a noun, already nested

package/dist/commands/apply.js

@@ -18,7 +18,7 @@ import { isHostPinned, isDevicePinned, managedKnownHostsPath } from '../lib/devi
 import { ensureDevicesRegistered } from '../lib/devices/sync.js';
 import { readFleetFile, resolveDesired, emptyTargetsMessage } from '../lib/fleet/manifest.js';
 import { snapshotAuth } from '../lib/fleet/auth-sync.js';
-import { AUTH_BUNDLE_NAME } from '../lib/secrets-policy.js';
+import { AUTH_STORE_ALIAS } from '../lib/secrets-policy.js';
 import { agentIdOf, diffFleet, probeDevice, runFleetApply, pool, sourceHome, expandAllSpecs, rosterNeedsVersions, fleetSecretsBundles, } from '../lib/fleet/apply.js';
 import { listInstalledVersions } from '../lib/installations/versions.js';
 /** Version of the running agents-cli — the fleet target version. */
@@ -221,7 +221,7 @@ async function runApply(opts) {
     // discipline as `withVersions` — a fleet that uses no bundles never pays it.
     const secretsBundles = fleetSecretsBundles(manifest.secrets?.bundles);
     const withSecrets = (opts.provisionSecrets === true && secretsBundles.length > 0)
-        || secretsBundles.includes(AUTH_BUNDLE_NAME);
+        || secretsBundles.includes(AUTH_STORE_ALIAS);
     console.log(chalk.gray(`Probing ${desired.length} device(s)…`));
     const probeList = await pool(desired, 6, async (d) => probeDevice(nameToProfile.get(d.device), { withVersions, withSecrets }));
     const probes = new Map(probeList.map((p) => [p.device, p]));
@@ -308,7 +308,7 @@ function reportResults(results) {
 /**
  * Attach the reconcile options + action to a command node.
  */
-export function configureApplyCommand(cmd) {
+function configureApplyCommand(cmd) {
     return cmd
         .description('Reconcile the fleet to a declared profile: install agents and sync config.')
         .option('-f, --file <path>', 'Manifest file carrying a fleet: block (default: agents.yaml)')

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

@@ -3,15 +3,11 @@ export interface BrowserTask {
     task: TaskStatus;
     profile: ProfileStatus;
 }
-export interface PickedBrowserTask {
+interface PickedBrowserTask {
     task: BrowserTask;
     action: 'view' | 'stop';
 }
-/** Build the preview pane for a browser task. */
-export declare function buildBrowserPreview(item: BrowserTask): string;
-/** Build the list label for a browser task. */
-export declare function buildBrowserLabel(item: BrowserTask, query: string): string;
-export interface BrowserPickerConfig {
+interface BrowserPickerConfig {
     message: string;
     tasks: BrowserTask[];
     pageSize?: number;
@@ -19,3 +15,4 @@ export interface BrowserPickerConfig {
 }
 /** Show an interactive browser task picker. */
 export declare function browserTaskPicker(config: BrowserPickerConfig): Promise<PickedBrowserTask | null>;
+export {};

package/dist/commands/browser-picker.js

@@ -12,7 +12,7 @@ function formatAge(ms) {
     return humanDuration(Date.now() - ms) + ' ago';
 }
 /** Build the preview pane for a browser task. */
-export function buildBrowserPreview(item) {
+function buildBrowserPreview(item) {
     const { task, profile } = item;
     const lines = [];
     // Line 1: Task name (ID: xxx)
@@ -48,7 +48,7 @@ export function buildBrowserPreview(item) {
     return lines.join('\n');
 }
 /** Build the list label for a browser task. */
-export function buildBrowserLabel(item, query) {
+function buildBrowserLabel(item, query) {
     const { task, profile } = item;
     const termWidth = process.stdout.columns || 80;
     // Format: name profile tabs domains age

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

@@ -1,4 +1,4 @@
-export interface BrowserSessionsCommandOpts {
+interface BrowserSessionsCommandOpts {
     profile?: string;
     open?: string | boolean;
     json?: boolean;
@@ -14,3 +14,4 @@ export declare function shouldOpenInteractiveBrowserSessions(opts: BrowserSessio
  * sites so the interactive routing decision lives in one place.
  */
 export declare function runBrowserSessionsCommand(opts: BrowserSessionsCommandOpts): Promise<void>;
+export {};

package/dist/commands/computer-sessions-picker.d.ts

@@ -1,5 +1,5 @@
 import { type ComputerRunRow } from '../lib/computer/sessions-list.js';
-export interface ComputerSessionsCommandOpts {
+interface ComputerSessionsCommandOpts {
     machine?: string;
     /** Row cap for the flat table only — the interactive picker is searchable
      *  and shows every row regardless (see `runComputerSessions`). */
@@ -19,3 +19,4 @@ export declare function shouldOpenInteractiveComputerSessions(opts: ComputerSess
  * split so both call sites stay in lockstep.
  */
 export declare function runComputerSessionsCommand(opts: ComputerSessionsCommandOpts): Promise<void>;
+export {};

package/dist/commands/computer.d.ts

@@ -39,6 +39,7 @@
  * own event ledger.
  */
 import { Command } from 'commander';
+import { type ComputerTargetContext } from '../lib/computer/context.js';
 /**
  * The verb catalog. Descriptions are the consumer's (they appear in
  * `agents computer --help`); flags are the engine's.
@@ -65,38 +66,32 @@ export declare function shouldBlockOffPlatform(opts: {
     device?: string;
 }): boolean;
 /**
- * Put `--device <name>` back on the argv handed to the engine.
+ * Put `--host <address>` on the argv handed to the engine.
  *
  * commander CONSUMES the `--device` it declares, so a verb that only read
  * `opts.device` forwarded an argv with no remote selector in it and the engine
  * — which selects the remote path from its own argv — ran the invocation
  * LOCALLY. That is how `setup --device win-mini` installed the macOS helper on
  * the laptop. The flag is re-inserted immediately after the verb rather than
- * appended, so a verb whose operands are variadic cannot swallow it.
+ * appended, so a verb whose operands are variadic cannot swallow it. A `--host`
+ * the caller already typed always wins — it is never overwritten (PHNX-4090).
  *
  * Pure, so the re-insertion is testable without spawning the engine.
  */
-export declare function withDeviceFlag(argv: string[], device?: string): string[];
+export declare function withHostFlag(argv: string[], host?: string): string[];
 /**
- * Forward one invocation to the engine and propagate its exit code.
- *
- * A missing standalone is the one failure agents-cli reports itself, because it
- * is the one the engine cannot: it prints the install line and exits 1. There is
- * no fallback engine to reach for — that is the point of the extraction.
+ * Resolve `--device <name>` to the `--host <address>` the engine actually
+ * speaks (PHNX-4090). A device's `computer.host` config (`agents config set
+ * devices.<name>.computer.host <address>`) wins when set — `vnc://`/`tcp://`
+ * carries no ssh identity, `ssh://` still resolves one against the fleet. With
+ * no `computer.host`, fall back to the fleet's ssh identity exactly as before
+ * (Windows-only — the tunnel this repo has always provisioned).
  */
-export declare function forwardToComputer(opts: {
-    argv: string[];
-    device?: string;
-    /** Skip recording — lifecycle verbs are not user actions. */
-    record?: boolean;
-    /** Read the engine's stdout instead of letting it reach the terminal. */
-    capture?: boolean;
-}): Promise<{
-    exitCode: number;
-    stdout: string;
+export declare function resolveDeviceHost(device: string): Promise<{
+    host: string;
+    target: ComputerTargetContext;
 }>;
 export declare function registerComputerCommand(program: Command): void;
-export declare function registerComputerSubcommands(program: Command): void;
 /**
  * Install the macOS helper through the engine. Used by the `agents setup
  * computer` wizard, which still owns the TCC hand-holding — that is a

package/dist/commands/computer.js

@@ -42,6 +42,9 @@ import { registerCommandGroups, setHelpSections } from '../lib/help.js';
 import { loadComputerAllowList, loadDefaultPeers, resolveTcpEndpoint, resolveVncEndpoint, } from '../lib/computer/policy.js';
 import { buildComputerContext } from '../lib/computer/context.js';
 import { recordComputerAction } from '../lib/computer/record.js';
+import { resolveRemoteDevice } from '../lib/ssh-tunnel.js';
+import { getConfigValue } from '../lib/device-config.js';
+import { parseAddress, sshTarget } from '../lib/address.js';
 import { isComputerClientError, resolveComputerBin, runComputer, } from '../lib/computer-client.js';
 import { runComputerSessionsCommand } from './computer-sessions-picker.js';
 // Help groups — mirror `agents browser` so the mental model carries over.
@@ -99,22 +102,65 @@ export function shouldBlockOffPlatform(opts) {
     return true;
 }
 /**
- * Put `--device <name>` back on the argv handed to the engine.
+ * Put `--host <address>` on the argv handed to the engine.
  *
  * commander CONSUMES the `--device` it declares, so a verb that only read
  * `opts.device` forwarded an argv with no remote selector in it and the engine
  * — which selects the remote path from its own argv — ran the invocation
  * LOCALLY. That is how `setup --device win-mini` installed the macOS helper on
  * the laptop. The flag is re-inserted immediately after the verb rather than
- * appended, so a verb whose operands are variadic cannot swallow it.
+ * appended, so a verb whose operands are variadic cannot swallow it. A `--host`
+ * the caller already typed always wins — it is never overwritten (PHNX-4090).
  *
  * Pure, so the re-insertion is testable without spawning the engine.
  */
-export function withDeviceFlag(argv, device) {
-    if (!device)
+export function withHostFlag(argv, host) {
+    if (!host)
+        return argv;
+    if (argv.some((arg) => arg === '--host' || arg.startsWith('--host=')))
         return argv;
     const [verb, ...rest] = argv;
-    return [verb, '--device', device, ...rest];
+    return [verb, '--host', host, ...rest];
+}
+/**
+ * Resolve `--device <name>` to the `--host <address>` the engine actually
+ * speaks (PHNX-4090). A device's `computer.host` config (`agents config set
+ * devices.<name>.computer.host <address>`) wins when set — `vnc://`/`tcp://`
+ * carries no ssh identity, `ssh://` still resolves one against the fleet. With
+ * no `computer.host`, fall back to the fleet's ssh identity exactly as before
+ * (Windows-only — the tunnel this repo has always provisioned).
+ */
+export async function resolveDeviceHost(device) {
+    const configured = getConfigValue('computer.host', { device }).value;
+    if (configured) {
+        const addr = parseAddress(configured);
+        if (addr.scheme === 'vnc' || addr.scheme === 'tcp') {
+            // No ssh identity involved — the transport is RFB or a raw helper socket.
+            return { host: configured, target: { alias: device, host: addr.host, user: addr.user ?? '', hostname: addr.host, platform: addr.scheme, sshArgs: [] } };
+        }
+        // The configured address IS the connection target — an ssh:// override
+        // naming a different host/user/port than the device registry must actually
+        // take effect, not be silently replaced by the registry's own resolution.
+        // Only the ssh identity (key file flags) comes from the fleet; the target
+        // string forwarded on --host and the one recorded on fd-3 must be the same
+        // `sshTarget(addr)` the engine itself derives from that same --host value,
+        // or the engine's own context-vs-argv match (`resolveContextDevice`) misses
+        // and silently drops the identity args instead of failing loud.
+        const resolved = await resolveRemoteDevice(device, {});
+        const target = sshTarget(addr);
+        return {
+            host: configured,
+            target: { alias: device, host: target, user: addr.user ?? resolved.user, hostname: addr.host, platform: resolved.device.platform, sshArgs: resolved.identityArgs },
+        };
+    }
+    const resolved = await resolveRemoteDevice(device, {
+        expectPlatform: 'windows',
+        forWhat: '`agents computer --device` drives the Windows computer-helper daemon, so it',
+    });
+    return {
+        host: `ssh://${resolved.target}`,
+        target: { alias: device, host: resolved.target, user: resolved.user, hostname: resolved.host, platform: resolved.device.platform, sshArgs: resolved.identityArgs },
+    };
 }
 /**
  * Forward one invocation to the engine and propagate its exit code.
@@ -123,7 +169,7 @@ export function withDeviceFlag(argv, device) {
  * is the one the engine cannot: it prints the install line and exits 1. There is
  * no fallback engine to reach for — that is the point of the extraction.
  */
-export async function forwardToComputer(opts) {
+async function forwardToComputer(opts) {
     let bin;
     try {
         bin = resolveComputerBin();
@@ -136,10 +182,19 @@ export async function forwardToComputer(opts) {
         throw err;
     }
     const hostFlag = opts.argv.findIndex(arg => arg === '--host' || arg.startsWith('--host='));
-    const host = hostFlag < 0 ? undefined : (opts.argv[hostFlag].includes('=') ? opts.argv[hostFlag].slice(7) : opts.argv[hostFlag + 1]);
-    const context = await buildComputerContext({ device: opts.device, host, computerBin: bin });
+    let host = hostFlag < 0 ? undefined : (opts.argv[hostFlag].includes('=') ? opts.argv[hostFlag].slice(7) : opts.argv[hostFlag + 1]);
+    let target;
+    // A device is resolved to --host here rather than forwarded as --device: the
+    // engine has no fleet registry of its own (PHNX-4090). An explicit --host on
+    // the command line always wins over --device, so this only runs without one.
+    if (!host && opts.device) {
+        const resolved = await resolveDeviceHost(opts.device);
+        host = resolved.host;
+        target = resolved.target;
+    }
+    const context = await buildComputerContext({ device: opts.device, host, target, computerBin: bin });
     return runComputer({
-        argv: withDeviceFlag(opts.argv, opts.device),
+        argv: withHostFlag(opts.argv, host),
         context,
         capture: opts.capture,
         onEvent: opts.record === false
@@ -224,7 +279,7 @@ export function registerComputerCommand(program) {
     `,
     });
 }
-export function registerComputerSubcommands(program) {
+function registerComputerSubcommands(program) {
     registerSetupCommand(program);
     registerStartCommand(program);
     registerStopCommand(program);