@phnx-labs/agents-cli 1.22.66 → 1.22.69

package/dist/commands/routines.js

@@ -10,8 +10,9 @@ import ora from 'ora';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
-import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemonLog, getDaemonStatus, getDaemonLogPath, } from '../lib/daemon/daemon.js';
-import { assertSchedulerEnabled, assertDaemonEnabled, isDaemonEnabled } from '../lib/device-config.js';
+import { isDaemonRunning, signalDaemonReload, startDaemon, readDaemonLog, getDaemonStatus, getDaemonLogPath, } 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';
 import { isCustomHarnessName } from '../lib/profiles.js';
 import { RUN_STRATEGIES, normalizeRunStrategy } from '../lib/accounting/rotate.js';
@@ -313,10 +314,17 @@ function ensureSchedulerRunning(opts = {}) {
         console.error(chalk.yellow(err.message));
         return;
     }
+    const wasServiceEnabled = isDaemonServiceEnabled('scheduler');
+    if (!wasServiceEnabled)
+        setDaemonServiceEnabled('scheduler', true);
     if (isDaemonRunning()) {
-        signalDaemonReload();
-        if (!opts.quiet)
-            log(chalk.gray('Scheduler reloaded'));
+        const reloaded = signalDaemonReload();
+        if (!reloaded) {
+            console.error(chalk.yellow('Scheduler service enabled, but live reload is unavailable. Restart deliberately with: agents daemon restart'));
+        }
+        else if (!opts.quiet) {
+            log(chalk.gray(wasServiceEnabled ? 'Scheduler reloaded' : 'Scheduler service enabled and reloaded'));
+        }
         return;
     }
     const result = startDaemon();
