@phnx-labs/agents-cli 1.20.58 → 1.20.60

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## Unreleased
 
+## 1.20.60
+
+- **Fix Goose skill sync status for its native central-storage path.** `agents skills list goose@<version>` now reports skills under `~/.agents/skills/` as installed instead of falsely requiring a per-version `.config/goose/skills/` copy that Goose never reads. Source: `apps/cli/src/lib/skills.ts`.
+- **Correct the documented `auto` and ACP `skip` semantics.** The README and bundled `run` skill now distinguish Kimi's interactive `--auto` from its already-auto-approved headless `-p` path, document Droid's native `--auto high`, and explain that ACP `skip` prefers `allow_always` but falls back to the first permission option offered by the server. Documentation only; runtime behavior is unchanged. Source: `README.md`, `skills/run/SKILL.md`.
+- **Wire Antigravity subagents and Kimi workflow sync (RUSH-1548, RUSH-1581).** Antigravity now receives subagents as custom-agent Markdown under `~/.gemini/config/agents/<name>/agent.md` with the `>= 1.0.16` version gate enforced during sync. Kimi receives workflows as managed `type: flow` skills under `.kimi-code/skills/<name>/SKILL.md`, using the canonical slug as the flow name and an `agents_workflow` marker so native user-owned flows are not overwritten or removed. Antigravity workflows remain disabled for version-home sync until a global filesystem target is documented. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/workflows.ts`.
+- **Release retries rebuild the exact merged, CI-tested release tree even after `main` advances.** A registry/auth failure after the release PR merged previously stranded that version because the catch-up guard required the release merge to remain current `main`. The local release script now validates the original PR head and full green matrix, verifies the SHA-pinned keychain helper, rebuilds the unpinned menu-bar helper from historical source in a detached temporary worktree, rejects mismatched remote tags, and tags/publishes that exact merge without including later commits. Source: `apps/cli/scripts/release.sh`.
+- **Wire Gemini plugins/subagents and Goose workflows/allowlists.** Gemini now syncs plugin bundles as Gemini extensions (`.gemini/extensions/<name>/gemini-extension.json`) from CLI 0.8.0+ and subagents as `.gemini/agents/*.md` from CLI 0.36.0+. Goose now syncs workflows as recipe/subrecipe YAML under `.config/goose/recipes/` and permission groups into `.config/goose/permission.yaml`. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/plugins.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/workflows.ts`, `apps/cli/src/lib/permissions.ts`. (RUSH-1568, RUSH-1569, RUSH-1574, RUSH-1582)
+- **Wire Gemini permissions/allowlist support (RUSH-1567).** Gemini permission groups now sync Bash allow/deny rules into `.gemini/settings.json` as `tools.core` / `tools.exclude` entries with per-command `ShellTool(...)` patterns; non-Bash canonical permissions remain unsupported by Gemini's native tool grammar and are skipped. Flip `allowlist: true`, register the permission writer/detector through the capability table, and replace the dormant legacy `tools.allowed` serializer. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/permissions.ts`, `apps/cli/src/lib/resources/permissions.ts`, `apps/cli/src/lib/staleness/detectors/permissions.ts`.
+- **Fix: `agents run <agent>@<version> --host <host>` now forwards the version pin and most run flags to the remote host.** Previously the `--host` branch stripped `@version` and ignored `--strategy`, `--effort`, `--add-dir`, `--json`, `--verbose`, `--timeout`, `--yes`, and `--acp`, so the remote host applied its own defaults. The local CLI now parses `agent@version` verbatim, normalizes `--strategy`/`--balanced`, makes `--add-dir` paths remote-portable, and forwards all of these flags to the remote `agents run` invocation. `--add-dir` portability uses the same `~`/`$HOME` re-rooting that `--cwd` already uses, so a Linux remote resolves home paths against its own `/home/<user>`. Source: `apps/cli/src/lib/hosts/dispatch.ts`, `apps/cli/src/commands/exec.ts`, `apps/cli/src/lib/hosts/dispatch.test.ts`.
+- **Fix: routine edits no longer rewrite the whole YAML file, so `~/.agents` stays clean and `agents repo pull` can sync routines across the fleet.** `writeJob` previously re-emitted the entire document via `yaml.stringify` on every mutation (pause/resume, `routines devices --set`, add), restyling untouched scalars — unquoting `schedule`, re-wrapping the folded `prompt` block — which left the git-backed user repo perpetually dirty. That made cross-device `agents repo pull` refuse ("uncommitted changes"), so a `devices:` pin set on one machine never reached the others and `Devices: all` routines kept firing on every box. A new `serializeJob` edits only the changed keys via the YAML Document API, preserving byte-for-byte formatting of untouched nodes; new/unparseable/non-mapping files fall back to canonical stringify. Source: `apps/cli/src/lib/routines.ts`, `apps/cli/src/lib/__tests__/routines.serialize.test.ts`.
+
+## 1.20.59
+
+- **Fix: remote secrets now choose the Windows PowerShell wrapper from the original `--host` name, not the resolved `user@ip` SSH target.** Inline enrolled Windows hosts resolve to address-based SSH targets, but the OS registry is keyed by the host name; `agents secrets view/list/exec --host <windows>`, `agents run --secrets bundle@<windows>`, and remote secrets unlock/export paths now pass that original name into command construction so Windows hosts no longer fall back to `bash -lc`. Source: `apps/cli/src/lib/secrets/remote.ts`, `apps/cli/src/commands/secrets.ts`, `apps/cli/src/commands/exec.ts`. (RUSH-1431)
+- **Wire Droid skills support (RUSH-1397).** Droid loads skills from `.factory/skills/` (since 0.26.0). Flip `skills: { since: '0.26.0' }`, register generic skills writer/detector. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/__tests__/capabilities.test.ts`.
+- **Wire skills support for Goose CLI (RUSH-1394).** Goose reads skills directly from `~/.agents/skills/` via the Summon extension (block-goose-cli >= 1.25.0). Flip `skills: { since: '1.25.0' }`, register generic skills writer/detector. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/staleness/writers/commands.ts`.
+- **Wire Droid allowlist support (RUSH-1396).** Droid stores allow/deny in `.factory/settings.json` (`commandAllowlist`/`commandDenylist`). Flip `allowlist: true` since 0.57.5, add `convertToDroidFormat`, wire writer/detector. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/permissions.ts`.
+- **Wire Codex permissions/allowlist support (RUSH-1566).** Codex stores allow/deny in `.codex/config.toml` (`approval_policy`, `sandbox_mode`). Flip `allowlist: true` since 0.128.0, add `convertToCodexFormat`, wire writer/detector. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/permissions.ts`.
+- **OpenCode permissions write to the loaded config path (RUSH-1623).** Global config is `~/.config/opencode/opencode.jsonc` (not `~/.opencode/`); project config is `opencode.jsonc` at the project root. Source: `apps/cli/src/lib/permissions.ts`, `apps/cli/src/lib/agents.ts`.
+- **Catch-up publishes now require the exact CI-tested release tree and its full green matrix.** A package version already present on `main` no longer counts as release validation by itself: `release.sh` resolves the merged `release/v<version>` PR, requires its merge commit to be current `main`, fetches the PR head that ran CI, requires that head tree to equal current `main`, and rechecks every expected CI context before publishing. This closes the path that let 1.20.58 reach npm before its tag-triggered Windows matrix exposed failures. Source: `apps/cli/scripts/release.sh`.
+- **Windows release validation now matches portable path behavior.** Home-relative project paths normalize native separators to `/` before they are stored as `~/…`, and the systemd-manifest and remote-shell assertions now compare the escaped/quoted forms that the runtime deliberately emits. This restores the Windows Node 22/24 release matrix without weakening command escaping. Source: `apps/cli/src/lib/project-root.ts`, `apps/cli/src/lib/{project-root,daemon}.test.ts`, `apps/cli/src/lib/hosts/dispatch.test.ts`.
+- **Wire subagents support for Kiro CLI.** Kiro custom agents are JSON files under `~/.kiro/agents/*.json` (introduced in kiro-cli v1.23.0). Flip Kiro's `subagents: { since: '1.23.0' }`, add `transformSubagentForKiro`, and wire the subagents writer, detector, install/remove, and orphan-detection paths. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/staleness/{writers,detectors}/subagents.ts`. (RUSH-1393)
+
 ## 1.20.58
 
 - **Self-updating agent CLIs are represented as one live installation.** `agents view` no longer invents version-home rows for single-binary installers such as Droid, Grok, Cursor, Kiro, Goose, and Hermes; it reports the version returned by the installed binary and folds away stale per-version directories. `agents add <agent>@<version>` now installs or keeps that agent's current release instead of rejecting an unsupported pinned install. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/versions.ts`, `apps/cli/src/commands/{versions,view}.ts`. (RUSH-1321)
@@ -9,7 +32,6 @@
 - **Wire allowlist support for Cursor CLI.** Cursor agent CLI stores allow/deny in `~/.cursor/cli-config.json` (`permissions.allow`/`deny` with Shell/Read/Write/WebFetch/Mcp). Flip `allowlist: true`, add `convertToCursorFormat` (Bash→Shell), and write via `applyPermissionsToVersion` + detector. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/permissions.ts`. (RUSH-1387)
 - **GitHub Copilot CLI subagents now sync (RUSH-1390).** Installed subagents flatten into GitHub Copilot custom-agent profiles at `~/.copilot/agents/<name>.agent.md` (the Droid custom-droid format), gated to Copilot CLI ≥ 0.0.353. `agents subagents list/view` now surfaces synced Copilot agents and `agents subagents remove` soft-deletes their `.agent.md` files to trash — both previously skipped `copilot` entirely. Source: `apps/cli/src/lib/subagents.ts` (`listSubagentsForAgent`, `removeSubagentFromVersion`, `transformSubagentForCopilot`), `apps/cli/src/lib/staleness/writers/subagents.ts`, `apps/cli/src/lib/staleness/detectors/subagents.ts`, `apps/cli/src/lib/agents.ts`.
 - **Menu-bar Quick Dispatch preserves typed drafts when focus is stolen (RUSH-1592).** If another app activates while the `Cmd-Shift-O` capture panel is open, the panel can hide without destroying the note; the next summon restores the draft text plus selected screenshots, action, and agents. Return submits and clears the draft; Escape clears without dispatching. Source: `apps/cli/menubar/Sources/MenubarHelper/PromptPanel.swift`, `apps/cli/docs/menubar.md`.
-- **Wire subagents support for Kiro CLI.** Kiro custom agents are JSON files under `~/.kiro/agents/*.json` (introduced in kiro-cli v1.23.0). Flip Kiro's `subagents: { since: '1.23.0' }`, add `transformSubagentForKiro`, and wire the subagents writer, detector, install/remove, and orphan-detection paths. Source: `apps/cli/src/lib/agents.ts`, `apps/cli/src/lib/subagents.ts`, `apps/cli/src/lib/staleness/{writers,detectors}/subagents.ts`. (RUSH-1393)
 - **Menu-bar ticket agents now carry every selected screenshot into the Linear issue (RUSH-1668).** `Cmd-Shift-O` already passed selected file paths to the ticket agent, but the prompt only asked it to inspect them, so agents could create text-only issues and stop. The brief now identifies every selected path as user-provided ticket material, requires each file to be uploaded, supplies the existing `linear update <id> --proof <path>` path as a reliable default, and leaves description/comment/other placement to the agent's judgment. Source: `apps/cli/menubar/Sources/MenubarHelper/{AgentsCLI,IssueSelfTest}.swift`, `apps/cli/docs/menubar.md`.
 - **`agents sessions --active --json` now carries session attachment metadata for Factory previews (RUSH-1524).** Claude and Droid prompt image/document blocks that reference local files are preserved as `{ path, name, mediaType, sizeBytes }`, and the active-session state dedupes them into `attachments` so consumers can render screenshot thumbnails and open the original files instead of only seeing an attachment count. Source: `apps/cli/src/lib/session/parse.ts`, `apps/cli/src/lib/session/state.ts`, `apps/cli/src/lib/session/active.ts`.
 - **Retired the standalone `com.phnx-labs.agents-secrets-agent` launchd service — the always-on daemon is now the sole broker host (#416, step 2).** `ensureAgentRunning()` no longer installs a separate launchd service: it retires any leftover plist via the new `retireLegacySecretsAgentService()` and relies on the daemon (Path 0), with a one-off detached broker as the only fallback. The upgrade migration (`scripts/postinstall.js` → `healLongRunningProcesses`) now `launchctl bootout`s the legacy service **first**, then (re)starts the daemon so it takes over the broker socket, instead of kickstarting the old service onto new code. `agents secrets start` is now a thin alias that brings the daemon up (and waits for the broker to answer); `agents secrets stop` locks all bundles and retires any leftover legacy service while leaving the always-on daemon running; `agents secrets status` reports broker reachability (daemon-hosted vs standalone) rather than "service installed". The stale broker teardown (version-skew self-heal) retires the legacy service instead of kickstarting it. Source: `apps/cli/src/lib/secrets/agent.ts` (`retireLegacySecretsAgentService`, `ensureAgentRunning`, `teardownStaleBroker`, `uninstallSecretsAgentService`; removed `installSecretsAgentService`/`kickstartSecretsAgentService`/`generateServicePlist`), `apps/cli/scripts/postinstall.js` (`healLongRunningProcesses`), `apps/cli/src/commands/secrets.ts` (`start`/`stop`/`status`).

package/README.md

@@ -161,9 +161,11 @@ Supports plan (read-only), edit, auto, and skip modes, effort levels, JSON outpu
 
 Treat `skip` as a last-resort escape hatch. In direct-exec runs (without `--acp`),
 agents-cli forwards the harness's native no-prompt flag; it does not add another
-safety layer. Prefer `auto` where the harness has a smart classifier (Claude Code and
-GitHub Copilot), or `edit` everywhere else. Harnesses without a native bypass flag
-reject direct-exec `skip`.
+safety layer. Prefer `auto` where it adds a safer automatic policy (smart classifier
+on Claude/Copilot, native high-auto mode on Droid, or interactive Kimi), or `edit`
+everywhere else. For headless Kimi, `edit`, `auto`, and `skip` all use the same
+already-auto-approved `-p` behavior, so prefer `edit` rather than signaling a blanket
+bypass. Harnesses without a native bypass flag reject direct-exec `skip`.
 
 | Harness | Direct-exec `--mode skip` becomes |
 |---|---|
@@ -179,8 +181,9 @@ reject direct-exec `skip`.
 | Droid | `--skip-permissions-unsafe` |
 
 With `--acp`, these native flags are not used. agents-cli instead grants `skip`
-permission requests at the ACP protocol layer with `allow_always`; the same
-last-resort warning applies.
+permission requests at the ACP protocol layer: it selects `allow_always` when offered,
+otherwise the first permission option offered by the server. The same last-resort
+warning applies.
 
 Codex has no native smart-classifier mode, so `agents run codex --mode auto` resolves
 to sandboxed `edit` and can still prompt. `agents run codex --mode skip` is different:
@@ -855,9 +858,10 @@ Which DotAgents resources each agent CLI can load. Source of truth: [src/lib/age
 | OpenCode | yes | no | yes | no | yes | yes | no | no | `AGENTS.md` | no |
 | Copilot | yes | no | yes | no | yes | yes | no | no | `AGENTS.md` | no |
 | Amp | yes | no | yes | no | yes | yes | no | no | `AGENTS.md` | no |
-| Kiro | yes | no | yes | >= 2.8.0 | yes | yes | no | no | `AGENTS.md` | no |
+| Kiro | yes | no | yes | >= 2.8.0 | yes | yes | no | >= 1.23.0 | `AGENTS.md` | no |
 | Goose | yes | no | yes | no | no | no | no | no | `AGENTS.md` | no |
 | Roo Code | yes | no | yes | no | yes | yes | no | no | `AGENTS.md` | no |
+| Droid | yes | yes | yes | >= 0.57.5 | >= 0.26.0 | yes | yes | yes | `AGENTS.md` | no |
 
 **Legend:** `yes` / `no` = synced or skipped at install time. `skills ($name)` = no file-based slash-command dir; behavior ships as a generated skill invoked with `$command`. `gateway` = OpenClaw resolves slash commands at runtime, not from synced files. Version suffixes are enforced at sync time — out-of-range versions are skipped with a clear message.
 
@@ -875,13 +879,17 @@ Which DotAgents resources each agent CLI can load. Source of truth: [src/lib/age
 | Grok Build | -- | yes | yes |
 | Antigravity | -- | yes | -- |
 | Copilot | -- | -- | yes |
-| OpenClaw, Amp, Kiro, Goose, Roo | -- | -- | -- |
+| OpenClaw, Amp, Goose, Roo | -- | -- | -- |
+| Kiro | -- | -- | -- |
 
 ### Version-gated sync
 
 | Capability | Agent | Gate |
 |------------|-------|------|
 | Hooks | Codex | >= 0.116.0 |
+| Subagents | Kiro | >= 1.23.0 |
+| Skills | Droid | >= 0.26.0 |
+| Permissions | Droid | >= 0.57.5 |
 | Hooks | Gemini | >= 0.26.0 |
 | Permissions | Kiro | >= 2.8.0 |
 | File-based commands | Codex | < 0.117.0 (0.117+ uses command-as-skill) |

package/dist/commands/exec.js

@@ -482,6 +482,7 @@ export function registerRunCommand(program) {
             const { resolveHost, resolveHostByCap } = await import('../lib/hosts/registry.js');
             const { dispatchToHost, runInteractiveOnHost } = await import('../lib/hosts/dispatch.js');
             const { registerHostSession, registerInteractiveHostSession } = await import('../lib/hosts/session-index.js');
+            const { normalizeRunStrategy, RUN_STRATEGIES } = await import('../lib/rotate.js');
             // A password-auth device throws DeviceOffloadUnsupportedError here; it's
             // printed cleanly by the top-level catch in index.ts (covers every
             // resolveHost caller), so it never falls through to capability routing.
@@ -506,12 +507,30 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
             try {
-                const runAgent = agentSpec.split('@')[0];
+                const [runAgent, rawRunVersion] = agentSpec.split('@');
+                // Forward the explicit @version pin verbatim. Resolving aliases like
+                // @latest locally would check local installs, but the remote host may
+                // have versions the laptop does not. The remote agents CLI resolves
+                // aliases against its own installed versions.
+                const runVersion = rawRunVersion || undefined;
+                // Normalize the effective strategy exactly like the local path so we
+                // fail fast on invalid input and can forward --balanced/--strategy.
+                const explicitStrategy = options.strategy ? normalizeRunStrategy(options.strategy) : null;
+                if (options.strategy && !explicitStrategy) {
+                    console.error(chalk.red(`Invalid strategy: ${options.strategy}. Use ${RUN_STRATEGIES.join(', ')}.`));
+                    process.exit(1);
+                }
+                if (options.balanced && explicitStrategy && explicitStrategy !== 'balanced') {
+                    console.error(chalk.red('--balanced conflicts with --strategy. Use one strategy override.'));
+                    process.exit(1);
+                }
+                const runStrategy = options.balanced ? 'balanced' : explicitStrategy ?? undefined;
                 // Working directory on the host: an explicit --remote-cwd is used
                 // verbatim; --cwd/--project are made portable (a local-home absolute
                 // becomes `~/…` so the remote shell re-roots it at ITS home).
                 const { toRemotePortable } = await import('../lib/project-root.js');
                 const hostCwd = options.remoteCwd ?? (options.cwd ? toRemotePortable(options.cwd) : undefined);
+                const hostAddDirs = options.addDir.length > 0 ? options.addDir.map(toRemotePortable) : undefined;
                 // `--resume [id]`: commander yields the string id, or `true` when the
                 // flag is passed bare. A bare resume needs the interactive picker,
                 // which can't run over a detached remote dispatch — only forward a
@@ -549,9 +568,18 @@ export function registerRunCommand(program) {
                     }
                     const exitCode = await runInteractiveOnHost(host, {
                         agent: runAgent,
+                        version: resumeId ? undefined : runVersion,
+                        strategy: resumeId ? undefined : runStrategy,
                         prompt,
                         mode: options.mode,
                         model: options.model,
+                        effort: options.effort,
+                        addDir: hostAddDirs,
+                        json: options.json,
+                        verbose: options.verbose,
+                        timeout: options.timeout,
+                        yes: options.yes,
+                        acp: options.acp,
                         remoteCwd: hostCwd,
                         sessionId: hostSessionId,
                         name: options.name,
@@ -571,9 +599,18 @@ export function registerRunCommand(program) {
                 const hostSessionId = runAgent === 'claude' && !resumeId ? randomUUID() : undefined;
                 const { task, exitCode } = await dispatchToHost(host, {
                     agent: runAgent,
+                    version: resumeId ? undefined : runVersion,
+                    strategy: resumeId ? undefined : runStrategy,
                     prompt,
                     mode: options.mode,
                     model: options.model,
+                    effort: options.effort,
+                    addDir: hostAddDirs,
+                    json: options.json,
+                    verbose: options.verbose,
+                    timeout: options.timeout,
+                    yes: options.yes,
+                    acp: options.acp,
                     remoteCwd: hostCwd,
                     sessionId: hostSessionId,
                     name: options.name,
@@ -1227,7 +1264,7 @@ export function registerRunCommand(program) {
                     // Remote bundle (`bundle@host`): resolve over SSH and inject
                     // ephemerally — values never touch this machine's keychain or disk.
                     const target = await resolveSshTarget(host);
-                    const bundleEnv = await remoteResolveEnv(target, bundleName);
+                    const bundleEnv = await remoteResolveEnv(target, bundleName, { osLookupName: host });
                     console.log(chalk.gray(`[secrets] Resolved ${bundleName}@${host}: ${Object.keys(bundleEnv).length} keys (remote, ephemeral)`));
                     secretsEnv = { ...secretsEnv, ...bundleEnv };
                 }

package/dist/commands/output.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Output command — productivity: token *burn* vs shipped *output*.
+ *
+ * `agents cost` answers "what did we burn?" (dollars + duration). This joins that
+ * burn to what actually shipped — real generated (output) tokens plus PRs and
+ * commits across every git identity — so you can see burn-vs-output and ratios
+ * like $/PR and output-tokens/$. Pure SQLite + local git/gh, no server, no
+ * telemetry — the same offline spirit as `cost`.
+ *
+ * Why not just show `token_count`? Because that number sums cache-read/-write
+ * context re-counted every turn and is dominated by cheap re-reads (often ~100x
+ * the real generation). `output_tokens` (scanned per-agent into the session DB)
+ * is the honest "work produced" signal, and it is what this command leads with.
+ *
+ * `--all-hosts` fans the same rollup across every online device (`ag devices`)
+ * over SSH and merges — one fleet-wide burn-vs-output view.
+ */
+import type { Command } from 'commander';
+export declare function registerOutputCommand(program: Command): void;

