@phnx-labs/agents-cli 1.22.114 → 1.22.115

package/dist/commands/browser.js

@@ -25,7 +25,11 @@ import { withActorEnv } from '../lib/hosts/dispatch.js';
 import { streamAgentsOnHost, passthroughSshOptions, } from '../lib/hosts/passthrough.js';
 import { buildRemoteAgentsInvocation, HOST_ROUTING_SPECS, stripRoutingFlags, } from '../lib/hosts/remote-cmd.js';
 import { resolveRemoteOsSync } from '../lib/hosts/remote-os.js';
-import { sshExec, SSH_OPTS } from '../lib/ssh-exec.js';
+import { sshExec, SSH_OPTS, sshStreamWithArgs } from '../lib/ssh-exec.js';
+import { getBrowserRuntimeDir } from '../lib/state.js';
+import { buildSshInvocation, writeAskpassShim } from '../lib/devices/connect.js';
+import { resolveDeviceProfile } from '../lib/devices/resolve-profile.js';
+import { resolveDeviceTarget } from '../lib/devices/resolve-target.js';
 import { flagValue } from '../lib/hosts/routing-flag.js';
 import { browserTaskPicker } from './browser-picker.js';
 import { assertRemoteControlAllowed, isFleetRemoteInvocation } from '../lib/browser/remote-control.js';
@@ -35,7 +39,7 @@ import { registerCommandGroups, setHelpSections } from '../lib/help.js';
 import { buildHar } from '../lib/browser/har.js';
 import { getCliVersion } from '../lib/version.js';
 import { runBrowserIPCStream } from '../lib/browser/stream.js';