@@ -2162,7 +2170,7 @@ export function registerRoutinesCommands(program) {
     // Scheduler lifecycle — usually auto-managed by `routines add`, exposed here for manual control.
     routinesCmd
         .command('start')
-        .description('Start the background scheduler. Usually unnecessary — it auto-starts when you add your first routine.')
+        .description('Enable and reload the scheduler service. Usually unnecessary — it auto-starts when you add your first routine.')
         .action(() => {
         try {
             // A manual start on a disabled device refuses with the same message the
@@ -2176,13 +2184,16 @@ export function registerRoutinesCommands(program) {
             console.error(chalk.red(err.message));
             process.exit(1);
         }
+        setDaemonServiceEnabled('scheduler', true);
         const result = startDaemon();
         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
             // the scheduler — a manual start heals a scheduler-less daemon.
-            signalDaemonReload();
-            console.log(chalk.yellow(`Scheduler already running (PID: ${result.pid}) — reloaded`));
+            const reloaded = signalDaemonReload();
+            console.log(reloaded
+                ? chalk.yellow(`Scheduler service enabled (shared daemon PID: ${result.pid}) — reloaded`)
+                : chalk.yellow(`Scheduler service enabled, but live reload is unavailable. Restart deliberately with: agents daemon restart`));
         }
         else if (result.pid) {
             console.log(chalk.green(`Scheduler started (PID: ${result.pid})`));
@@ -2193,25 +2204,31 @@ export function registerRoutinesCommands(program) {
     });
     routinesCmd
         .command('stop')
-        .description('Stop the background scheduler. Routines will not fire until you start it again.')
+        .description('Stop only the scheduler service. The shared daemon and its browser, secrets, usage, and monitoring services stay running.')
         .action(() => {
-        if (!isDaemonRunning()) {
-            console.log(chalk.yellow('Scheduler is not running'));
+        const daemonRunning = isDaemonRunning();
+        setDaemonServiceEnabled('scheduler', false);
+        if (daemonRunning && !signalDaemonReload()) {
+            console.log(chalk.yellow('Scheduler service disabled, but live reload is unavailable. It will stay off after the next daemon start.'));
             return;
         }
-        stopDaemon();
-        console.log(chalk.green('Scheduler stopped'));
+        console.log(daemonRunning
+            ? chalk.green('Scheduler service stopped; shared daemon is still running')
+            : chalk.yellow('Scheduler service disabled; shared daemon was already stopped'));
     });
     routinesCmd
         .command('status')
-        .description('Show scheduler status, enabled routines, and when each one fires next.')
-        .option('--json', 'Emit machine-readable scheduler + per-routine status (owner device, last fire, last error, in-flight run)')
+        .description('Show scheduler service state, shared-daemon state, enabled routines, and upcoming runs.')
+        .option('--json', 'Emit machine-readable scheduler service + device gate + daemon + per-routine status (owner device, last fire, last error, in-flight run)')
         .action((options) => {
         try {
             monitorRunningJobs();
         }
         catch { /* best-effort orphan reap */ }
         const status = getDaemonStatus();
+        const schedulerServiceEnabled = isDaemonServiceEnabled('scheduler');
+        const schedulerDeviceEnabled = isSchedulerEnabled();
+        const schedulerState = schedulerServiceEnabled && schedulerDeviceEnabled ? status.state : 'stopped';
         // The daemon-owned status surface (PHNX-3215): scheduler truth plus, per
         // routine, its single owner device, last fire outcome + error, and any
         // in-flight spawn — the fields `list --json` (definition-shaped) does not
@@ -2221,7 +2238,10 @@ export function registerRoutinesCommands(program) {
             writeJson({
                 device: machineId(),
                 scheduler: {
-                    state: status.state,
+                    state: schedulerState,
+                    serviceEnabled: schedulerServiceEnabled,
+                    deviceEnabled: schedulerDeviceEnabled,
+                    daemonState: status.state,
                     pid: status.pid,
                     binaryPath: status.binaryPath,
                     heartbeat: status.heartbeat
@@ -2238,12 +2258,13 @@ export function registerRoutinesCommands(program) {
             return;
         }
         console.log(chalk.bold('Scheduler\n'));
-        const stateLabel = status.state === 'running'
+        const stateLabel = schedulerState === 'running'
             ? chalk.green('running')
-            : status.state === 'wedged'
+            : schedulerState === 'wedged'
                 ? chalk.red('wedged')
                 : chalk.gray('stopped');
         console.log(`  Status:    ${stateLabel}`);
+        console.log(`  Daemon:    ${status.running ? chalk.green('running') : chalk.gray('stopped')}`);
         if (status.pid)
             console.log(`  PID:       ${status.pid}`);
         if (status.binaryPath)
@@ -2256,9 +2277,9 @@ export function registerRoutinesCommands(program) {
         const enabled = jobs.filter((j) => j.enabled);
         console.log(`  Routines:  ${enabled.length} enabled / ${jobs.length} total`);
         if (status.state === 'wedged') {
-            console.log(chalk.red('\n  The daemon is wedged (heartbeat stale). Restart with: agents routines stop && agents routines start'));
+            console.log(chalk.red('\n  The shared daemon is wedged (heartbeat stale). Restart deliberately with: agents daemon restart'));
         }
-        if (status.running && enabled.length > 0) {
+        if (schedulerState === 'running' && enabled.length > 0) {
             const scheduler = new JobScheduler(async () => { });
             scheduler.loadAll();
             const scheduled = scheduler.listScheduled();
@@ -2269,7 +2290,7 @@ export function registerRoutinesCommands(program) {
             }
             scheduler.stopAll();
         }
-        else if (!status.running && jobs.length > 0) {
+        else if (schedulerState !== 'running' && jobs.length > 0) {
             console.log(chalk.gray('\n  Start the scheduler to begin firing routines: agents routines start'));
         }
     });

package/dist/commands/send.js

@@ -2,7 +2,9 @@ import chalk from 'chalk';
 import { die } from '../lib/format.js';
 import { setHelpSections } from '../lib/help.js';
 import { readMeta } from '../lib/state.js';
-import { sendMessage } from '../lib/channels/send.js';
+import { sendMessage, isOwnerAlias } from '../lib/channels/send.js';
+import { composeOwnerMessage } from '../lib/owner-message.js';
+import { fireTraceSyncInBackground } from '../lib/run-trace-sync.js';
 function mergeAttachments(opts) {
     const list = [...(opts.attach ?? []), ...(opts.attachment ?? [])];
     return list.length ? list : undefined;
@@ -23,7 +25,28 @@ function toInput(positionalText, opts, ownerMode) {
 }
 async function runSend(positionalText, opts, ownerMode) {
     const meta = readMeta();
-    const out = await sendMessage(toInput(positionalText, opts, ownerMode), meta);
+    let input = toInput(positionalText, opts, ownerMode);
+    // An owner-bound ping (`agents notify`, `agents send --to owner`) goes through
+    // the SAME composer as an important `feed post` (PHNX-3698): short-shaped body,
+    // TEAM-N keys linkified, session crumb as a tappable console URL — instead of a
+    // raw dump. A non-owner send (explicit --channel/--to) is delivered verbatim.
+    if (ownerMode || isOwnerAlias(opts.to)) {
+        const flagged = opts.text?.trim() ?? '';
+        const positional = (positionalText ?? '').trim();
+        const raw = flagged || positional;
+        // When both forms are given and disagree, leave it to sendMessage to fail
+        // loud with the "pass the message once" error rather than composing a guess.
+        const bothDiffer = flagged !== '' && positional !== '' && flagged !== positional;
+        if (raw && !bothDiffer) {
+            input = { ...input, text: composeOwnerMessage(raw), positionalText: undefined };
+            // The console URL in the composed body only resolves once this session's
+            // trace shard is uploaded; fire that now so the tapped link isn't a 404.
+            // A --dry-run resolves + composes but MUST NOT act (its documented contract),
+            // so it never spawns the sync — it just shows what would be sent.
+            fireTraceSyncInBackground({ disabled: Boolean(opts.dryRun) });
+        }
+    }
+    const out = await sendMessage(input, meta);
     if ('error' in out) {
         die(out.error);
     }
@@ -127,6 +150,10 @@ export function registerSendCommand(program) {
       Set owner.channels + owner.policy.normal in humans.yaml once per fleet.
       Every channel listed in the normal policy receives an owner-addressed send.
 
+      Owner sends go through the same composer as "feed post": the body is
+      short-shaped, any TEAM-N key becomes a Linear URL, and the session crumb
+      becomes a tappable https://prix.dev/console/sessions/<id> link.
+
       ${SHARED_NOTES}
     `,
     });

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

@@ -13,5 +13,63 @@
  * `--pane`/`--pty` target a backend directly when the handle is already known.
  */
 import type { Command } from 'commander';
+import { type ActiveSession } from '../lib/session/active.js';
+interface InjectOptions {
+    pane?: string;
+    socket?: string;
+    pty?: string;
+    /**
+     * The remote device. A single `--device box` arrives here as `['box']` because
+     * the parent `sessions` command's variadic `-D, --device <target...>` shadows
+     * this subcommand's scalar option under `optsWithGlobals()` — normalize it with
+     * {@link normalizeInjectDevice} before use (PHNX-3688).
+     */
+    device?: string | string[];
+    enter?: boolean;
+    combined?: boolean;
+    json?: boolean;
+}
+/**
+ * Whether an active session is the one `sessions inject <token>` means. Matches
+ * a resolvable session id (exact or unique prefix) AND — for a tmux-hosted row
+ * whose full id never resolved (`sessionId` absent) — the `ag-<agent>-<shortid>`
+ * tmux name's `shortid` suffix (exact or prefix), the full tmux name, and the
+ * pane id. Those are the only selectors an id-less remote tmux row exposes, so
+ * without this an operator has no tool-native way to nudge it (PHNX-3688).
+ */
+export declare function matchInjectSelector(session: ActiveSession, token: string): boolean;
+/**
+ * The `--device` selector, normalized to a single host string. `optsWithGlobals()`
+ * merges the parent `sessions` command's variadic `-D, --device <target...>` over
+ * this subcommand's scalar `--device`, so a single `--device box` arrives as
+ * `['box']` — which flowed straight into `sshExec` and crashed on
+ * `host.startsWith` (PHNX-3688). Coerce the array to its one element; fail loud on
+ * several, since inject delivers to exactly one terminal (a fan-out spelling is a
+ * user error, not a first-of-list guess).
+ */
+export declare function normalizeInjectDevice(value: string | string[] | undefined): string | undefined;
+/**
+ * The `agents sessions inject` argv to re-run ON a device (its tmux panes live
+ * there, so resolution must happen there). Every flag rides along EXCEPT
+ * `--device`: the command runs on the device, resolving locally. Pure so the
+ * forwarded invocation is asserted without an SSH hop (PHNX-3688).
+ */
+export declare function buildRemoteInjectArgv(sessionId: string, text: string, options: InjectOptions): string[];
+/**
+ * Resolve `device` (registry alias or `user@host`) to an ssh target and re-run
+ * `agents sessions inject` there, so a bare session id + `--device` resolves on
+ * the box that actually holds the session's tmux panes. The tool-native form of
+ * the `agents ssh <device> "agents sessions inject <id> …"` workaround (PHNX-3688).
+ */
+/**
+ * Resolve `--device` to an ssh target. A registered device becomes its
+ * `user@dnsName`; a bare unknown name (an ad-hoc `user@host` or ssh_config alias)
+ * is handed to ssh verbatim (`resolveHost` returns null for it). A registered
+ * device we CANNOT dial — password-auth, addressless — throws its typed error and
+ * is NOT degraded to the raw name, which could ssh a coincidentally-matching but
+ * unrelated `~/.ssh/config` Host (PHNX-3688 review).
+ */
+export declare function resolveInjectSshTarget(device: string): Promise<string>;
 /** Attach the `inject` subcommand to an existing `sessions` command. */
 export declare function registerSessionsInjectCommand(sessionsCmd: Command): void;
+export {};

package/dist/commands/sessions-inject.js

@@ -13,14 +13,121 @@
  * `--pane`/`--pty` target a backend directly when the handle is already known.
  */
 import chalk from 'chalk';
-import { getActiveSessions } from '../lib/session/active.js';
+import { getActiveSessions, shortIdFromName } from '../lib/session/active.js';
 import { injectIntoTerminal, resolveInjectTargetForSession } from '../lib/terminal/index.js';
+import { sshExec, shellQuote } from '../lib/ssh-exec.js';
+import { resolveHost } from '../lib/hosts/registry.js';
+import { sshTargetFor } from '../lib/hosts/types.js';
 import { setHelpSections } from '../lib/help.js';
+/**
+ * Whether an active session is the one `sessions inject <token>` means. Matches
+ * a resolvable session id (exact or unique prefix) AND — for a tmux-hosted row
+ * whose full id never resolved (`sessionId` absent) — the `ag-<agent>-<shortid>`
+ * tmux name's `shortid` suffix (exact or prefix), the full tmux name, and the
+ * pane id. Those are the only selectors an id-less remote tmux row exposes, so
+ * without this an operator has no tool-native way to nudge it (PHNX-3688).
+ */
+export function matchInjectSelector(session, token) {
+    if (!token)
+        return false;
+    const sid = session.sessionId;
+    if (sid && (sid === token || sid.startsWith(token)))
+        return true;
+    const short = session.tmuxName ? shortIdFromName(session.tmuxName) : undefined;
+    if (short && (short === token || short.startsWith(token)))
+        return true;
+    if (session.tmuxName && session.tmuxName === token)
+        return true;
+    if (session.paneId && session.paneId === token)
+        return true;
+    return false;
+}
+/**
+ * The `--device` selector, normalized to a single host string. `optsWithGlobals()`
+ * merges the parent `sessions` command's variadic `-D, --device <target...>` over
+ * this subcommand's scalar `--device`, so a single `--device box` arrives as
+ * `['box']` — which flowed straight into `sshExec` and crashed on
+ * `host.startsWith` (PHNX-3688). Coerce the array to its one element; fail loud on
+ * several, since inject delivers to exactly one terminal (a fan-out spelling is a
+ * user error, not a first-of-list guess).
+ */
+export function normalizeInjectDevice(value) {
+    const list = value == null ? [] : Array.isArray(value) ? value : [value];
+    const hosts = list.map((v) => String(v).trim()).filter((v) => v.length > 0);
+    if (hosts.length === 0)
+        return undefined;
+    if (hosts.length > 1) {
+        throw new Error(`sessions inject targets a single device, but --device named ${hosts.length}: ${hosts.join(', ')}.`);
+    }
+    return hosts[0];
+}
+/**
+ * The `agents sessions inject` argv to re-run ON a device (its tmux panes live
+ * there, so resolution must happen there). Every flag rides along EXCEPT
+ * `--device`: the command runs on the device, resolving locally. Pure so the
+ * forwarded invocation is asserted without an SSH hop (PHNX-3688).
+ */
+export function buildRemoteInjectArgv(sessionId, text, options) {
+    const argv = ['agents', 'sessions', 'inject', sessionId, text];
+    if (options.enter === false)
+        argv.push('--no-enter');
+    if (options.combined)
+        argv.push('--combined');
+    if (options.socket)
+        argv.push('--socket', options.socket);
+    if (options.pty)
+        argv.push('--pty', options.pty);
+    if (options.pane)
+        argv.push('--pane', options.pane);
+    if (options.json)
+        argv.push('--json');
+    return argv;
+}
+/**
+ * Resolve `device` (registry alias or `user@host`) to an ssh target and re-run
+ * `agents sessions inject` there, so a bare session id + `--device` resolves on
+ * the box that actually holds the session's tmux panes. The tool-native form of
+ * the `agents ssh <device> "agents sessions inject <id> …"` workaround (PHNX-3688).
+ */
+/**
+ * Resolve `--device` to an ssh target. A registered device becomes its
+ * `user@dnsName`; a bare unknown name (an ad-hoc `user@host` or ssh_config alias)
+ * is handed to ssh verbatim (`resolveHost` returns null for it). A registered
+ * device we CANNOT dial — password-auth, addressless — throws its typed error and
+ * is NOT degraded to the raw name, which could ssh a coincidentally-matching but
+ * unrelated `~/.ssh/config` Host (PHNX-3688 review).
+ */
+export async function resolveInjectSshTarget(device) {
+    const host = await resolveHost(device);
+    return host ? sshTargetFor(host) : device;
+}
+async function injectOnDevice(sessionId, text, options, device) {
+    let target;
+    try {
+        target = await resolveInjectSshTarget(device);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (options.json)
+            console.log(JSON.stringify({ ok: false, error: message }));
+        else
+            console.error(chalk.red(message));
+        process.exit(1);
+    }
+    const remoteCmd = buildRemoteInjectArgv(sessionId, text, options).map(shellQuote).join(' ');
+    const res = sshExec(target, remoteCmd, { multiplex: true });
+    if (res.stdout)
+        process.stdout.write(res.stdout);
+    if (res.stderr)
+        process.stderr.write(res.stderr);
+    if (res.code !== 0)
+        process.exit(res.code ?? 1);
+}
 /** Resolve a session id (short or full) to an addressable terminal target, via the
  * same resolver the watchdog uses so both agree on what is reachable. */
 async function resolveTarget(sessionId) {
     const sessions = await getActiveSessions();
-    const match = sessions.find((s) => s.sessionId === sessionId || (s.sessionId != null && s.sessionId.startsWith(sessionId)));
+    const match = sessions.find((s) => matchInjectSelector(s, sessionId));
     if (!match)
         return { target: null, reason: `No active session matches "${sessionId}".` };
     const resolution = resolveInjectTargetForSession(match);
@@ -35,8 +142,21 @@ async function resolveTarget(sessionId) {
     return { target: resolution.target };
 }
 async function runInject(sessionId, text, options) {
+    let device;
+    try {
+        device = normalizeInjectDevice(options.device);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (options.json)
+            console.log(JSON.stringify({ ok: false, error: message }));
+        else
+            console.error(chalk.red(message));
+        process.exit(1);
+    }
     // Direct-target shortcuts skip the session lookup — the watchdog often already
-    // holds the pane id or pty session it wants to type into.
+    // holds the pane id or pty session it wants to type into. The pane's exact
+    // address is known, so it composes with --device (tmux send-keys over SSH).
     let target = null;
     if (options.pty) {
         target = { backend: 'pty', id: options.pty };
@@ -44,6 +164,12 @@ async function runInject(sessionId, text, options) {
     else if (options.pane) {
         target = { backend: 'tmux', pane: options.pane, socket: options.socket };
     }
+    else if (device) {
+        // A bare session id + a device: the session's tmux panes live ON that device,
+        // so getActiveSessions here can't see them. Resolve + deliver THERE by re-running
+        // inject over SSH (the same command, minus --device) — PHNX-3688.
+        return injectOnDevice(sessionId, text, options, device);
+    }
     else {
         const resolved = await resolveTarget(sessionId);
         if (!resolved.target) {
@@ -60,7 +186,7 @@ async function runInject(sessionId, text, options) {
         enter: options.enter !== false,
         combined: options.combined,
         socket: options.socket,
-        host: options.device,
+        host: device,
     });
     if (options.json) {
         console.log(JSON.stringify(res));
@@ -82,7 +208,7 @@ export function registerSessionsInjectCommand(sessionsCmd) {
         .option('--pane <id>', 'Target a tmux pane id directly (e.g. %3), skipping session lookup')
         .option('--pty <id>', 'Target an agents-pty session id directly, skipping session lookup')
         .option('--socket <path>', 'tmux socket path (defaults to the session/shared socket)')
-        .option('--device <target>', 'Deliver on a remote device over SSH (tmux/AppleScript backends)')
+        .option('--device <target>', 'Deliver on a remote device over SSH. With a bare session id, the session is resolved ON that device; with --pane, the pane is addressed there directly.')
         .option('--no-enter', 'Send only the text, without a trailing Enter')
         .option('--combined', 'Fuse text + Enter into ONE write (default: two writes, Ink-TUI safe)')
         .option('--json', 'Output the InjectResult as JSON');
@@ -96,6 +222,12 @@ export function registerSessionsInjectCommand(sessionsCmd) {
 
       # Type into an agents-pty session without submitting
       agents sessions inject _ "ls" --pty $SID --no-enter
+
+      # Nudge a live session on another box (resolved on the device)
+      agents sessions inject 214edaae "continue" --device yosemite-s0
+
+      # Address a known remote pane directly (skips lookup, sends over SSH)
+      agents sessions inject _ "continue" --pane %122 --socket $SOCK --device yosemite-s0
     `,
         notes: `
       - Ink-TUI Enter semantics: by default the text and Enter are two separate
@@ -103,8 +235,12 @@ export function registerSessionsInjectCommand(sessionsCmd) {
       - A session is addressable by id when it resolves to a precise split —
         tmux, iTerm, a VSCodium/Cursor/VS Code integrated terminal, or a pty
         (resolveInjectTargetForSession). Use --pane/--pty for direct targeting.
-      - Built on the Terminal Engine (src/lib/terminal): --device runs the tmux /
-        AppleScript spec over the same SSH transport the launch engine uses.
+      - The id may be the session id (short or full) OR the '<shortid>' suffix of
+        a tmux target (ag-<agent>-<shortid>) — the only selector a live tmux
+        session whose id column shows '-' exposes.
+      - Built on the Terminal Engine (src/lib/terminal): with --pane, --device
+        runs the tmux send-keys spec over SSH; with a bare id, --device re-runs
+        the lookup on that box (its tmux panes live there, not here).
     `,
     });
     // The parent `sessions` command also defines --json, so it binds there;

package/dist/commands/sessions-optimize.js

@@ -35,7 +35,7 @@ export function registerSessionsOptimizeCommand(sessionsCmd) {
         notes: `
       - FTS5 appends a segment on every insert and tombstones every delete; the scanner delete+inserts a session's docs on each rescan and never self-merges, so \`tool_call_text_data\` / \`session_text_data\` bloat with unmerged segments — GBs of index for tens of MB of content, and queries slow down.
       - This runs FTS5 \`'optimize'\`: it merges every segment into one and purges tombstones. Non-destructive — no searchable content is lost.
-      - Reclaimed space becomes reusable free pages inside the DB file. To return it to the OS, stop the daemon (\`agents routines stop\`) and run \`VACUUM\` against \`~/.agents/.history/sessions/sessions.db\`.
+      - Reclaimed space becomes reusable free pages inside the DB file. To return it to the OS, use the operator lifecycle command \`agents daemon stop\`, run \`VACUUM\` against \`~/.agents/.history/sessions/sessions.db\`, then \`agents daemon start\`. \`agents routines stop\` disables only the scheduler service.
     `,
     });
 }

package/dist/commands/sessions-picker.js

@@ -104,6 +104,7 @@ function sanitizeMeta(s) {
         version: clean(s.version),
         account: clean(s.account),
         topic: clean(s.topic),
+        firstUserMessage: clean(s.firstUserMessage),
         label: clean(s.label),
         ticketId: clean(s.ticketId),
         prUrl: clean(s.prUrl),

package/dist/commands/sessions.js

@@ -53,7 +53,7 @@ import { itemPicker } from '../lib/picker.js';
 import { resolveSessionAlias } from '../lib/session/actor-sidecar.js';
 import { listInstalledVersions, resolveVersionAliasLoose } from '../lib/installations/versions.js';
 import { getAgentsInvocation } from '../lib/daemon/daemon.js';
-import { sessionRecoveryRunArgs } from '../lib/session/recovery.js';
+import { sessionAgentSupportsResume, sessionRecoveryRunArgs } from '../lib/session/recovery.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { sessionPicker, buildPreview, loadSessionPreviewDigest, transcriptOnPeerOf, formatTodoCompact, githubRepoUrlFromCwd, } from './sessions-picker.js';
 import { setHelpSections } from '../lib/help.js';
@@ -4062,6 +4062,8 @@ function versionedAliasIfPresent(agent, version) {
     return null;
 }
 export function buildResumeCommand(session) {
+    if (!sessionAgentSupportsResume(session.agent))
+        return null;
     switch (session.agent) {
         // opencode sessions are shared across versions, so resume is deliberately NOT
         // version-pinned — it always goes through the plain launcher.
@@ -4079,16 +4081,7 @@ export function buildResumeCommand(session) {
             }
             return resumeArgv(session.agent, session.id, cli);
         }
-        case 'gemini':
-        case 'antigravity':
-        case 'openclaw':
-        case 'rush':
-        case 'hermes':
-        case 'grok':
-        case 'kimi':
-        case 'droid':
-        case 'cursor':
-            // Grok (and some others) sessions are captured artifacts, not resumable the same way.
+        default:
             return null;
     }
 }

package/dist/commands/share.d.ts

@@ -80,7 +80,9 @@ export declare function runShareEdit(target: string, opts: {
     removeMeta?: string[];
     /** Change the page's visibility in place (public | unlisted | me | org).
      * A metadata-only rewrite like label/meta — the body is untouched, so no
-     * revision is created. me/org require a Phoenix session. */
+     * revision is created. me/org require a Phoenix session. `private` is
+     * rejected here — token-gating needs a fresh viewer key only the publish
+     * path mints (PHNX-3654). */
     visibility?: ShareVisibility;
     force?: boolean;
     fetchEdit?: typeof fetch;
@@ -116,7 +118,7 @@ export declare function runShareList(opts?: {
     /** Visibility filter. `public` (default) lists only public gallery pages;
      * `unlisted`/`me`/`org` include that owner's hidden pages; `all` includes
      * every active page. Hidden scopes send the owner's bearer and `scope=mine`. */
-    scope?: 'public' | 'unlisted' | 'me' | 'org' | 'all';
+    scope?: 'public' | 'unlisted' | 'private' | 'me' | 'org' | 'all';
 }): Promise<ShareListResult>;
 /** Client-side filtering over an already-fetched listing (RUSH-2683) — the
  * Worker has no query surface for this, so it narrows the fetched set instead
@@ -127,7 +129,7 @@ export declare function applyShareListFilters(result: ShareListResult, filters:
     session?: string;
     label?: string;
     meta?: Record<string, string>;
-    scope?: 'public' | 'unlisted' | 'me' | 'org' | 'all';
+    scope?: 'public' | 'unlisted' | 'private' | 'me' | 'org' | 'all';
 }): ShareListResult;
 export declare function formatShareList(result: ShareListResult, json?: boolean): string;
 /** One retained prior version of a slug, as reported by the Worker's