@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/commands/computer.js

@@ -47,7 +47,6 @@ 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.
 const COMPUTER_HELP_GROUPS = [
     { title: 'Installation', names: ['setup'] },
     { title: 'Daemon lifecycle', names: ['start', 'stop', 'reload', 'status'] },
@@ -56,14 +55,6 @@ const COMPUTER_HELP_GROUPS = [
     { title: 'Interact', names: ['launch', 'raise', 'click', 'right-click', 'type', 'type-text', 'key', 'drag', 'scroll', 'ax-action', 'focus', 'wait'] },
     { title: 'History and discovery', names: ['sessions'] },
 ];
-/**
- * The verb catalog. Descriptions are the consumer's (they appear in
- * `agents computer --help`); flags are the engine's.
- *
- * This list is the contract with the engine: `computer --verbs` must report the
- * same names. `computer.test.ts` pins it so a drift shows up as a failing test
- * rather than a verb that quietly stops existing.
- */
 export const COMPUTER_PASSTHROUGH_VERBS = [
     { name: 'run', description: 'Autonomously drive an app from a natural-language task (model loop over the computer verbs)' },
     { name: 'apps', description: 'List running apps the policy allows, with pid and bundle id' },
@@ -83,37 +74,17 @@ export const COMPUTER_PASSTHROUGH_VERBS = [
     { name: 'focus', description: 'Move keyboard focus to an element' },
     { name: 'wait', description: 'Wait for an element or condition to appear before continuing' },
 ];
-/**
- * Pure platform gate. The computer subsystem is macOS-only for LOCAL driving
- * (Accessibility / launchctl). It is NOT blocked off macOS when a remote daemon
- * is reachable — either a configured TCP endpoint (COMPUTER_HELPER_TCP, e.g. a
- * Windows daemon over a tunnel) or a `--device <name>` remote invocation. Kept
- * pure so the gating rule is unit-testable without a live command tree.
- */
 export function shouldBlockOffPlatform(opts) {
     if (opts.platform === 'darwin')
         return false;
     if (opts.tcpConfigured)
-        return false; // remote (Windows) daemon over a tunnel
+        return false;
     if (opts.vncConfigured)
-        return false; // RFB/VNC desktop (Linux GUI over the wire)
+        return false;
     if (opts.device)
-        return false; // remote path resolves its own endpoint
+        return false;
     return true;
 }
-/**
- * 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. 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 withHostFlag(argv, host) {
     if (!host)
         return argv;
@@ -122,30 +93,13 @@ export function withHostFlag(argv, host) {
     const [verb, ...rest] = argv;
     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 {
@@ -162,13 +116,6 @@ export async function resolveDeviceHost(device) {
         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.
- *
- * 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.
- */
 async function forwardToComputer(opts) {
     let bin;
     try {
@@ -184,9 +131,6 @@ async function forwardToComputer(opts) {
     const hostFlag = opts.argv.findIndex(arg => arg === '--host' || arg.startsWith('--host='));
     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;
@@ -202,7 +146,6 @@ async function forwardToComputer(opts) {
             : (event) => recordComputerAction(event, { device: opts.device }),
     });
 }
-/** Forward, then exit with the engine's status so shells and agents see the truth. */
 async function forwardAndExit(opts) {
     const { exitCode } = await forwardToComputer(opts);
     if (exitCode !== 0)
@@ -212,17 +155,10 @@ export function registerComputerCommand(program) {
     const computer = program
         .command('computer')
         .description('Drive macOS apps via Accessibility, a Linux GUI desktop with --vnc, or a remote Windows device with --device — screenshot, click, type')
-        // A VNC/RFB desktop is driven over the wire (--vnc host:port, e.g. an x11vnc
-        // server on a headless Linux box or an LXD container). Set it before the gate.
         .option('--vnc <host:port>', 'Drive a GUI desktop over VNC/RFB (x11vnc/Xvnc; port defaults to 5901) instead of a native helper')
         .option('--vnc-password <password>', 'VNC password for --vnc (or set COMPUTER_HELPER_VNC_PASSWORD)')
-        // The whole subsystem is macOS Accessibility / TCC for LOCAL driving. Off
-        // macOS it still works against a remote daemon (COMPUTER_HELPER_TCP set, a
-        // --vnc desktop, or a `--device <name>` invocation). Fail fast with a clear
-        // message only when no remote path is available, instead of a downstream error.
         .hook('preAction', async (_thisCommand, actionCommand) => {
         const globals = actionCommand.optsWithGlobals();
-        // --vnc selects the RFB transport for every verb under this command.
         if (globals.vnc) {
             process.env.COMPUTER_HELPER_VNC = globals.vnc;
             if (globals.vncPassword)
@@ -289,13 +225,6 @@ function registerComputerSubcommands(program) {
     registerSessionsCommand(program);
     registerCommandGroups(program, COMPUTER_HELP_GROUPS);
 }
-/**
- * Register every plain verb as an opaque forwarder.
- *
- * `allowUnknownOption` is what makes this thin: commander stops trying to parse
- * flags it does not own and hands them through in `cmd.args`, so the engine's
- * flag surface can grow without a matching edit here.
- */
 function registerPassthroughVerbs(program) {
     for (const verb of COMPUTER_PASSTHROUGH_VERBS) {
         program
@@ -344,8 +273,6 @@ function registerStopCommand(program) {
         .allowExcessArguments(true)
         .helpOption(false)
         .action(async (opts, cmd) => {
-        // The engine owns both halves of a remote stop — the tunnel it opened and
-        // the scheduled task it registered — and reports each one itself.
         await forwardAndExit({ argv: ['stop', ...cmd.args], device: opts.device, record: false });
     });
 }
@@ -358,10 +285,6 @@ function registerReloadCommand(program) {
         .allowExcessArguments(true)
         .helpOption(false)
         .action(async (opts, cmd) => {
-        // Reload EXISTS to re-render the allow list; doing it before the signal is
-        // the whole command. A `--device` reload bounces the remote daemon, which
-        // enforces no allow list — rendering (and printing) this machine's would
-        // claim a policy that device never reads.
         await forwardAndExit({ argv: ['reload', ...cmd.args], device: opts.device, record: false });
     });
 }
@@ -375,10 +298,6 @@ function registerStatusCommand(program) {
         .helpOption(false)
         .action(async (opts, cmd) => {
         const json = cmd.args.includes('--json');
-        // The allow list is agents-cli's answer, not the engine's — report it here
-        // so `status` stays the one place that tells you why an app is refused. It
-        // governs the LOCAL helper only: the Windows daemon enforces none, and the
-        // engine reports that device's target, transport and liveness itself.
         if (!json && !opts.device) {
             const allowed = loadComputerAllowList();
             const preview = allowed.slice(0, 5).join(', ');
@@ -389,10 +308,6 @@ function registerStatusCommand(program) {
         await forwardAndExit({ argv: ['status', ...cmd.args], device: opts.device, record: false });
     });
 }
-// sessions — task-first history over the computer.action event ledger (RUSH-2432),
-// the computer counterpart of `agents browser sessions` (RUSH-2407). `agents
-// sessions --computer` (sessions.ts) routes to the same runComputerSessionsCommand.
-// It reads agents-cli's own ledger, so it never reaches the engine.
 function registerSessionsCommand(program) {
     program
         .command('sessions')
@@ -405,34 +320,17 @@ function registerSessionsCommand(program) {
         await runComputerSessionsCommand({ machine: opts.machine, limit: opts.limit, json: opts.json, interactive: opts.interactive });
     });
 }
-/**
- * Install the macOS helper through the engine. Used by the `agents setup
- * computer` wizard, which still owns the TCC hand-holding — that is a
- * conversation with the user, not a daemon operation.
- */
 export async function installComputerHelperMacLocal() {
     const { exitCode } = await forwardToComputer({ argv: ['setup'], record: false });
     if (exitCode !== 0)
         throw new Error(`\`computer setup\` failed (exit ${exitCode})`);
 }
-/**
- * Activate the local daemon through the engine and report whether Accessibility
- * trust is granted, so the wizard knows whether to walk the user to System
- * Settings.
- */
 export async function activateComputerHelperMacLocal() {
     const { exitCode } = await forwardToComputer({ argv: ['start'], record: false });
     if (exitCode !== 0)
         throw new Error(`\`computer start\` failed (exit ${exitCode})`);
     return { trusted: await probeComputerTrust() };
 }
-/**
- * Read `trusted` out of `computer status --json`.
- *
- * Tolerant by construction: the engine may print a banner line before its JSON,
- * so scan for the first parseable object rather than assuming the whole stream
- * is JSON. Pure, so the parsing contract is testable without a daemon.
- */
 export function parseTrustFromStatusJson(stdout) {
     const start = stdout.indexOf('{');
     if (start < 0)
@@ -445,15 +343,6 @@ export function parseTrustFromStatusJson(stdout) {
         return false;
     }
 }
-/**
- * Probe Accessibility trust without re-activating. Returns false (never throws)
- * when the engine is absent, the daemon is down, or the probe errors — the
- * wizard polls this while the user grants permissions in System Settings, and a
- * throw there would abort the very flow that fixes it.
- *
- * This is the ONE place agents-cli reads engine stdout instead of passing it
- * through, because it needs an answer rather than a display.
- */
 export async function probeComputerTrust() {
     try {
         const { exitCode, stdout } = await forwardToComputer({

package/dist/commands/config.d.ts

@@ -1,16 +1,2 @@
-/**
- * Unified configuration command barrel.
- *
- * `agents config` consolidates the fragmented config surface into one namespace:
- *   - run defaults (model, mode, effort)
- *   - tier overrides (folded into the run namespace)
- *   - interactive host
- *   - browser profile
- *   - local projects root
- *   - per-device config keys
- *
- * The underlying YAML schema is unchanged; this command translates the new key
- * grammar into reads/writes of the existing stores.
- */
 import type { Command } from 'commander';
 export declare function registerConfigCommand(program: Command): void;

package/dist/commands/config.js

@@ -1,17 +1,3 @@
-/**
- * Unified configuration command barrel.
- *
- * `agents config` consolidates the fragmented config surface into one namespace:
- *   - run defaults (model, mode, effort)
- *   - tier overrides (folded into the run namespace)
- *   - interactive host
- *   - browser profile
- *   - local projects root
- *   - per-device config keys
- *
- * The underlying YAML schema is unchanged; this command translates the new key
- * grammar into reads/writes of the existing stores.
- */
 import chalk from 'chalk';
 import { AGENTS } from '../lib/agents.js';
 import { setHelpSections } from '../lib/help.js';
@@ -25,7 +11,6 @@ import { MODEL_TIERS } from '../lib/model-tiers.js';
 import { machineId } from '../lib/machine-id.js';
 import { getProjectRoot, setProjectRoot } from '../lib/project-root.js';
 import { rawAgentAutoUpdateSetting, rawGlobalAutoUpdateSetting, setAgentAutoUpdateEnabled, setGlobalAutoUpdateEnabled, unsetAgentAutoUpdateEnabled, unsetGlobalAutoUpdateEnabled, } from '../lib/installations/update-policy.js';
-/** Parse a boolean value the same way `agents devices configure` does. */
 function parseBool(value, key) {
     const v = value.trim().toLowerCase();
     if (v === 'on' || v === 'true')
@@ -34,7 +19,22 @@ function parseBool(value, key) {
         return false;
     throw new Error(`Config key '${key}' expects a boolean ('on' or 'off'), got '${value}'.`);
 }
-/** Parse the value for a given key, enforcing type rules. */
+function parseStringList(raw, key) {
+    const text = raw.trim();
+    if (!text.startsWith('['))
+        return text.split(',').map((item) => item.trim());
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Config key '${key}' expects a JSON array of strings or comma-separated items, got '${raw}'.`);
+    }
+    if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== 'string')) {
+        throw new Error(`Config key '${key}' expects a JSON array of strings, got '${raw}'.`);
+    }
+    return parsed;
+}
 function parseValue(key, parsed, raw) {
     switch (parsed.scope) {
         case 'run':
@@ -52,8 +52,6 @@ function parseValue(key, parsed, raw) {
         case 'updates':
             return parseBool(raw, key);
         case 'menubar': {
-            // The type (and enum validation) live in the device-config spec; parse the
-            // raw string to that type here so setConfigValue's assertion passes.
             const spec = configKeySpec(formatConfigKey(parsed));
             if (spec.type === 'bool')
                 return parseBool(raw, key);
@@ -63,6 +61,8 @@ function parseValue(key, parsed, raw) {
                 }
                 return Number.parseInt(raw.trim(), 10);
             }
+            if (spec.type === 'string-list')
+                return parseStringList(raw, key);
             return raw.trim();
         }
         case 'device': {
@@ -95,17 +95,11 @@ function parseValue(key, parsed, raw) {
                 case 'computer.host':
                     return raw.trim();
             }
-            // A device property with no arm above used to fall out of the switch and
-            // return `undefined`, so the write failed downstream with "expects a
-            // boolean, got undefined" instead of naming the real gap. The `never`
-            // binding makes adding a DeviceConfigProperty without a parse rule a
-            // compile error rather than a runtime mystery.
             const unhandled = property;
             throw new Error(`Config key '${key}' has no parse rule for device property '${String(unhandled)}'.`);
         }
     }
 }
-/** Write a value for a parsed config key. */
 function setConfig(parsed, value) {
     switch (parsed.scope) {
         case 'run': {
@@ -135,14 +129,9 @@ function setConfig(parsed, value) {
         }
         case 'browser': {
             if (parsed.property === 'device') {
-                // Fleet hub: user scope, one central value, never peer-targeted.
                 setConfigValue('browser.device', value);
                 return;
             }
-            // Device-local default lives in the per-device doc's config: block
-            // (same store `agents devices config` / getConfigValue use). Bare
-            // browser.profile targets this machine; devices.<name>.browser.profile
-            // targets a peer.
             setConfigValue(parsed.property === 'viewer' ? 'browser.viewer' : 'browser.profile', value, parsed.device ? { device: parsed.device } : undefined);
             return;
         }
@@ -177,7 +166,6 @@ function setConfig(parsed, value) {
         }
     }
 }
-/** Unset a parsed config key. */
 function unsetConfig(parsed) {
     switch (parsed.scope) {
         case 'run': {
@@ -204,9 +192,6 @@ function unsetConfig(parsed) {
                 return had;
             }
             const target = parsed.device ? { device: parsed.device } : undefined;
-            // Must follow parsed.property. Hardcoding 'browser.profile' here meant
-            // `config unset browser.viewer` deleted the user's browser.profile while
-            // printing success, and left browserViewer in place.
             const name = parsed.property === 'viewer' ? 'browser.viewer' : 'browser.profile';
             const had = getConfigValue(name, target).value !== undefined;
             unsetConfigValue(name, target);
@@ -214,11 +199,6 @@ function unsetConfig(parsed) {
         }
         case 'project': {
             const had = getProjectRoot() !== undefined;
-            // `projectRoot` is a machine-local key that `writeMeta` persists to the
-            // device doc; it only clears that doc when the key is PRESENT-but-falsy
-            // (`writesProjectRoot` needs the own-property, state.ts). Dropping the key
-            // from the returned object left the device-doc value in place, so
-            // `config get` still returned it after unset. Set it undefined instead.
             updateMeta((meta) => ({ ...meta, projectRoot: undefined }));
             return had;
         }
@@ -252,7 +232,6 @@ function unsetConfig(parsed) {
         }
     }
 }
-/** Read the stored value for a parsed config key. */
 function getConfig(parsed) {
     switch (parsed.scope) {
         case 'run': {
@@ -286,7 +265,6 @@ function getConfig(parsed) {
         }
     }
 }
-/** Format a config value for display. */
 function formatValue(value) {
     if (value === undefined)
         return chalk.gray('(unset)');
@@ -294,7 +272,6 @@ function formatValue(value) {
         return value ? chalk.green('true') : chalk.red('false');
     return chalk.cyan(JSON.stringify(value));
 }
-/** Collect all set config entries for a given device scope (self or peer). */
 function* listRunConfigEntries() {
     const meta = readMeta();
     for (const [selector, defaults] of Object.entries(meta.run?.defaults ?? {})) {
@@ -324,7 +301,6 @@ function* listRunConfigEntries() {
         }
     }
 }
-/** Collect central non-run config entries. */
 function* listCentralConfigEntries() {
     const meta = readMeta();
     if (meta.config?.interactiveHost !== undefined) {
@@ -336,8 +312,6 @@ function* listCentralConfigEntries() {
     if (meta.projectRoot !== undefined) {
         yield { key: 'project.root', value: meta.projectRoot, hint: 'devices.<self>.projectRoot' };
     }
-    // This machine's default browser profile lives in fleet.devices.<self>.config
-    // (device-config), not the legacy top-level Meta.defaultBrowserProfile field.
     const browserProfile = getConfigValue('browser.profile').value;
     if (browserProfile !== undefined) {
         const key = 'browser.profile';
@@ -348,21 +322,17 @@ function* listCentralConfigEntries() {
         const key = 'browser.viewer';
         yield { key, value: browserViewer, hint: configKeyStorageHint(parseConfigKey(key)) };
     }
-    // Fleet browser hub — user scope, so it belongs in the central listing next to
-    // its siblings. Omitting it repeats the browser.viewer invisibility bug.
     const browserDevice = getConfigValue('browser.device').value;
     if (browserDevice !== undefined) {
         const key = 'browser.device';
         yield { key, value: browserDevice, hint: configKeyStorageHint(parseConfigKey(key)) };
     }
-    // Session-summarizer keys (PHNX-3939) — user scope, syncs fleet-wide.
     for (const key of ['summarizer.enabled', 'summarizer.baseUrl', 'summarizer.model']) {
         const value = getConfigValue(key).value;
         if (value !== undefined) {
             yield { key, value, hint: configKeyStorageHint(parseConfigKey(key)) };
         }
     }
-    // Managed-harness auto-update switches (PHNX-3940) — user scope, syncs fleet-wide.
     const globalAutoUpdate = rawGlobalAutoUpdateSetting();
     if (globalAutoUpdate !== undefined) {
         yield { key: 'updates.auto', value: globalAutoUpdate, hint: configKeyStorageHint(parseConfigKey('updates.auto')) };
@@ -374,8 +344,6 @@ function* listCentralConfigEntries() {
             yield { key, value, hint: configKeyStorageHint(parseConfigKey(key)) };
         }
     }
-    // AGI Menu preferences (PHNX-3999) — user scope, syncs fleet-wide. Only set
-    // keys are listed; the native menu falls back to its own defaults for the rest.
     for (const prop of MENUBAR_MENU_PROPERTIES) {
         const key = `menubar.menu.${prop}`;
         const value = getConfigValue(key).value;
@@ -384,7 +352,6 @@ function* listCentralConfigEntries() {
         }
     }
 }
-/** Collect device-scope config entries. */
 function* listDeviceConfigEntries(device) {
     for (const entry of listConfig({ device })) {
         if (entry.value === undefined)
@@ -420,14 +387,11 @@ function* listDeviceConfigEntries(device) {
                 key = `${prefix}formFactor`;
                 break;
             case 'browser.profile':
-                // The self device's default browser profile is already surfaced as the
-                // top-level `browser.profile` key; skip it here to avoid duplication.
                 if (device === machineId())
                     continue;
                 key = `${prefix}browser.profile`;
                 break;
             case 'browser.viewer':
-                // Same duplication rule as browser.profile above.
                 if (device === machineId())
                     continue;
                 key = `${prefix}browser.viewer`;
@@ -436,12 +400,6 @@ function* listDeviceConfigEntries(device) {
                 key = `${prefix}computer.host`;
                 break;
             default:
-                // A `default: continue` here silently drops any device property with no
-                // arm — which is how browser.viewer was invisible to `config list` after
-                // being added everywhere else. This is the fourth switch enumerating
-                // DeviceConfigProperty; unlike parseValue's it cannot use a `never`
-                // binding (it must keep skipping properties that are deliberately not
-                // listed), so the completeness test in config.test.ts is the guard.
                 continue;
         }
         yield { key, value: entry.value, hint: configKeyStorageHint(parseConfigKey(key)) };
@@ -463,6 +421,8 @@ export function registerConfigCommand(program) {
       agents config set devices.mac-mini.max-agents 4
       agents config set updates.auto off
       agents config set updates.claude.auto off
+      agents config set menubar.menu.tabOrder home,projects,sessions,inbox
+      agents config set menubar.menu.pinnedProjects '["Rush","AGI Menu"]'
       agents config get run.claude@*.model
       agents config unset run.claude@*.tier.best
       agents config list
@@ -473,6 +433,7 @@ export function registerConfigCommand(program) {
       Every agent/harness reference uses agent@version. Use * for all versions.
       Tier overrides are part of the run namespace: run.<agent@version>.tier.<tier>.
       Project root is auto-inferred from the current Git repository when unset.
+      A list key takes the whole list: comma-separated, or a JSON array for names with commas.
       Spend caps live under \`agents config budget\` (not a top-level command).
     `,
     });

package/dist/commands/cost.d.ts

@@ -1,13 +1,2 @@
-/**
- * Cost command — roll up $ spend and wall-clock duration across the local,
- * cross-agent session index.
- *
- * This is the read side of issue #323. Cost and duration are computed and
- * persisted at scan time (see src/lib/session/discover.ts + db.ts); this
- * command only queries and renders them — a pure SQLite/CLI win, no server,
- * no telemetry. Distinct from `agents view`, which reports live rate-limit /
- * quota status per agent and is left untouched.
- */
 import type { Command } from 'commander';
-/** Register `agents insights cost` under the insights parent. */
 export declare function registerCostCommand(insightsCmd: Command): void;

package/dist/commands/cost.js

@@ -3,10 +3,9 @@ import chalk from 'chalk';
 import { discoverSessions, parseTimeFilter } from '../lib/session/discover.js';
 import { queryUsageRollup, topSessionsByCost, } from '../lib/session/db.js';
 import { formatUsd, PRICING_VERSION } from '../lib/pricing/index.js';
-import { formatDuration } from '../lib/session/render.js';
+import { formatDuration } from '@phnx-labs/sessions-cli/reader';
 import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
 import { sessionHeadline } from '../lib/session/title.js';
-/** Register `agents insights cost` under the insights parent. */
 export function registerCostCommand(insightsCmd) {
     addHostOption(insightsCmd.command('cost'))
         .description('Roll up $ cost and duration across local agent sessions')
@@ -23,17 +22,10 @@ Examples:
 
 Cost is computed offline from a versioned per-model price table (${PRICING_VERSION}).
 `)
-        // Read opts via optsWithGlobals(): `--json`/`--since`/`--by` collide by name
-        // with the `insights` parent's own options, so commander binds them to the
-        // parent at parse time and the leaf's plain opts() never sees them. Merging
-        // ancestor opts is what the sibling `insights mix` recipes already do
-        // (mix-commands.ts) — without it every flag on this command is silently
-        // dropped (e.g. `agents insights cost --json` printed the human table).
         .action(async (_options, command) => {
         await costAction(command.optsWithGlobals());
     });
 }
-/** Map the --by flag to a rollup group, rejecting unknown values. */
 function resolveGroup(by) {
     if (by === undefined)
         return 'agent';
@@ -44,7 +36,6 @@ function resolveGroup(by) {
 }
 async function costAction(options) {
     const sinceMs = options.since ? parseTimeFilter(options.since) : undefined;
-    // Ensure the index is fresh (and migrated to v6) before we read costs.
     await discoverSessions({ all: true, since: options.since, limit: 1 });
     const filter = {};
     if (typeof sinceMs === 'number')
@@ -85,13 +76,11 @@ async function costAction(options) {
     out.push(`  ${chalk.green(formatUsd(totalCost))} across ${totalSessions} session${totalSessions !== 1 ? 's' : ''}` +
         (totalDuration > 0 ? chalk.gray(`  ·  ${formatDuration(totalDuration)} total`) : ''));
     out.push('');
-    // Daily histogram (unicode block sparkline, zero deps).
     if (daily.length > 0) {
         out.push(chalk.bold('Daily'));
         out.push(renderDailyHistogram(daily));
         out.push('');
     }
-    // Top sessions by cost.
     if (top.length > 0) {
         out.push(chalk.bold('Top sessions by cost'));
         const cols = terminalWidth();
@@ -109,7 +98,6 @@ async function costAction(options) {
         }
         out.push('');
     }
-    // Per-agent / per-project / per-day breakdown.
     const groupLabel = groupBy === 'agent' ? 'agent'
         : groupBy === 'project' ? 'project'
             : groupBy === 'account' ? 'account'
@@ -132,11 +120,8 @@ async function costAction(options) {
     }
     console.log(out.join('\n'));
 }
-/** Eight levels of vertical block characters for sparkline rendering. */
 const BLOCKS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
-/** Render a per-day cost histogram as a unicode sparkline plus a labeled list. */
 function renderDailyHistogram(daily) {
-    // Daily comes back cost-desc; show it chronologically for the sparkline.
     const sorted = [...daily].sort((a, b) => a.key.localeCompare(b.key));
     const max = Math.max(...sorted.map(d => d.costUsd), 0);
     const spark = sorted
@@ -148,7 +133,6 @@ function renderDailyHistogram(daily) {
     })
         .join('');
     const lines = [`  ${chalk.green(spark)}`];
-    // Show the most expensive days as a short list under the sparkline.
     const topDays = [...daily].slice(0, 7);
     const costW = Math.max(...topDays.map(d => formatUsd(d.costUsd).length), 4);
     for (const d of topDays) {

package/dist/commands/daemon-test-harness.d.ts

@@ -1,42 +1,10 @@
-/**
- * Shared harness for the `agents daemon` CLI subprocess suites (RUSH-2354).
- *
- * Every test spawns the real CLI against an isolated mkdtemp HOME with no
- * daemon running — no mocks. Modeled on routines.test.ts.
- *
- * EXTRACTED so the suite can live in several files. `daemon.test.ts` was 35
- * tests in ONE file at 159s — the slowest file in the repo and therefore the
- * SUITE'S FLOOR, because vitest parallelises across files and runs the tests
- * inside one file sequentially in a single worker. Splitting the tests across
- * files lets them run concurrently; sharing the harness is what makes that
- * possible without duplicating the spawn plumbing.
- */
 import { spawnSync, type ChildProcess } from 'child_process';
 export declare const REPO_ROOT: string;
 export declare const TSX_IMPORT: string;
 export declare const CLI_ENTRYPOINT: string;
-/**
- * win32: subprocess CLI + process-group signals / path spawn assumptions
- * (RUSH-2215). Exported as a PREDICATE, not as a pre-bound `describe.skip` —
- * vitest's suite type is not nameable across a module boundary (TS4023), so
- * each suite builds its own `describe` from this.
- */
 export declare const DAEMON_TESTS_SUPPORTED: boolean;
-/** Provision an isolated HOME with just enough scaffolding for the CLI to boot. */
 export declare function makeHome(): string;
-/** Run `agents daemon <args>` against an isolated HOME — no daemon process ever started. */
 export declare function run(home: string, args: string[]): ReturnType<typeof spawnSync>;
-/**
- * Spawn a real, long-lived process whose command line ends in `__daemon-run`
- * (so `isLiveDaemon`'s process-command check accepts it — see
- * `lib/daemon.test.ts`'s "reaps a live __daemon-run registrant" test, same
- * technique) and register it in `home`'s OWN instance registry, exactly the
- * marker `registerDaemonInstance` would write. A real live process, not a
- * mock — `agents daemon status` reads it through the actual registry +
- * `ps`-liveness path, the same one the reaper and `stopDaemon`'s postcondition
- * use.
- */
 export declare function spawnFakeRegisteredDaemon(home: string): Promise<ChildProcess>;
-/** Register a pid in `home`'s instance registry — the scope stale/duplicate reporting uses. */
 export declare function registerInstance(home: string, pid: number): void;
 export declare function killFakeDaemon(child: ChildProcess): void;