@phnx-labs/agents-cli 1.20.58 → 1.20.59

package/dist/lib/output/git-output.js

@@ -0,0 +1,213 @@
+/**
+ * Git / GitHub "output" collector — the shipped-work half of `agents output`.
+ *
+ * `agents cost` answers "what did we burn?"; this answers "what did we ship?".
+ * It counts commits (across every author identity, so multi-account totals stay
+ * correct regardless of which `gh` login is active) and PRs opened / merged in a
+ * time window. Pure `git`/`gh` over child_process — no server, no telemetry,
+ * mirroring the offline spirit of the cost rollup.
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+const execFileAsync = promisify(execFile);
+/** Directory names never descended into during repo discovery. */
+const SKIP_DIRS = new Set(['node_modules', '.git', '.agents', '.worktrees', 'dist', 'build', '.next', '.cache']);
+/**
+ * Find git repositories under `root` up to `maxDepth` levels deep. A directory
+ * with a `.git` entry is a repo and is NOT descended into (so nested worktrees
+ * / submodules don't double-count).
+ */
+export function findGitRepos(root, maxDepth = 4) {
+    const repos = [];
+    const walk = (dir, depth) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // unreadable dir — skip
+        }
+        if (entries.some(e => e.name === '.git')) {
+            repos.push(dir);
+            return; // don't descend into a repo
+        }
+        if (depth >= maxDepth)
+            return;
+        for (const e of entries) {
+            if (!e.isDirectory() || e.name.startsWith('.') || SKIP_DIRS.has(e.name))
+                continue;
+            walk(path.join(dir, e.name), depth + 1);
+        }
+    };
+    walk(root, 0);
+    return repos;
+}
+/** git log for one repo (SHA + author email per commit), tolerant of empty/broken repos. */
+async function repoLog(repoDir, sinceIso) {
+    try {
+        const { stdout } = await execFileAsync('git', ['-C', repoDir, 'log', '--all', '--no-merges', `--since=${sinceIso}`, '--pretty=format:%H%x09%ae'], { maxBuffer: 64 * 1024 * 1024 });
+        const refs = [];
+        for (const line of stdout.split('\n')) {
+            const tab = line.indexOf('\t');
+            if (tab < 0)
+                continue;
+            refs.push({ sha: line.slice(0, tab).trim(), email: line.slice(tab + 1).trim() });
+        }
+        return refs;
+    }
+    catch {
+        return []; // no commits yet / not a real repo / detached weirdness
+    }
+}
+/**
+ * Discover the user's own author emails so commit counts exclude teammates.
+ * Union of `git config --global user.email` and each repo's local `user.email`.
+ */
+async function discoverAuthorEmails(repos) {
+    const emails = new Set();
+    try {
+        const { stdout } = await execFileAsync('git', ['config', '--global', 'user.email']);
+        const e = stdout.trim();
+        if (e)
+            emails.add(e.toLowerCase());
+    }
+    catch {
+        /* no global identity */
+    }
+    await Promise.all(repos.map(async (repo) => {
+        try {
+            const { stdout } = await execFileAsync('git', ['-C', repo, 'config', '--get', 'user.email']);
+            const e = stdout.trim();
+            if (e)
+                emails.add(e.toLowerCase());
+        }
+        catch {
+            /* repo has no local identity */
+        }
+    }));
+    return [...emails];
+}
+/**
+ * Count commits by our authors across all repos, deduped by SHA (so the same
+ * commit reachable via multiple repo clones/worktrees on this machine — or, at
+ * the fleet layer, across machines — is counted once), tallied per email.
+ */
+export async function collectCommits(repos, sinceIso, authors) {
+    const ours = new Set(authors.map(a => a.toLowerCase()));
+    const tally = new Map();
+    const seen = new Set();
+    const logs = await Promise.all(repos.map(r => repoLog(r, sinceIso)));
+    for (const refs of logs) {
+        for (const { sha, email } of refs) {
+            const key = email.toLowerCase();
+            if (ours.size > 0 && !ours.has(key))
+                continue;
+            if (seen.has(sha))
+                continue; // same commit seen via another clone/ref
+            seen.add(sha);
+            tally.set(key, (tally.get(key) ?? 0) + 1);
+        }
+    }
+    const byAuthor = [...tally.entries()]
+        .map(([author, commits]) => ({ author, commits }))
+        .sort((a, b) => b.commits - a.commits);
+    return { total: seen.size, byAuthor, shas: [...seen] };
+}
+/** Resolve the current gh login, or null if gh is unavailable/unauthed. */
+async function currentGhLogin() {
+    try {
+        const { stdout } = await execFileAsync('gh', ['api', 'user', '--jq', '.login']);
+        const login = stdout.trim();
+        return login || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Count PRs matching a gh search query (author + date), returning null on failure. */
+async function ghSearchCount(args) {
+    try {
+        const { stdout } = await execFileAsync('gh', [...args, '--limit', '1000', '--json', 'number'], {
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        const rows = JSON.parse(stdout);
+        return Array.isArray(rows) ? rows.length : 0;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Count PRs opened and merged in the window across the given logins. `gh search
+ * prs` searches all of GitHub, so one authed gh can cover multiple accounts'
+ * logins. Returns ghAvailable=false if gh can't be reached at all.
+ */
+export async function collectPrs(logins, sinceDate) {
+    let resolved = logins;
+    if (resolved.length === 0) {
+        const login = await currentGhLogin();
+        if (!login)
+            return { opened: 0, merged: 0, logins: [], ghAvailable: false };
+        resolved = [login];
+    }
+    let opened = 0;
+    let merged = 0;
+    let anyOk = false;
+    for (const login of resolved) {
+        const o = await ghSearchCount(['search', 'prs', '--author', login, '--created', `>=${sinceDate}`]);
+        const m = await ghSearchCount(['search', 'prs', '--author', login, '--merged', `>=${sinceDate}`]);
+        if (o !== null) {
+            opened += o;
+            anyOk = true;
+        }
+        if (m !== null) {
+            merged += m;
+            anyOk = true;
+        }
+    }
+    return { opened, merged, logins: resolved, ghAvailable: anyOk };
+}
+/** Format an epoch-ms as a YYYY-MM-DD date (UTC), for gh's date-range search. */
+export function toSearchDate(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+/**
+ * Collect the full shipped-work summary for a window: commits (across accounts)
+ * plus PRs opened/merged.
+ */
+export async function collectGitOutput(options) {
+    const reposDir = options.reposDir.replace(/^~(?=$|\/)/, os.homedir());
+    const sinceIso = new Date(options.sinceMs).toISOString();
+    const sinceDate = toSearchDate(options.sinceMs);
+    const repos = findGitRepos(reposDir, options.maxDepth ?? 4);
+    const authors = options.authors && options.authors.length > 0
+        ? options.authors.map(a => a.toLowerCase())
+        : await discoverAuthorEmails(repos);
+    const { total: commits, byAuthor, shas: commitShas } = await collectCommits(repos, sinceIso, authors);
+    let prsOpened = 0;
+    let prsMerged = 0;
+    let ghAvailable = false;
+    let logins = options.logins ?? [];
+    if (options.includePrs !== false) {
+        const prs = await collectPrs(logins, sinceDate);
+        prsOpened = prs.opened;
+        prsMerged = prs.merged;
+        ghAvailable = prs.ghAvailable;
+        logins = prs.logins;
+    }
+    return {
+        reposScanned: repos.length,
+        commits,
+        byAuthor,
+        commitShas,
+        prsOpened,
+        prsMerged,
+        ghAvailable,
+        authors,
+        logins,
+        sinceIso,
+    };
+}

package/dist/lib/permissions.d.ts

@@ -117,6 +117,11 @@ export declare function convertToGeminiFormat(set: PermissionSet): {
         allowed: string[];
     };
 };
+/** Convert canonical Bash rules into Droid's command arrays. */
+export declare function convertToDroidFormat(set: PermissionSet): {
+    commandAllowlist: string[];
+    commandDenylist: string[];
+};
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with
@@ -212,6 +217,13 @@ export declare function applyClaudePermissions(set: PermissionSet, scope?: 'user
     success: boolean;
     error?: string;
 };
+/**
+ * Path OpenCode actually loads for global config:
+ *   ~/.config/opencode/opencode.jsonc  (or .json)
+ * Project: <cwd>/opencode.jsonc (or .json) at project root — not .opencode/.
+ * See https://opencode.ai/docs/config/
+ */
+export declare function openCodeConfigPath(scope: 'user' | 'project', cwd?: string, home?: string): string;
 /**
  * Apply a permission set to a specific version's home directory.
  * This writes to {versionHome}/.{agent}/settings.json (or equivalent).

package/dist/lib/permissions.js

@@ -525,6 +525,26 @@ function normalizeBashPattern(pattern) {
         return pattern.slice(0, -2) + ' *';
     return pattern;
 }
+/** Convert canonical Bash rules into Droid's command arrays. */
+export function convertToDroidFormat(set) {
+    const commands = (permissions) => {
+        const result = new Set();
+        for (const permission of permissions) {
+            if (BLANKET_BASH_FORMS.has(permission)) {
+                result.add('*');
+                continue;
+            }
+            const parsed = parseCanonicalPattern(permission);
+            if (parsed?.tool === 'bash')
+                result.add(normalizeBashPattern(parsed.pattern));
+        }
+        return Array.from(result);
+    };
+    return {
+        commandAllowlist: commands(set.allow),
+        commandDenylist: commands(set.deny ?? []),
+    };
+}
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with
@@ -919,9 +939,7 @@ function readClaudePermissions(scope = 'user', cwd, options) {
  */
 function readOpenCodePermissions(scope = 'user', cwd, options) {
     const home = options?.home || HOME;
-    const configPath = scope === 'user'
-        ? path.join(home, '.opencode', 'opencode.jsonc')
-        : path.join(cwd || process.cwd(), '.opencode', 'opencode.jsonc');
+    const configPath = openCodeConfigPath(scope, cwd, home);
     if (!fs.existsSync(configPath)) {
         return null;
     }
@@ -1031,14 +1049,36 @@ export function applyClaudePermissions(set, scope = 'user', cwd, merge = true) {
         return { success: false, error: err.message };
     }
 }
+/**
+ * Path OpenCode actually loads for global config:
+ *   ~/.config/opencode/opencode.jsonc  (or .json)
+ * Project: <cwd>/opencode.jsonc (or .json) at project root — not .opencode/.
+ * See https://opencode.ai/docs/config/
+ */
+export function openCodeConfigPath(scope, cwd, home = HOME) {
+    if (scope === 'project') {
+        const root = cwd || process.cwd();
+        for (const name of ['opencode.jsonc', 'opencode.json']) {
+            const candidate = path.join(root, name);
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        return path.join(root, 'opencode.jsonc');
+    }
+    const globalDir = path.join(home, '.config', 'opencode');
+    for (const name of ['opencode.jsonc', 'opencode.json']) {
+        const candidate = path.join(globalDir, name);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return path.join(globalDir, 'opencode.jsonc');
+}
 /**
  * Apply a permission set to OpenCode's opencode.jsonc.
  */
 function applyOpenCodePermissions(set, scope = 'user', cwd, merge = true) {
-    const configDir = scope === 'user'
-        ? path.join(HOME, '.opencode')
-        : path.join(cwd || process.cwd(), '.opencode');
-    const configPath = path.join(configDir, 'opencode.jsonc');
+    const configPath = openCodeConfigPath(scope, cwd);
+    const configDir = path.dirname(configPath);
     try {
         // Ensure directory exists
         if (!fs.existsSync(configDir)) {
@@ -1172,7 +1212,10 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             return { success: true };
         }
         if (agentId === 'opencode') {
-            const configPath = path.join(configDir, 'opencode.jsonc');
+            // OpenCode loads ~/.config/opencode/opencode.jsonc under the version home
+            // (HOME isolation), not ~/.opencode/opencode.jsonc.
+            const configPath = openCodeConfigPath('user', undefined, versionHome);
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
             let config = {};
             if (fs.existsSync(configPath)) {
                 const content = stripJsonComments(fs.readFileSync(configPath, 'utf-8'));
@@ -1364,6 +1407,27 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
             return { success: true };
         }
+        if (agentId === 'droid') {
+            const configPath = path.join(versionHome, '.factory', 'settings.json');
+            let config = {};
+            if (fs.existsSync(configPath)) {
+                config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            }
+            const converted = convertToDroidFormat(set);
+            if (merge) {
+                const existingAllow = Array.isArray(config.commandAllowlist) ? config.commandAllowlist : [];
+                const existingDeny = Array.isArray(config.commandDenylist) ? config.commandDenylist : [];
+                config.commandAllowlist = Array.from(new Set([...existingAllow, ...converted.commandAllowlist]));
+                config.commandDenylist = Array.from(new Set([...existingDeny, ...converted.commandDenylist]));
+            }
+            else {
+                config.commandAllowlist = converted.commandAllowlist;
+                config.commandDenylist = converted.commandDenylist;
+            }
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+            return { success: true };
+        }
         if (agentId === 'kiro') {
             const permissionsPath = path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
             let config = {};
@@ -1496,7 +1560,7 @@ export function exportPermissionsFromPath(filePath) {
     if (fileName === 'settings.json' && parentDir === '.claude') {
         agentId = 'claude';
     }
-    else if (fileName === 'opencode.jsonc' || parentDir === '.opencode') {
+    else if (fileName === 'opencode.jsonc' || fileName === 'opencode.json' || parentDir === 'opencode' || parentDir === '.opencode') {
         agentId = 'opencode';
     }
     else if (fileName === 'config.toml' && parentDir === '.codex') {

package/dist/lib/project-root.js

@@ -16,6 +16,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { readMeta, updateMeta } from './state.js';
 import { getMainRepoRoot } from './git.js';
+import { toPosix } from './platform/index.js';
 const HOME = process.env.HOME ?? os.homedir();
 /** Rewrite an absolute path under the local home to a `~/`-relative string; pass others through. */
 export function toHomeRelative(abs) {
@@ -23,7 +24,7 @@ export function toHomeRelative(abs) {
     if (rel === '')
         return '~';
     if (!rel.startsWith('..') && !path.isAbsolute(rel))
-        return `~/${rel}`;
+        return `~/${toPosix(rel)}`;
     return abs;
 }
 /** Expand a leading `~`/`$HOME` against the LOCAL home. Other paths pass through unchanged. */

package/dist/lib/resources/mcp.js

@@ -111,7 +111,7 @@ export function getMcpConfigPath(agent, versionHome) {
         case 'codex':
             return path.join(versionHome, '.codex', 'config.toml');
         case 'opencode':
-            return path.join(versionHome, '.opencode', 'opencode.jsonc');
+            return path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
         case 'cursor':
             return path.join(versionHome, '.cursor', 'mcp.json');
         case 'gemini':

package/dist/lib/resources/permissions.js

@@ -66,9 +66,11 @@ function getAgentConfigPath(agent, versionHome) {
         case 'codex':
             return path.join(versionHome, '.codex', 'config.toml');
         case 'opencode':
-            return path.join(versionHome, '.opencode', 'opencode.jsonc');
+            return path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
         case 'kimi':
             return path.join(versionHome, '.kimi-code', 'config.toml');
+        case 'droid':
+            return path.join(versionHome, '.factory', 'settings.json');
         case 'kiro':
             return path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
         default:

package/dist/lib/resources/skills.js

@@ -5,7 +5,7 @@
  * Format is the same for all agents. Resolution order: project > user > system.
  */
 import * as fs from 'fs';
-import { agentConfigDirName } from '../agents.js';
+import { AGENTS, agentConfigDirName } from '../agents.js';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { getSystemSkillsDir, getUserSkillsDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../state.js';
@@ -201,6 +201,11 @@ export function createSkillsHandler(provider = defaultProvider) {
             return null;
         },
         sync(agent, versionHome, cwd) {
+            // Agents that read directly from central ~/.agents/skills/ (e.g. Gemini,
+            // Goose via the Summon extension) should not get a per-version copy.
+            if (AGENTS[agent]?.nativeAgentsSkillsDir) {
+                return;
+            }
             const targetDir = path.join(versionHome, agentConfigDirName(agent), 'skills');
             // Ensure target directory exists
             if (!fs.existsSync(targetDir)) {

package/dist/lib/resources/types.d.ts

@@ -5,7 +5,7 @@
  * - Union: All resources from all layers are combined
  * - Override on name conflict: Higher layer wins (project > user > system)
  */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'kiro' | 'antigravity' | 'grok' | 'kimi' | 'hermes' | 'forge';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'kiro' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'forge';
 export type Layer = 'system' | 'user' | 'project';
 export type ResourceKind = 'command' | 'hook' | 'skill' | 'rule' | 'mcp' | 'permission' | 'subagent' | 'workflow' | 'memory';
 /** A resolved resource with its origin layer. */

package/dist/lib/secrets/remote.d.ts

@@ -50,6 +50,7 @@ export declare function splitBundleRef(ref: string): {
 export declare function remoteSecretsRaw(target: string, args: string[], opts?: {
     tty?: boolean;
     input?: string;
+    osLookupName?: string;
 }): SshExecResult;
 /**
  * Run a remote `agents secrets <args>` FOREGROUND, with the local stdio wired
@@ -64,7 +65,9 @@ export declare function remoteSecretsRaw(target: string, args: string[], opts?:
  * bundle's passphrase at your own terminal. Output is NOT captured (it streams
  * to the terminal); only the exit code is returned.
  */
-export declare function remoteSecretsStream(target: string, args: string[]): number;
+export declare function remoteSecretsStream(target: string, args: string[], opts?: {
+    osLookupName?: string;
+}): number;
 /**
  * Resolve a remote bundle to a plaintext env map by driving the remote's
  * `agents secrets export <bundle> --plaintext --format json`. Values cross over
@@ -78,4 +81,6 @@ export declare function remoteSecretsStream(target: string, args: string[]): num
  * SSH will block on Touch-ID — use `view`/`exec` with a remote `file` bundle,
  * an already-unlocked remote secrets-agent, or an interactive `-tt` session.)
  */
-export declare function remoteResolveEnv(target: string, bundle: string): Promise<Record<string, string>>;
+export declare function remoteResolveEnv(target: string, bundle: string, opts?: {
+    osLookupName?: string;
+}): Promise<Record<string, string>>;

package/dist/lib/secrets/remote.js

@@ -22,11 +22,12 @@ import { sshTargetFor } from '../hosts/types.js';
 import { buildRemoteAgentsInvocation } from '../hosts/remote-cmd.js';
 import { resolveRemoteOsSync } from '../hosts/remote-os.js';
 const REMOTE_TIMEOUT_MS = 30_000;
-/** Remote OS for a target string (bare alias matches a device entry; a raw
- * `user@host` falls back to POSIX). Threaded into the command builder so a
- * Windows host gets PowerShell instead of `bash -lc`. */
-function osForTarget(target) {
-    return resolveRemoteOsSync(target.split('@').pop() ?? target);
+/** Remote OS for a host name or target string. Prefer the original host name
+ * because enrolled inline hosts resolve to `user@address`, while the OS
+ * registry is keyed by the host name. */
+function osForTarget(target, lookupName) {
+    const byName = lookupName ? resolveRemoteOsSync(lookupName) : undefined;
+    return byName ?? resolveRemoteOsSync(target.split('@').pop() ?? target);
 }
 /**
  * Resolve a `--host` value to an ssh target string. Tries the `agents hosts`
@@ -86,7 +87,7 @@ export function splitBundleRef(ref) {
  * remote Touch-ID / passphrase prompt can surface (e.g. `view --reveal`).
  */
 export function remoteSecretsRaw(target, args, opts = {}) {
-    const remoteCmd = buildRemoteAgentsInvocation(['secrets', ...args], undefined, osForTarget(target));
+    const remoteCmd = buildRemoteAgentsInvocation(['secrets', ...args], undefined, osForTarget(target, opts.osLookupName));
     return sshExec(target, remoteCmd, {
         timeoutMs: REMOTE_TIMEOUT_MS,
         input: opts.input,
@@ -107,8 +108,8 @@ export function remoteSecretsRaw(target, args, opts = {}) {
  * bundle's passphrase at your own terminal. Output is NOT captured (it streams
  * to the terminal); only the exit code is returned.
  */
-export function remoteSecretsStream(target, args) {
-    const remoteCmd = buildRemoteAgentsInvocation(['secrets', ...args], undefined, osForTarget(target));
+export function remoteSecretsStream(target, args, opts = {}) {
+    const remoteCmd = buildRemoteAgentsInvocation(['secrets', ...args], undefined, osForTarget(target, opts.osLookupName));
     return sshStream(target, remoteCmd, { tty: true });
 }
 /**
@@ -124,9 +125,9 @@ export function remoteSecretsStream(target, args) {
  * SSH will block on Touch-ID — use `view`/`exec` with a remote `file` bundle,
  * an already-unlocked remote secrets-agent, or an interactive `-tt` session.)
  */
-export async function remoteResolveEnv(target, bundle) {
+export async function remoteResolveEnv(target, bundle, opts = {}) {
     assertValidSshTarget(target);
-    const remoteCmd = buildRemoteAgentsInvocation(['secrets', 'export', bundle, '--plaintext', '--format', 'json'], undefined, osForTarget(target));
+    const remoteCmd = buildRemoteAgentsInvocation(['secrets', 'export', bundle, '--plaintext', '--format', 'json'], undefined, osForTarget(target, opts.osLookupName));
     const res = sshExec(target, remoteCmd, {
         timeoutMs: REMOTE_TIMEOUT_MS,
     });

package/dist/lib/session/db.d.ts

@@ -24,6 +24,7 @@ export interface SessionRow {
     label: string | null;
     message_count: number | null;
     token_count: number | null;
+    output_tokens: number | null;
     cost_usd: number | null;
     duration_ms: number | null;
     file_path: string;
@@ -184,6 +185,8 @@ export interface UsageRollupRow {
     durationMs: number;
     sessionCount: number;
     tokenCount: number;
+    /** Real generated (output) tokens — excludes cache-read/-write context. */
+    outputTokens: number;
 }
 /** What to group a usage rollup by. */
 export type UsageRollupGroup = 'agent' | 'project' | 'day';

package/dist/lib/session/db.js

@@ -13,7 +13,7 @@ import { getSessionsDir, getSessionsDbPath } from '../state.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. */
-const SCHEMA_VERSION = 11;
+const SCHEMA_VERSION = 12;
 /**
  * Canonicalize a file path for use as a scan_ledger key. The same physical
  * session file is reachable via multiple aliases — `~/.claude/projects/x.jsonl`
@@ -54,6 +54,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   label TEXT,
   message_count INTEGER,
   token_count INTEGER,
+  output_tokens INTEGER,
   cost_usd REAL,
   duration_ms INTEGER,
   file_path TEXT NOT NULL,
@@ -224,6 +225,16 @@ function migrateSchema(db, fromVersion) {
             db.exec(`ALTER TABLE sessions ADD COLUMN plan TEXT`);
         db.exec(`DELETE FROM scan_ledger;`);
     }
+    if (fromVersion < 12) {
+        // v11 → v12: `output_tokens` — the real generated-token count, kept separate
+        // from `token_count` (which sums cache-read/-write and so is dominated by
+        // cheap re-counted context). This is the honest "output" metric powering
+        // `agents output`. Additive column; rescan to backfill from transcripts.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'output_tokens'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN output_tokens INTEGER`);
+        db.exec(`DELETE FROM scan_ledger;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -438,13 +449,13 @@ const upsertSessionStmt = (db) => db.prepare(`
   INSERT INTO sessions (
     id, short_id, agent, version, account, timestamp, last_activity,
     project, cwd, git_branch, topic, label, message_count, token_count,
-    cost_usd, duration_ms,
+    output_tokens, cost_usd, duration_ms,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
     pr_url, pr_number, worktree_slug, ticket_id, plan
   ) VALUES (
     @id, @short_id, @agent, @version, @account, @timestamp, @last_activity,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
-    @cost_usd, @duration_ms,
+    @output_tokens, @cost_usd, @duration_ms,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
     @pr_url, @pr_number, @worktree_slug, @ticket_id, @plan
   )
@@ -462,6 +473,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     label = excluded.label,
     message_count = excluded.message_count,
     token_count = excluded.token_count,
+    output_tokens = excluded.output_tokens,
     cost_usd = excluded.cost_usd,
     duration_ms = excluded.duration_ms,
     file_path = excluded.file_path,
@@ -510,6 +522,7 @@ export function upsertSession(meta, content, scan) {
         label: meta.label ?? null,
         message_count: meta.messageCount ?? null,
         token_count: meta.tokenCount ?? null,
+        output_tokens: meta.outputTokens ?? null,
         cost_usd: meta.costUsd ?? null,
         duration_ms: meta.durationMs ?? null,
         file_path: meta.filePath,
@@ -599,6 +612,7 @@ export function upsertSessionsBatch(entries) {
                     label: meta.label ?? null,
                     message_count: meta.messageCount ?? null,
                     token_count: meta.tokenCount ?? null,
+                    output_tokens: meta.outputTokens ?? null,
                     cost_usd: meta.costUsd ?? null,
                     duration_ms: meta.durationMs ?? null,
                     file_path: meta.filePath,
@@ -772,6 +786,7 @@ function rowToMeta(row) {
         gitBranch: row.git_branch ?? undefined,
         messageCount: row.message_count ?? undefined,
         tokenCount: row.token_count ?? undefined,
+        outputTokens: row.output_tokens ?? undefined,
         costUsd: row.cost_usd ?? undefined,
         durationMs: row.duration_ms ?? undefined,
         version: row.version ?? undefined,
@@ -956,7 +971,8 @@ export function queryUsageRollup(options) {
       IFNULL(SUM(cost_usd), 0) AS costUsd,
       IFNULL(SUM(duration_ms), 0) AS durationMs,
       COUNT(*) AS sessionCount,
-      IFNULL(SUM(token_count), 0) AS tokenCount
+      IFNULL(SUM(token_count), 0) AS tokenCount,
+      IFNULL(SUM(output_tokens), 0) AS outputTokens
     FROM sessions
     ${clause}
     GROUP BY key

package/dist/lib/session/discover.d.ts

@@ -46,6 +46,8 @@ interface ClaudeSessionScan {
     topic?: string;
     messageCount: number;
     tokenCount?: number;
+    /** Real generated (output) tokens, excluding cache-read/-write context. */
+    outputTokens?: number;
     /** Total USD cost accumulated from per-(model, direction) token usage. */
     costUsd?: number;
     /** Wall-clock duration in ms between the first and last timestamped event. */