package/dist/commands/output.js

@@ -0,0 +1,333 @@
+import chalk from 'chalk';
+import * as os from 'os';
+import * as path from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { addHostOption } from '../lib/hosts/option.js';
+import { discoverSessions, parseTimeFilter } from '../lib/session/discover.js';
+import { queryUsageRollup } from '../lib/session/db.js';
+import { formatUsd, PRICING_VERSION } from '../lib/pricing/index.js';
+import { formatDuration } from '../lib/session/render.js';
+import { terminalWidth, truncateToWidth, padToWidth } from '../lib/session/width.js';
+import { collectGitOutput } from '../lib/output/git-output.js';
+import { loadDevices } from '../lib/devices/registry.js';
+import { machineId } from '../lib/session/sync/config.js';
+const execFileAsync = promisify(execFile);
+export function registerOutputCommand(program) {
+    addHostOption(program.command('output'))
+        .description('Productivity rollup — token burn vs shipped output (PRs, commits) across agents')
+        .option('--json', 'Output the rollup as JSON')
+        .option('--since <time>', 'Only sessions/commits newer than this: 1h, 24h, 7d, 4w, 1mo, 1y, or ISO date (default 7d)')
+        .option('--by <dimension>', 'Group the burn/output breakdown by: agent (default), project, or day')
+        .option('--repos-dir <dir>', 'Root scanned for git repos (default ~/src)')
+        .option('--author <email...>', 'Count commits by these author emails (default: your git identities)')
+        .option('--login <login...>', 'Count PRs for these GitHub logins (default: current gh user)')
+        .option('--no-prs', 'Skip the GitHub PR lookup (commits only)')
+        .option('--all-hosts', 'Aggregate across every online device (ag devices) over SSH')
+        .addHelpText('after', `
+Examples:
+  agents output                       Last 7 days: burn, output tokens, PRs, commits, ratios
+  agents output --since 24h           Last 24 hours
+  agents output --since 1mo           Last month  (units: 1h 24h 7d 4w 1mo 1y, or ISO date)
+  agents output --all-hosts           Fleet-wide, folding in every online machine
+  agents output --by day --json       Machine-readable daily burn/output rollup
+
+Burn (cost) is computed offline from a versioned per-model price table (${PRICING_VERSION}).
+Output tokens are the real generated tokens — NOT the cache-inflated total token count.
+`)
+        .action(async (options) => {
+        await outputAction(options);
+    });
+}
+function resolveGroup(by) {
+    if (by === undefined)
+        return 'agent';
+    if (by === 'agent' || by === 'project' || by === 'day')
+        return by;
+    console.error(chalk.red('error: --by must be one of: agent, project, day'));
+    process.exit(1);
+}
+/** Compact token formatter: 38.6M, 4.1K, 10.6B. */
+function formatCompact(n) {
+    const abs = Math.abs(n);
+    if (abs >= 1e9)
+        return `${(n / 1e9).toFixed(1)}B`;
+    if (abs >= 1e6)
+        return `${(n / 1e6).toFixed(1)}M`;
+    if (abs >= 1e3)
+        return `${(n / 1e3).toFixed(1)}K`;
+    return String(n);
+}
+function emptyBurn() {
+    return { costUsd: 0, outputTokens: 0, tokenCount: 0, sessionCount: 0, durationMs: 0 };
+}
+function sumBurn(rows) {
+    return rows.reduce((acc, r) => {
+        acc.costUsd += r.costUsd;
+        acc.outputTokens += r.outputTokens;
+        acc.tokenCount += r.tokenCount;
+        acc.sessionCount += r.sessionCount;
+        acc.durationMs += r.durationMs;
+        return acc;
+    }, emptyBurn());
+}
+/** Compute this machine's payload from the local session DB + git. */
+async function computeLocalPayload(options, includePrs) {
+    const since = options.since ?? '7d';
+    const sinceMs = parseTimeFilter(since);
+    // Ensure the index is fresh (and migrated to v12 so output_tokens is populated).
+    await discoverSessions({ all: true, since, limit: 1 });
+    const filter = { sinceMs };
+    const groupBy = resolveGroup(options.by);
+    const breakdown = queryUsageRollup({ ...filter, groupBy });
+    const burn = sumBurn(breakdown);
+    const reposDir = options.reposDir ?? path.join(os.homedir(), 'src');
+    const git = await collectGitOutput({
+        reposDir,
+        sinceMs,
+        authors: options.author,
+        logins: options.login,
+        includePrs,
+    });
+    return {
+        machine: machineId(),
+        pricingVersion: PRICING_VERSION,
+        since,
+        burn,
+        output: {
+            commits: git.commits,
+            commitShas: git.commitShas,
+            prsOpened: git.prsOpened,
+            prsMerged: git.prsMerged,
+            reposScanned: git.reposScanned,
+            ghAvailable: git.ghAvailable,
+            authors: git.authors,
+            logins: git.logins,
+        },
+        breakdown: { by: groupBy, rows: breakdown },
+        uncostedAgents: groupBy === 'agent' ? breakdown.filter(r => r.costUsd === 0).map(r => r.key) : [],
+    };
+}
+/** Fetch one remote device's payload by re-invoking `agents output --json --host <name>`. */
+async function fetchRemotePayload(device, options) {
+    const args = ['output', '--json', '--no-prs', '--host', device, '--since', options.since ?? '7d'];
+    if (options.by)
+        args.push('--by', options.by);
+    if (options.reposDir)
+        args.push('--repos-dir', options.reposDir);
+    for (const a of options.author ?? [])
+        args.push('--author', a);
+    try {
+        const { stdout } = await execFileAsync('agents', args, {
+            timeout: 120_000,
+            maxBuffer: 64 * 1024 * 1024,
+        });
+        const parsed = JSON.parse(stdout);
+        parsed.machine = parsed.machine || device;
+        return parsed;
+    }
+    catch (err) {
+        return {
+            machine: device,
+            pricingVersion: PRICING_VERSION,
+            since: options.since ?? '7d',
+            burn: emptyBurn(),
+            output: { commits: 0, commitShas: [], prsOpened: 0, prsMerged: 0, reposScanned: 0, ghAvailable: false, authors: [], logins: [] },
+            breakdown: { by: resolveGroup(options.by), rows: [] },
+            uncostedAgents: [],
+            error: (err?.stderr || err?.message || 'unreachable').toString().split('\n')[0].slice(0, 120),
+        };
+    }
+}
+async function outputAction(options) {
+    const includePrs = options.prs !== false;
+    if (!options.allHosts) {
+        const payload = await computeLocalPayload(options, includePrs);
+        if (options.json) {
+            process.stdout.write(JSON.stringify(withRatios(payload, [payload]), null, 2) + '\n');
+            return;
+        }
+        renderSingle(payload);
+        return;
+    }
+    // Fleet: local payload + every online device, folded in over SSH.
+    const self = machineId();
+    const registry = await loadDevices();
+    const remotes = Object.values(registry)
+        .filter(d => d.tailscale?.online && d.name !== self)
+        .map(d => d.name);
+    if (!options.json)
+        console.error(chalk.gray(`Folding in ${remotes.length} online device${remotes.length !== 1 ? 's' : ''}…`));
+    // PRs are global (gh search by author, not machine-bound) — compute once, locally.
+    const local = await computeLocalPayload(options, includePrs);
+    const remotePayloads = await Promise.all(remotes.map(d => fetchRemotePayload(d, options)));
+    const machines = [local, ...remotePayloads];
+    if (options.json) {
+        process.stdout.write(JSON.stringify(withRatios(mergeMachines(machines, options), machines), null, 2) + '\n');
+        return;
+    }
+    renderFleet(machines, options);
+}
+/** Merge per-machine payloads into a combined one (burn + commits summed; PRs local-only). */
+function mergeMachines(machines, options) {
+    const burn = emptyBurn();
+    const byKey = new Map();
+    // Union commit SHAs across machines: shared repos (cloned on several boxes)
+    // expose the same commits to `git log` on each, so summing counts would
+    // multi-count. A commit's SHA is its global identity — union, don't add.
+    const allShas = new Set();
+    const uncosted = new Set();
+    for (const m of machines) {
+        burn.costUsd += m.burn.costUsd;
+        burn.outputTokens += m.burn.outputTokens;
+        burn.tokenCount += m.burn.tokenCount;
+        burn.sessionCount += m.burn.sessionCount;
+        burn.durationMs += m.burn.durationMs;
+        for (const s of m.output.commitShas)
+            allShas.add(s);
+        for (const a of m.uncostedAgents)
+            uncosted.add(a);
+        for (const r of m.breakdown.rows) {
+            const cur = byKey.get(r.key) ?? { key: r.key, costUsd: 0, durationMs: 0, sessionCount: 0, tokenCount: 0, outputTokens: 0 };
+            cur.costUsd += r.costUsd;
+            cur.durationMs += r.durationMs;
+            cur.sessionCount += r.sessionCount;
+            cur.tokenCount += r.tokenCount;
+            cur.outputTokens += r.outputTokens;
+            byKey.set(r.key, cur);
+        }
+    }
+    const rows = [...byKey.values()].sort((a, b) => b.costUsd - a.costUsd);
+    // PRs from the local machine only (machines[0]) — gh search is not machine-scoped.
+    const localGit = machines[0].output;
+    return {
+        machine: 'fleet',
+        pricingVersion: PRICING_VERSION,
+        since: options.since ?? '7d',
+        burn,
+        output: { ...localGit, commits: allShas.size, commitShas: [...allShas] },
+        breakdown: { by: resolveGroup(options.by), rows },
+        uncostedAgents: [...uncosted],
+    };
+}
+/** Attach burn-vs-output ratios to a payload for JSON output. */
+function withRatios(payload, machines) {
+    const prsTotal = payload.output.prsOpened + payload.output.prsMerged;
+    return {
+        ...payload,
+        ratios: {
+            costPerPr: prsTotal > 0 ? payload.burn.costUsd / prsTotal : null,
+            costPerCommit: payload.output.commits > 0 ? payload.burn.costUsd / payload.output.commits : null,
+            outputTokensPerUsd: payload.burn.costUsd > 0 ? payload.burn.outputTokens / payload.burn.costUsd : null,
+        },
+        machines: machines.length > 1 ? machines.map(m => ({ machine: m.machine, burn: m.burn, commits: m.output.commits, error: m.error })) : undefined,
+    };
+}
+/** Shared header line: burned · output tokens · PRs · commits, plus ratios. */
+function headerLines(payload) {
+    const prsTotal = payload.output.prsOpened + payload.output.prsMerged;
+    const out = [];
+    out.push('  ' +
+        `${chalk.green(formatUsd(payload.burn.costUsd))} burned` +
+        chalk.gray('  ·  ') +
+        `${chalk.cyan(formatCompact(payload.burn.outputTokens))} output tokens` +
+        chalk.gray('  ·  ') +
+        `${chalk.yellow(String(prsTotal))} PRs ${chalk.gray(`(${payload.output.prsMerged} merged)`)}` +
+        chalk.gray('  ·  ') +
+        `${chalk.yellow(String(payload.output.commits))} commits`);
+    const ratios = [];
+    if (prsTotal > 0)
+        ratios.push(`${formatUsd(payload.burn.costUsd / prsTotal)}/PR`);
+    if (payload.output.commits > 0)
+        ratios.push(`${formatUsd(payload.burn.costUsd / payload.output.commits)}/commit`);
+    if (payload.burn.costUsd > 0)
+        ratios.push(`${formatCompact(Math.round(payload.burn.outputTokens / payload.burn.costUsd))} out-tok/$`);
+    if (ratios.length > 0)
+        out.push(chalk.gray('  ' + ratios.join('  ·  ')));
+    return out;
+}
+/** Render the per-group burn/output table. */
+function renderBreakdown(rows, groupBy) {
+    const out = [chalk.bold(`By ${groupBy}`)];
+    if (rows.length === 0)
+        return out;
+    const cols = terminalWidth();
+    const burnW = Math.max(...rows.map(r => formatUsd(r.costUsd).length), 4);
+    const outW = Math.max(...rows.map(r => formatCompact(r.outputTokens).length), 6);
+    const sessW = Math.max(...rows.map(r => String(r.sessionCount).length), 3);
+    const fixedW = 2 + 2 + burnW + 2 + outW + 2 + sessW + 8;
+    const keyW = Math.max(8, Math.min(Math.max(...rows.map(r => r.key.length), groupBy.length), cols - fixedW));
+    out.push('  ' + chalk.gray(padToWidth('', keyW)) + '  ' + chalk.gray(padToWidth('burn', burnW)) + '  ' + chalk.gray(padToWidth('output', outW)) + '  ' + chalk.gray('sessions'));
+    for (const r of rows) {
+        out.push('  ' +
+            padToWidth(truncateToWidth(r.key, keyW), keyW) +
+            '  ' +
+            chalk.green(padToWidth(formatUsd(r.costUsd), burnW)) +
+            '  ' +
+            chalk.cyan(padToWidth(formatCompact(r.outputTokens), outW)) +
+            '  ' +
+            chalk.gray(padToWidth(String(r.sessionCount), sessW)));
+    }
+    return out;
+}
+function renderSingle(payload) {
+    const out = [];
+    out.push(chalk.bold('Output') + chalk.gray(`  ·  pricing ${payload.pricingVersion}  ·  since ${payload.since}`));
+    out.push(...headerLines(payload));
+    out.push('');
+    if (payload.burn.sessionCount === 0) {
+        out.push(chalk.gray('No sessions with cost data found. Run `agents sessions --all` to index, then retry.'));
+        console.log(out.join('\n'));
+        return;
+    }
+    out.push(...renderBreakdown(payload.breakdown.rows, payload.breakdown.by));
+    out.push('');
+    out.push(chalk.bold('Shipped'));
+    out.push(`  ${chalk.yellow(String(payload.output.commits))} commits across ${payload.output.reposScanned} repos` + chalk.gray(`  (authors: ${payload.output.authors.length > 0 ? payload.output.authors.join(', ') : 'none detected'})`));
+    if (payload.output.ghAvailable) {
+        out.push(`  ${chalk.yellow(String(payload.output.prsOpened))} PRs opened, ${chalk.yellow(String(payload.output.prsMerged))} merged` + chalk.gray(`  (logins: ${payload.output.logins.join(', ')})`));
+    }
+    else {
+        out.push(chalk.gray('  PRs: gh unavailable or unauthed — not counted'));
+    }
+    out.push('');
+    out.push(chalk.gray(notCountedLine(payload.uncostedAgents)));
+    if (payload.burn.durationMs > 0)
+        out.push(chalk.gray(`agent wall-clock: ${formatDuration(payload.burn.durationMs)}`));
+    console.log(out.join('\n'));
+}
+function renderFleet(machines, options) {
+    const merged = mergeMachines(machines, options);
+    const out = [];
+    out.push(chalk.bold('Output') + chalk.gray(`  ·  fleet (${machines.length} machines)  ·  pricing ${merged.pricingVersion}  ·  since ${merged.since}`));
+    out.push(...headerLines(merged));
+    out.push('');
+    // By machine.
+    out.push(chalk.bold('By machine'));
+    const nameW = Math.max(...machines.map(m => m.machine.length), 7);
+    const burnW = Math.max(...machines.map(m => formatUsd(m.burn.costUsd).length), 4);
+    for (const m of machines) {
+        const note = m.error ? chalk.red(`  (${m.error})`) : '';
+        out.push('  ' +
+            padToWidth(m.machine, nameW) +
+            '  ' +
+            chalk.green(padToWidth(formatUsd(m.burn.costUsd), burnW)) +
+            '  ' +
+            chalk.cyan(padToWidth(formatCompact(m.burn.outputTokens), 7)) +
+            '  ' +
+            chalk.gray(`${m.burn.sessionCount} sessions, ${m.output.commits} commits`) +
+            note);
+    }
+    out.push('');
+    out.push(...renderBreakdown(merged.breakdown.rows, merged.breakdown.by));
+    out.push('');
+    out.push(chalk.gray(notCountedLine(merged.uncostedAgents)));
+    console.log(out.join('\n'));
+}
+function notCountedLine(uncosted) {
+    const notes = [];
+    if (uncosted.length > 0)
+        notes.push(`no price table for: ${[...new Set(uncosted)].join(', ')} (burn undercounts)`);
+    notes.push('cloud runs (Rush/Codex/Factory) not counted');
+    return 'not counted: ' + notes.join('  ·  ');
+}