-import { machineId } from '../lib/machine-id.js';
+import { machineId, normalizeHost } from '../lib/machine-id.js';
 import { isArcRunning } from '../lib/browser/drivers/arc.js';
 import { resolveBrowserTarget } from '../lib/browser/resolve-target.js';
 /**
@@ -179,6 +183,158 @@ export function remoteStartTaskName(stdout, explicit) {
     }
     return trimmed.split('\n').map((line) => line.trim()).find(Boolean);
 }
+/**
+ * Fetch an absolute remote file into a private local path, bounded.
+ *
+ * Bounded for real, not by a pre-flight `stat`: the byte budget is enforced on the
+ * stream as it arrives (`sshExecRawStream` + `cat`), so a file that grows between
+ * a size check and the copy — or a peer that lies about the size — still cannot
+ * spend more than the budget. `scp` could not do this; it would transfer
+ * everything before this process got a chance to refuse.
+ *
+ * The local file is written 0600 inside a 0700 directory, because a capture can
+ * show anything that was on the peer's screen and a world-readable temp path
+ * would publish it to every local user.
+ */
+/**
+ * The command that streams one file's RAW BYTES to stdout on the device's shell.
+ *
+ * Platform-correct, not one command with a portable-looking name. On Windows
+ * `cat` is an alias for `Get-Content`, which is a TEXT reader: it decodes the
+ * file, splits it into lines, and re-encodes on output — so a screenshot arrives
+ * corrupted rather than merely reordered. The .NET path opens a `FileStream` and
+ * copies it into the raw stdout handle, bypassing PowerShell's object/text
+ * pipeline entirely, which is the only way binary survives.
+ */
+export function remoteReadFileArgv(remotePath, shell) {
+    if (shell === 'powershell') {
+        // Single-quoted inside the script with pwsh's own doubling, because this whole
+        // script is ONE argv token to the outer powershell.
+        const literal = remotePath.replace(/'/g, "''");
+        return ['powershell', '-NoProfile', '-Command', [
+                '$ErrorActionPreference=' + "'Stop';",
+                `$in=[System.IO.File]::OpenRead('${literal}');`,
+                'try{$out=[System.Console]::OpenStandardOutput();$in.CopyTo($out);$out.Flush()}finally{$in.Dispose()}',
+            ].join(' ')];
+    }
+    // `--` so a path that begins with a dash is a path, not an option.
+    return ['cat', '--', remotePath];
+}
+/**
+ * Largest capture `browser show --device` will pull. A capture is a screenshot,
+ * a PDF or a short recording; anything past this is not something a viewer should
+ * stream over ssh, and the cap is what makes the transfer BOUNDED rather than
+ * "however big the peer's file happens to be".
+ */
+export const REMOTE_VIEW_MAX_BYTES = 64 * 1024 * 1024;
+/** Write a whole buffer, looping until it is all out. */
+function writeFully(handle, chunk) {
+    let offset = 0;
+    while (offset < chunk.length) {
+        // `writeSync` may write FEWER bytes than asked (a signal, a pipe boundary),
+        // and ignoring the return value silently truncated the file mid-capture.
+        const wrote = fs.writeSync(handle, chunk, offset, chunk.length - offset);
+        if (wrote <= 0)
+            throw new Error('local write made no progress');
+        offset += wrote;
+    }
+}
+/**
+ * Fetch an absolute remote file into a private local path, bounded.
+ *
+ * Auth is the CANONICAL device path, not a hand-rolled ssh: `buildSshInvocation`
+ * supplies the askpass shim for a password-auth box, `-i`/`IdentitiesOnly` for an
+ * explicit identity file, and the managed known-hosts pinning. Building the ssh
+ * args here instead meant a password-auth device could not be reached at all and
+ * an explicit `identityFile` was silently ignored.
+ *
+ * Bounded for real, not by a pre-flight `stat`: the byte budget is enforced on the
+ * stream as it arrives, so a file that grows between a size check and the copy — or
+ * a peer that misreports its size — still cannot spend more than the budget.
+ *
+ * The local file is written 0600 inside a 0700 directory, because a capture can
+ * show anything that was on the peer's screen and a world-readable temp path
+ * would publish it to every local user.
+ */
+export async function fetchRemoteFileForViewing(device, remotePath, localPath, opts = {}) {
+    const posixAbsolute = path.posix.isAbsolute(remotePath);
+    const windowsAbsolute = /^[A-Za-z]:[\\/]/.test(remotePath) || /^\\\\/.test(remotePath);
+    if (!posixAbsolute && !windowsAbsolute) {
+        throw new Error(`Remote path must be absolute: got "${remotePath}".\n`
+            + 'This machine cannot resolve the peer\'s working directory, so a relative path\n'
+            + 'would name a different file there than you meant here.');
+    }
+    // `resolveDeviceTarget` is the SAME resolver `agents ssh` uses, so it yields the
+    // full device profile — platform, shell and auth — that `buildSshInvocation`
+    // needs. `resolveHost` returns a hosts-registry `Host`, which carries none of
+    // that: with it, a password-auth device could not be reached and an explicit
+    // identityFile was silently dropped.
+    const resolved = await resolveDeviceTarget(device);
+    if (!resolved)
+        throw new Error(`Unknown device "${device}". Next: agents devices list`);
+    const profile = resolveDeviceProfile(resolved);
+    const maxBytes = opts.maxBytes ?? REMOTE_VIEW_MAX_BYTES;
+    // A POSIX device cannot read a Windows path and vice versa; saying so here beats
+    // a confusing shell error from the peer.
+    if (profile.shell === 'powershell' && posixAbsolute && !windowsAbsolute) {
+        throw new Error(`"${remotePath}" is a POSIX path but ${device} runs PowerShell. Pass the Windows path (e.g. C:\\Users\\…).`);
+    }
+    if (profile.shell !== 'powershell' && windowsAbsolute) {
+        throw new Error(`"${remotePath}" is a Windows path but ${device} is a POSIX host. Pass the absolute POSIX path.`);
+    }
+    const resolvedLocal = path.resolve(localPath);
+    const dir = path.dirname(resolvedLocal);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700);
+    const handle = fs.openSync(resolvedLocal, 'w', 0o600);
+    let written = 0;
+    let overflow = false;
+    const controller = new AbortController();
+    try {
+        // `argv: true` is what makes a path containing a space or a quote survive —
+        // the same exact-token delivery `agents ssh --argv` exposes.
+        const { args, env } = buildSshInvocation(profile, remoteReadFileArgv(remotePath, profile.shell), writeAskpassShim(), {}, { argv: true });
+        const result = await sshStreamWithArgs({
+            args,
+            env,
+            timeoutMs: opts.timeoutMs ?? 120_000,
+            signal: controller.signal,
+            onStdout: (chunk) => {
+                if (overflow)
+                    return;
+                if (written + chunk.length > maxBytes) {
+                    overflow = true;
+                    controller.abort();
+                    return;
+                }
+                writeFully(handle, chunk);
+                written += chunk.length;
+            },
+        });
+        if (overflow) {
+            throw new Error(`Refusing to pull ${device}:${remotePath}: larger than the ${maxBytes}-byte view budget.`);
+        }
+        if (result.timedOut)
+            throw new Error(`Timed out pulling ${device}:${remotePath}.`);
+        if (result.code !== 0) {
+            const detail = result.stderr.toString('utf8').trim();
+            throw new Error(`Failed to read ${device}:${remotePath}${detail ? `: ${detail}` : ` (ssh exited ${result.code})`}`);
+        }
+        if (written === 0)
+            throw new Error(`${device}:${remotePath} is empty or was not readable.`);
+    }
+    catch (error) {
+        // Never leave a partial file behind for a viewer to open as if it were whole.
+        try {
+            fs.unlinkSync(resolvedLocal);
+        }
+        catch { /* nothing to clean */ }
+        throw error;
+    }
+    finally {
+        fs.closeSync(handle);
+    }
+}
 async function pullRemoteFile(device, remotePath, localPath) {
     const host = await resolveHost(device);
     if (!host) {
@@ -2071,8 +2227,14 @@ function registerTaskCommands(browser) {
     });
     browser
         .command('show <url>')
-        .description('Open a URL for a human to read: goes to browser.viewer (default: browser.profile), and binds no task')
+        .description('Open a URL or local file for a human to read: goes to browser.viewer (default: browser.profile), and binds no task')
         .option('--os-browser', 'Use the OS default handler instead of the configured viewer')
+        // `--device` here names WHERE THE FILE IS, not where to open it. `show` is the
+        // one browser verb narrowly exempt from the task-routing refusal
+        // (`REJECT_DEVICE_MESSAGE`) because it binds no task and has nothing to route:
+        // it is a local viewer, so the flag can only mean "the source lives there".
+        // Every other verb still refuses `--device` — a task is bound at `start`.
+        .option('--device <name>', 'fetch the file from this device, then view it locally (absolute path only)')
         .option('--json', 'Output machine-readable JSON')
         .action(async (url, opts) => {
         // The entry point external tools need. `navigate` binds a task, which the
@@ -2083,20 +2245,48 @@ function registerTaskCommands(browser) {
         // drive letter (`C:\Users\me\plan.html`), so a real path was treated as a
         // URL. A scheme is at least two characters.
         const isLocalFile = !/^[a-z][a-z0-9+.-]+:/i.test(url);
-        const outcome = isLocalFile
-            ? await showFile(path.resolve(url), { osBrowser: opts.osBrowser })
+        let localTarget = isLocalFile ? path.resolve(url) : undefined;
+        let fetched;
+        if (opts.device) {
+            // A URL is already reachable from here, so `--device` with one is a
+            // contradiction rather than a no-op: it says the source is remote while
+            // naming something that is not a file on that peer.
+            if (!isLocalFile) {
+                console.error(`--device names the device holding a FILE, so it cannot be combined with a URL.\n  Drop --device to open ${url} here, or pass an absolute path on ${opts.device}.`);
+                process.exit(1);
+            }
+            // The peer's path, verbatim — NOT path.resolve()'d, which would rewrite it
+            // against this machine's cwd and name a different file there.
+            const remotePath = url;
+            const dir = path.join(getBrowserRuntimeDir(), 'remote-views');
+            fetched = path.join(dir, `${normalizeHost(opts.device)}-${Date.now()}-${path.basename(remotePath) || 'capture'}`);
+            try {
+                await fetchRemoteFileForViewing(opts.device, remotePath, fetched);
+            }
+            catch (error) {
+                console.error(error.message);
+                process.exit(1);
+            }
+            localTarget = fetched;
+        }
+        const outcome = localTarget
+            ? await showFile(localTarget, { osBrowser: opts.osBrowser })
             : await showUrl(url, { osBrowser: opts.osBrowser });
+        // The fetched copy is what a viewer actually opened, so it is what the
+        // caller is told about — pointing at the peer's path would name a file that
+        // is not on this machine.
+        const shown = fetched ?? url;
         if (opts.json) {
-            console.log(JSON.stringify(outcome, null, 2));
+            console.log(JSON.stringify({ ...outcome, ...(fetched ? { source: `${opts.device}:${url}`, local: fetched } : {}) }, null, 2));
         }
         else if (outcome.via === 'none') {
-            console.error(`Could not open a browser — open this yourself:\n  ${url}`);
+            console.error(`Could not open a browser — open this yourself:\n  ${shown}`);
         }
         else if (outcome.via === 'profile') {
-            console.log(`Shown in ${outcome.profile}: ${url}`);
+            console.log(`Shown in ${outcome.profile}: ${shown}`);
         }
         else {
-            console.log(`Opened in the OS default browser: ${url}`);
+            console.log(`Opened in the OS default browser: ${shown}`);
         }
         if (outcome.via === 'none')
             process.exit(1);

package/dist/commands/doctor.d.ts

@@ -18,9 +18,8 @@
  * Read-only always: doctor diagnoses, it never mutates. To fix the gaps it
  * finds — install missing resources, repair Claude-invalid plugin manifests,
  * refresh stale plugins, reconcile drift, repair hook runtime shims — run
- * `agents sync <agent>@all` (the one fixer, a superset of the old `doctor
- * --fix`). Run `agents prune cleanup` to act on orphan readouts. `--fix` is a
- * deprecated no-op that now errors with a pointer to `agents sync`.
+ * `agents sync <agent>@all` (the one fixer). Run `agents prune cleanup` to act
+ * on orphan readouts.
  */
 import type { Command } from 'commander';
 import { type FleetInventory } from '../lib/devices/fleet-divergence.js';

package/dist/commands/doctor.js

@@ -1251,7 +1251,6 @@ export function registerDoctorCommand(program) {
         .description('Diagnose CLI availability, sync status, and resource divergence (optionally for a specific agent[@version]).')
         .option('--json', 'Output machine-readable JSON')
         .option('--diff', 'In target mode, include unified diffs for divergent files')
-        .option('--fix', '(deprecated) doctor is diagnose-only — this errors with a pointer to `agents sync`, the one fixer')
         .option('--kind <kinds>', 'Restrict to comma-separated resource kinds (commands,skills,hooks,rules,mcp,permissions,subagents,plugins,workflows,memory)')
         .option('--cwd <path>', 'Resolution cwd for project layer detection (default: process.cwd())')
         .option('--adopt <agent>', "Take over the agent's native launcher that shadows the shim (symlink it to the version-managed shim; reversible with --release)")
@@ -1381,16 +1380,6 @@ export function registerDoctorCommand(program) {
             }
             return;
         }
-        // `doctor --fix` moved to `agents sync` — doctor is diagnose-only now.
-        // Keep the flag for one release as a signpost: it never heals, it points at
-        // the one fixer and exits non-zero so scripts and muscle memory get a clear
-        // redirect instead of a silent no-op.
-        if (opts.fix) {
-            const where = target ? `agents sync ${target}` : 'agents sync <agent>@all';
-            console.error(chalk.yellow('`agents doctor --fix` has moved to `agents sync`.'));
-            console.error(chalk.gray(`  doctor now only diagnoses. To fix, run: ${where}`));
-            process.exit(1);
-        }
         if (!target) {
             // Singleflight + short-TTL cache for the bare `doctor --json` overview.
             // This overview probes every host CLI, every agent's sign-in, and every

package/dist/commands/events.d.ts

@@ -42,13 +42,11 @@ export interface EventsOptions {
     limit?: string;
     json?: boolean;
     follow?: boolean;
-    /** @deprecated Prefer --include ops / --exclude activity */
-    audit?: boolean;
     include?: string;
     exclude?: string;
 }
 /** Add the one canonical event-reader option surface to a command or alias. */
-export declare function addEventsReadOptions(command: Command, includeAuditFlag?: boolean): Command;
+export declare function addEventsReadOptions(command: Command): Command;
 /** Canonical reader used by `agents events`, `agents events audit`, and `agents logs`. */
 export declare function runEventsCommand(options: EventsOptions, forceAudit?: boolean): Promise<void>;
 /** Shared by `events stats` and the `logs stats` alias. */

package/dist/commands/events.js

@@ -195,7 +195,7 @@ function registerEmitSubcommand(events) {
     });
 }
 /** Add the one canonical event-reader option surface to a command or alias. */
-export function addEventsReadOptions(command, includeAuditFlag = true) {
+export function addEventsReadOptions(command) {
     command
         .option('--include <families>', `Only these families (comma-sep): ${EVENT_FAMILIES.join(', ')}`)
         .option('--exclude <families>', `Drop these families (comma-sep): ${EVENT_FAMILIES.join(', ')}`)
@@ -211,9 +211,6 @@ export function addEventsReadOptions(command, includeAuditFlag = true) {
         .option('--limit <n>', 'Max records to show; 0 for no cap (default 50)', '50')
         .option('--json', 'Output raw records as JSON')
         .option('-f, --follow', "Tail today's operational log live");
-    if (includeAuditFlag) {
-        command.option('--audit', 'Deprecated: operational events only — prefer --include ops or --exclude activity');
-    }
     return command;
 }
 /** Canonical reader used by `agents events`, `agents events audit`, and `agents logs`. */
@@ -242,11 +239,11 @@ export async function runEventsCommand(options, forceAudit = false) {
         process.exitCode = 2;
         return;
     }
-    // --audit / forceAudit = ops-only when no family flags. Families own the
-    // source selection via applyFamilies — never override includeActivity after.
+    // forceAudit (`events audit` / `logs`) = ops-only when no family flags. Families
+    // own the source selection via applyFamilies — never override includeActivity after.
     const includeActivity = (includeFamilies !== undefined || excludeFamilies !== undefined)
         ? true
-        : !(forceAudit || options.audit);
+        : !forceAudit;
     const fetched = readUnifiedEvents({
         startDate,
         eventTypes: options.event && options.event.length ? options.event : undefined,

package/dist/commands/exec.d.ts

@@ -53,7 +53,6 @@ interface ExecCommandActionOptions {
      * @deprecated Hidden alias for `--device auto`. Resolved before host dispatch.
      * Remove after one release.
      */
-    smart?: boolean;
     acp?: boolean;
     yes?: boolean;
     loop?: boolean;

package/dist/commands/exec.js

@@ -660,8 +660,6 @@ export function registerRunCommand(program) {
     // `--on` and `--computer` are hidden aliases of `--device` — same behavior.
     runCmd.addOption(new Option('--on <name>', 'Alias of --device.').hideHelp());
     runCmd.addOption(new Option('--computer <name>', 'Alias of --device.').hideHelp());
-    // Deprecated one-release alias: `agents run … --smart` → treat as `--device auto`.
-    runCmd.addOption(new Option('--smart', 'Deprecated: use --device auto (affinity host pick).').hideHelp());
     // Internal: the `--device` dispatch forwards this so the REMOTE run prints its
     // resolved session id as a one-line stdout sentinel (hosts/session-marker.ts),
     // letting the launcher relate the remote-created session back to itself for
@@ -1226,7 +1224,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         const defaultPlacement = bareInteractiveRunDefaultsToDeviceAuto(options, { prompt, devicePickerRequested }, { tty: isInteractiveTerminal(), json: options.json });
         if (defaultPlacement)
             options.device = 'auto';
-        // --device auto (and deprecated --smart): live fleet pick.
+        // --device auto: live fleet pick.
         // Harness is always the agent the user typed — never auto-picked.
         // Placement failure propagates; an automatic request never becomes local.
         {
@@ -1252,9 +1250,6 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 console.error(chalk.gray(`Run here instead: agents run ${runBaseAgentName} --device ${machineId()}`));
                 process.exit(1);
             }
-            if (!options.quiet && result.deprecationSmart) {
-                process.stderr.write(chalk.yellow('[agents] --smart is deprecated; use --device auto\n'));
-            }
             if (!options.quiet && result.banner) {
                 const { hostLabel, deviceHint, acctNote } = result.banner;
                 process.stderr.write(chalk.gray(`[agents] device=auto → ${hostLabel}` +
@@ -2064,7 +2059,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             import('../lib/run-defaults.js'),
             import('../lib/mcp.js'),
             import('../lib/capabilities.js'),
-            import('../lib/share/config.js'),
+            import('../lib/share-runtime.js'),
         ]);
         bootMark('run-deps:imported');
         const isValidAgent = (agent) => ALL_AGENT_IDS.includes(agent);

package/dist/commands/feed-watch.js

@@ -1,10 +1,51 @@
-import { machineId } from '../lib/machine-id.js';
 import { setHelpSections } from '../lib/help.js';
-import { watchFleetFeed, watchLocalFeed } from '../lib/feed/watch.js';
+import { streamFeedFromHub, waitForHub } from '../lib/feed/hub-server.js';
+import { ensureDaemonStarted } from '../lib/daemon/daemon.js';
+/**
+ * Attach to the daemon's shared collector, starting the daemon if it is not up.
+ *
+ * There is deliberately no in-process fallback: running `watchFleetFeed` here
+ * would give this reader its own ssh child per peer, which is exactly the
+ * per-caller fan-out the hub exists to collapse (see `lib/feed/hub.ts`). So a
+ * missing hub is answered by starting its owner and WAITING for it.
+ *
+ * The wait is what makes that honest. `ensureDaemonStarted()` returns once the
+ * process is spawned, long before it has loaded its services and bound the
+ * socket, so retrying immediately raced the bind and reported a daemon that was
+ * about to be perfectly healthy as unavailable. The final error is the one from
+ * the last real attempt, not the first.
+ */
+async function attachToHub(signal, emit, scope) {
+    try {
+        await streamFeedFromHub({ signal, emit, scope });
+        return;
+    }
+    catch (first) {
+        if (signal.aborted)
+            return;
+        ensureDaemonStarted();
+        if (!await waitForHub()) {
+            throw new Error(`the shared feed stream did not come up: ${first.message}\n`
+                + 'Next: agents daemon status, then agents daemon services enable feed-stream');
+        }
+        try {
+            await streamFeedFromHub({ signal, emit, scope });
+        }
+        catch (second) {
+            throw new Error(`the shared feed stream is unavailable: ${second.message}\n`
+                + 'Next: agents daemon status, then agents daemon services enable feed-stream');
+        }
+    }
+}
 export function registerFeedWatchCommand(parent) {
-    const command = parent.command('watch').description('Stream the canonical agent, attention, and activity projection as NDJSON')
+    const command = parent.command('watch').description('Stream the canonical agent, attention, tool, and activity projection as NDJSON')
         .option('--json', 'Emit versioned NDJSON envelopes').option('--local', 'Watch only this machine');
-    setHelpSections(command, { examples: `agents feed watch --json\nagents feed watch --json --local`, notes: 'Order by streamId + sequence. Unavailable scopes retain their last rows until reset on reconnect.' });
+    setHelpSections(command, {
+        examples: `agents feed watch --json\nagents feed watch --json --local`,
+        notes: 'Order by streamId + sequence. Unavailable scopes retain their last rows until reset on reconnect. '
+            + 'The fleet stream is served by the daemon\'s shared collector, so several readers cost one connection per peer; '
+            + '--local is the per-machine stream the collector itself subscribes to over ssh.',
+    });
     command.action(async (_opts, invoked) => {
         const opts = invoked.optsWithGlobals();
         if (!opts.json)
@@ -15,10 +56,13 @@ export function registerFeedWatchCommand(parent) {
         process.once('SIGINT', stop);
         process.once('SIGTERM', stop);
         try {
-            if (opts.local)
-                await watchLocalFeed({ scope: machineId(), signal: controller.signal, emit });
-            else
-                await watchFleetFeed({ signal: controller.signal, emit });
+            // BOTH scopes go through the daemon's shared collectors. `--local` used to
+            // run its own `watchLocalFeed`, so every observing box's ssh subscription
+            // built a separate activity cursor set, tool watcher and setup subscription
+            // on the SAME peer. The local collector is a distinct hub from the fleet one
+            // (`feed-stream-service.ts`) and its watcher dials no peer at all, so a
+            // local reader can never trigger a fan-out, recursively or otherwise.
+            await attachToHub(controller.signal, emit, opts.local ? 'local' : 'fleet');
         }
         finally {
             process.off('SIGINT', stop);

package/dist/commands/focus.js

@@ -136,7 +136,7 @@ export function registerFocusCommand(program) {
       # Resolve latest on yosemite-s0, then pick from that version's sessions
       agents sessions focus claude@latest --device yosemite-s0
 
-      # Attach only — refuse if nothing is joinable (old sessions go)
+      # Attach only — refuse if nothing is joinable
       agents sessions focus a1b2c3d4 --attach-only
 
       # Pick from live sessions on this machine only

package/dist/commands/go.d.ts

@@ -1,23 +1,6 @@
-/**
- * `agents sessions go [id]` — DEPRECATED alias for `agents sessions focus --attach-only`.
- *
- * `go` was "attach or refuse" (never fork/resume). `focus --attach-only` is exactly
- * that behavior, so `go` now prints a deprecation notice and delegates to `focusAction`.
- *
- * This file still owns the shared reach engine that `focus` imports:
- *   - `gatherLiveTargets` / `pickLiveTarget` / `buildLivePool` — live-session discovery + picker
- *   - `jumpTo` — the side-effecting jump: attach the already-running terminal
- *       local tmux    -> attach (switch-client when already inside tmux)
- *       local Ghostty -> focus its tab (Cmd+<n> via System Events; tab # from ghostty-tabs)
- *       remote tmux   -> ssh -tt + tmux attach (pane->session resolved on the remote)
- *       otherwise     -> hand off to the `UnreachableFallback` (attach-only refuses; focus resumes)
- *   - `refuseFallback` — the attach-only fallback (remote -> login shell; local -> refuse)
- */
-import type { Command } from 'commander';
 import { type ActiveSession } from '../lib/session/active.js';
 import type { SessionMeta } from '../lib/session/types.js';
 import { type LiveStatusFilter } from './sessions.js';
-export declare function registerGoCommand(program: Command): void;
 /**
  * Scope a live-session pool by device and live status. Pure so the `focus`
  * device/status filters are unit-testable without touching the sweep. `hosts`

package/dist/commands/go.js

@@ -1,10 +1,6 @@
 /**
- * `agents sessions go [id]` — DEPRECATED alias for `agents sessions focus --attach-only`.
- *
- * `go` was "attach or refuse" (never fork/resume). `focus --attach-only` is exactly
- * that behavior, so `go` now prints a deprecation notice and delegates to `focusAction`.
- *
- * This file still owns the shared reach engine that `focus` imports:
+ * The shared live-session reach engine that `sessions focus` / `resume --attach-only`
+ * import ("attach or refuse", never fork/resume):
  *   - `gatherLiveTargets` / `pickLiveTarget` / `buildLivePool` — live-session discovery + picker
  *   - `jumpTo` — the side-effecting jump: attach the already-running terminal
  *       local tmux    -> attach (switch-client when already inside tmux)
@@ -26,7 +22,6 @@ import { dedupeByMachineSession, mergeLocalFirst, pickSessionInteractive, matche
 import { buildPreview } from './sessions-picker.js';
 import { multiItemPicker } from '../lib/picker.js';
 import { isPromptCancelled } from './utils.js';
-import { focusAction } from './focus.js';
 import { machineId } from '../lib/session/sync/config.js';
 import { attachTmux, runTmux } from '../lib/tmux/binary.js';
 import { ensureSessionHookRepaired, paneExitStatus, teardownIfAgentExited } from '../lib/tmux/session.js';
@@ -36,18 +31,6 @@ import { connectionEndedNotice } from '../lib/hosts/reconnect.js';
 import { enumerateGhosttyTabs, assignGhosttyTabs } from '../lib/session/ghostty-tabs.js';
 import { addressabilityRecoveryHint } from '../lib/terminal/resolve.js';
 const execFileAsync = promisify(execFile);
-export function registerGoCommand(program) {
-    program
-        .command('go', { hidden: true })
-        .argument('[id]', 'Short/full session id to jump to; omit for an interactive picker')
-        .option('--local', 'Only this machine (skip the cross-host sweep)')
-        .description('Deprecated — use `agents sessions resume --attach-only` instead.')
-        .action(async (id, opts) => {
-        console.warn(chalk.yellow('`agents sessions go` is deprecated — use `agents sessions resume --attach-only` instead:'));
-        console.warn(chalk.gray(`  agents sessions resume ${id ?? '<id>'} --attach-only`));
-        await focusAction(id, { local: opts.local, attachOnly: true });
-    });
-}
 /**
  * Scope a live-session pool by device and live status. Pure so the `focus`
  * device/status filters are unit-testable without touching the sweep. `hosts`

package/dist/commands/logs.js

@@ -263,7 +263,7 @@ export function registerLogsCommand(program) {
         .action((id, opts) => runLogs(id, opts));
     addEventsReadOptions(logsCmd
         .command('audit')
-        .description('Alias for `agents events --audit`'), false)
+        .description('Alias for `agents events audit`'))
         .addHelpText('after', `
 Examples:
   agents logs audit                          Recent activity across everything