package/dist/commands/secrets.js

@@ -328,12 +328,12 @@ async function browseRemote(targets, args, tty) {
     if (tty) {
         for (const t of targets) {
             const target = await resolveSshTarget(t);
-            render(t, remoteSecretsRaw(target, args, { tty: true }));
+            render(t, remoteSecretsRaw(target, args, { tty: true, osLookupName: t }));
         }
     }
     else {
-        const resolved = await Promise.all(targets.map((t) => resolveSshTarget(t)));
-        const results = resolved.map((target) => remoteSecretsRaw(target, args));
+        const resolved = await Promise.all(targets.map(async (t) => ({ name: t, target: await resolveSshTarget(t) })));
+        const results = resolved.map(({ name, target }) => remoteSecretsRaw(target, args, { osLookupName: name }));
         targets.forEach((t, i) => render(t, results[i]));
     }
     if (failures > 0)
@@ -1476,7 +1476,7 @@ Examples:
                         // engine (BatchMode, ConnectTimeout, keepalive, control-socket
                         // reuse) via the same path the READ inverse (`remoteResolveEnv`)
                         // uses. `--from -` reads the .env off ssh stdin.
-                        res = remoteSecretsRaw(host, ['import', resolvedBundleName, '--from', '-', ...(opts.force ? ['--force'] : [])], { input: dotenv });
+                        res = remoteSecretsRaw(host, ['import', resolvedBundleName, '--from', '-', ...(opts.force ? ['--force'] : [])], { input: dotenv, osLookupName: host });
                     }
                     if (res.code === null) {
                         failures++;
@@ -1584,7 +1584,7 @@ Examples:
                 // locally instead.
                 const { assertRemoteBundleFlagsUnsupported } = await import('../lib/secrets/bundles.js');
                 assertRemoteBundleFlagsUnsupported(bundleName, execOpts.host, { keys: keysSubset, allowExpired: execOpts.allowExpired }, { keysFlag: '--keys', allowExpiredFlag: '--allow-expired' });
-                secretEnv = await remoteResolveEnv(await resolveSshTarget(execOpts.host), bundleName);
+                secretEnv = await remoteResolveEnv(await resolveSshTarget(execOpts.host), bundleName, { osLookupName: execOpts.host });
             }
             else {
                 const { readAndResolveBundleEnv } = await import('../lib/secrets/bundles.js');
@@ -1738,7 +1738,7 @@ Examples:
                 // sees a real TTY, which requires our local terminal to pass straight
                 // through. The remote's prompt + output stream to this terminal; we get
                 // back only the exit code.
-                const code = remoteSecretsStream(target, unlockArgs);
+                const code = remoteSecretsStream(target, unlockArgs, { osLookupName: h });
                 if (code === 0) {
                     console.log(chalk.green(`${h}: unlocked`));
                 }

package/dist/index.js

@@ -50,7 +50,7 @@ if (IS_DEV_BUILD) {
 // module on each invocation (which loaded the whole ~50-module tree before the
 // first byte of output), the registry maps a command name to a thunk that
 // imports only what that command needs. See src/lib/startup/command-registry.ts.
-import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadPackages, loadDaemon, loadRoutines, loadRun, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadCheck, loadStatus, loadProfiles, loadSecrets, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadBudget, loadAlias, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadFeed, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadPackages, loadDaemon, loadRoutines, loadRun, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadCheck, loadStatus, loadProfiles, loadSecrets, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadFeed, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { emit, redactArgs } from './lib/events.js';
@@ -690,6 +690,7 @@ async function registerAllEagerCommands() {
     await reg(loadFactory);
     await reg(loadUsage);
     await reg(loadCost);
+    await reg(loadOutput);
     await reg(loadBudget);
     await reg(loadAlias);
     await reg(loadPty);