@phnx-labs/agents-cli 1.22.18 → 1.22.20

package/dist/lib/session/db.js

@@ -17,6 +17,7 @@ import { machineForSessionFile } from './origin-machine.js';
 import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
 import { toolCallsFromEvents } from './tool-calls.js';
 import { persistToolCalls, purgeToolCalls, toolEvidenceSourcePath } from './tool-store.js';
+import { buildClaudeAccountIndex, resolveClaudeAccount } from './claude-accounts.js';
 import { extractSkills, extractSlashCommands } from './highlights.js';
 import { resolveResource } from '../resources.js';
 import { discoverPlugins } from '../plugins.js';
@@ -25,7 +26,7 @@ const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/05-sessions.md calls the constant the source of truth). */
-export const SCHEMA_VERSION = 32;
+export const SCHEMA_VERSION = 33;
 /**
  * Bump to force `agents sessions backfill resources` to re-derive every
  * session's skill/slash-command tallies on its next run (resource_scan_ledger
@@ -67,6 +68,8 @@ CREATE TABLE IF NOT EXISTS sessions (
   routine_run_id TEXT,
   version TEXT,
   account TEXT,
+  account_key TEXT,
+  account_org TEXT,
   mode TEXT,
   timestamp TEXT NOT NULL,
   last_activity TEXT,
@@ -730,6 +733,56 @@ function migrateSchema(db, fromVersion) {
         if (!cols.has('mode'))
             db.exec(`ALTER TABLE sessions ADD COLUMN mode TEXT`);
     }
+    if (fromVersion < 33) {
+        // v32 → v33: attribute each Claude session to the account that produced it.
+        // Until now `account` held ONE email resolved process-globally and stamped on
+        // every row of a scan, so a machine with several signed-in accounts reported all
+        // of its history under whichever resolved first.
+        //
+        // Do NOT wipe scan_ledger. Attribution is a pure function of (file_path,
+        // version) — both already stored — so existing rows are repaired in place with
+        // no transcript re-parsed. Adding `DELETE FROM scan_ledger` here to match the
+        // other migrations would force a full re-parse of every indexed transcript to
+        // recompute something derivable from two columns. The v31 migration sets the
+        // same precedent.
+        const cols = new Set(db.prepare(`PRAGMA table_info(sessions)`).all().map((column) => column.name));
+        if (!cols.has('account_key'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN account_key TEXT`);
+        if (!cols.has('account_org'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN account_org TEXT`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_account_key ON sessions(account_key)`);
+        backfillClaudeAccounts(db);
+    }
+}
+/**
+ * Stamp `account_key` / `account_org` / `account` on every Claude row from its
+ * `file_path` and recorded `version`. Used by the v33 migration; idempotent, so it is
+ * safe to re-run.
+ */
+function backfillClaudeAccounts(db, scope = 'all') {
+    // 'unresolved' exists so the getDB repair touches ONLY rows that are actually
+    // broken. Re-resolving every Claude row on an unrelated trigger would silently
+    // downgrade a correct row whose version home has since been uninstalled and its
+    // trash snapshot pruned — the row would go from attributed to dark for no reason
+    // the user caused. The migration wants 'all'; the repair does not.
+    const where = scope === 'all'
+        ? `agent = 'claude'`
+        : `agent = 'claude' AND (account_key IS NULL
+         OR (account_key LIKE 'unattributed:%' AND account IS NOT NULL))`;
+    const index = buildClaudeAccountIndex();
+    const rows = db.prepare(`SELECT id, file_path, version FROM sessions WHERE ${where}`).all();
+    if (rows.length === 0)
+        return;
+    // `account` is overwritten, not COALESCEd. Every pre-v33 row carries the wrong
+    // globally-resolved email; keeping it on a row we could not attribute would leave a
+    // known-false address on display (commands/sessions.ts prints it, and its fuzzy
+    // matcher scores on it) and would disagree with the scan path, which writes
+    // `account = excluded.account` unconditionally. A dark row reads NULL.
+    const update = db.prepare(`UPDATE sessions SET account_key = ?, account_org = ?, account = ? WHERE id = ?`);
+    for (const row of rows) {
+        const bucket = resolveClaudeAccount(index, row.file_path ?? '', row.version);
+        update.run(bucket.key, bucket.orgName, bucket.email, row.id);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -776,6 +829,31 @@ export function getDB() {
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_last_activity ON sessions(last_activity DESC)`);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_origin ON sessions(origin)`);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_routine_run_id ON sessions(routine_run_id)`);
+    // Account attribution repair. Two ways a Claude row ends up wrong even at v33:
+    // an older CLI (whose INSERT does not name the column) writes NULL, and a DB
+    // migrated by a build that predates the "clear the stale email on a dark row" fix
+    // keeps a known-wrong address. The v33 migration cannot fix either — it never runs
+    // again. Cheap guard first so the common case is one indexed lookup, then repair.
+    // Same shape as the `machine` repair below, for the same reason.
+    {
+        // Column guard FIRST, like the `machine` repair below. schema_version can be
+        // stamped at SCHEMA_VERSION without the column existing — getDB writes the marker
+        // for any DB whose meta has no row (a hand-built or partially-created index), and
+        // migrateSchema never runs in that path. Querying account_key unguarded would
+        // then throw "no such column" and take down every command that opens the index.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (cols.some((c) => c.name === 'account_key') && cols.some((c) => c.name === 'account_org')) {
+            const needsRepair = db.prepare(`
+        SELECT 1 FROM sessions
+        WHERE agent = 'claude'
+          AND (account_key IS NULL
+               OR (account_key LIKE 'unattributed:%' AND account IS NOT NULL))
+        LIMIT 1
+      `).get();
+            if (needsRepair)
+                db.transaction(() => backfillClaudeAccounts(db, 'unresolved'))();
+        }
+    }
     // machine column + indexes: only after the column is guaranteed present.
     // Fresh SCHEMA (v17) includes the column; older DBs get it from migrate v17.
     // If a partial upgrade left schema_version ahead of the column, repair here.
@@ -1124,7 +1202,7 @@ export function recordDirScans(entries) {
 const upsertSessionStmt = (db) => db.prepare(`
   INSERT INTO sessions (
     id, short_id, agent, origin, routine_name, routine_run_id,
-    version, account, mode, timestamp, last_activity,
+    version, account, account_key, account_org, mode, timestamp, last_activity,
     project, cwd, git_branch, topic, label, message_count, token_count,
     output_tokens, cost_usd, duration_ms, model, tool_call_count,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
@@ -1133,7 +1211,7 @@ const upsertSessionStmt = (db) => db.prepare(`
     actor, initiated_by, used_browser, used_computer
   ) VALUES (
     @id, @short_id, @agent, @origin, @routine_name, @routine_run_id,
-    @version, @account, @mode, @timestamp, @last_activity,
+    @version, @account, @account_key, @account_org, @mode, @timestamp, @last_activity,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
     @output_tokens, @cost_usd, @duration_ms, @model, @tool_call_count,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
@@ -1149,6 +1227,8 @@ const upsertSessionStmt = (db) => db.prepare(`
     routine_run_id = excluded.routine_run_id,
     version = excluded.version,
     account = excluded.account,
+    account_key = excluded.account_key,
+    account_org = excluded.account_org,
     mode = COALESCE(excluded.mode, sessions.mode),
     timestamp = excluded.timestamp,
     last_activity = excluded.last_activity,
@@ -1290,20 +1370,22 @@ function writeResourceUsageFromTallies(sessionId, skills, commands, cwd) {
     const plugins = discoverPlugins({ cwd });
     for (const { name, count } of skills) {
         const prov = resolveResourceProvenance('skills', name, cwd, plugins);
-        ins.run({
+        const bind = {
             session_id: sessionId, kind: 'skill', name, count,
             plugin: prov.plugin ?? null, source: prov.source ?? null,
             repo_root: prov.repoRoot ?? null, snapshot_sha: prov.snapshotSha ?? null,
-        });
+        };
+        ins.run(bind);
     }
     for (const { name, count } of commands) {
         const bare = name.replace(/^\//, '');
         const prov = resolveResourceProvenance('commands', bare, cwd, plugins);
-        ins.run({
+        const bind = {
             session_id: sessionId, kind: 'command', name: bare, count,
             plugin: prov.plugin ?? null, source: prov.source ?? null,
             repo_root: prov.repoRoot ?? null, snapshot_sha: prov.snapshotSha ?? null,
-        });
+        };
+        ins.run(bind);
     }
 }
 /**
@@ -1392,6 +1474,8 @@ export function upsertSession(meta, content, scan) {
         routine_run_id: meta.routineRunId ?? null,
         version: meta.version ?? null,
         account: meta.account ?? null,
+        account_key: meta.accountKey ?? null,
+        account_org: meta.accountOrg ?? null,
         mode: meta.mode ?? actorRec?.mode ?? null,
         timestamp: meta.timestamp,
         last_activity: resolveLastActivity(meta, scan),
@@ -1547,7 +1631,12 @@ export function upsertSessionsBatch(entries) {
                 writeResourceUsageFromTallies(meta.id, meta.skillsUsed ?? [], meta.slashCommandsUsed ?? [], meta.cwd);
             }
             try {
-                upsert.run({
+                // Typed, not a bare literal: bun binds named parameters in strict mode, where a
+                // MISSING key throws (node binds NULL instead). A silently dropped key therefore
+                // breaks only the shipped binary's runtime, and the per-row catch below swallows
+                // it — the exact shape of the bug that shipped account_key unbound. Annotating
+                // against SessionRow makes tsc reject the next omission.
+                const row = {
                     id: meta.id,
                     short_id: meta.shortId,
                     agent: meta.agent,
@@ -1556,6 +1645,8 @@ export function upsertSessionsBatch(entries) {
                     routine_run_id: meta.routineRunId ?? null,
                     version: meta.version ?? null,
                     account: meta.account ?? null,
+                    account_key: meta.accountKey ?? null,
+                    account_org: meta.accountOrg ?? null,
                     mode: meta.mode ?? actorIndex.get(meta.id)?.mode ?? null,
                     timestamp: meta.timestamp,
                     last_activity: resolveLastActivity(meta, scan),
@@ -1591,7 +1682,8 @@ export function upsertSessionsBatch(entries) {
                     initiated_by: meta.initiatedBy ?? actorIndex.get(meta.id)?.initiatedBy ?? null,
                     used_browser: toolUsage.usedBrowser ? 1 : 0,
                     used_computer: toolUsage.usedComputer ? 1 : 0,
-                });
+                };
+                upsert.run(row);
                 delText.run(meta.id);
                 insText.run(meta.id, 
                 // Mirror upsertSession: index the label the upsert actually stored
@@ -1780,6 +1872,8 @@ function rowToMeta(row) {
         toolCallCount: row.tool_call_count ?? undefined,
         version: row.version ?? undefined,
         account: row.account ?? undefined,
+        accountKey: row.account_key ?? undefined,
+        accountOrg: row.account_org ?? undefined,
         mode: isSessionRunMode(row.mode) ? row.mode : undefined,
         topic: row.topic ?? undefined,
         label: row.label ?? undefined,
@@ -2075,12 +2169,23 @@ export function queryUsageRollup(options) {
         ? 'agent'
         : options.groupBy === 'project'
             ? `IFNULL(NULLIF(project, ''), '(no project)')`
-            // ISO timestamps are lexicographically date-sortable; the date is the
-            // first 10 chars (YYYY-MM-DD).
-            : `substr(timestamp, 1, 10)`;
+            : options.groupBy === 'account'
+                // A NULL account_key means this harness has no account attribution yet —
+                // the mechanism is Claude-only today (see lib/session/claude-accounts.ts).
+                // Bucket per agent so the rows are named honestly instead of being called
+                // "not indexed", which they are not, and instead of joining a real account.
+                ? `IFNULL(NULLIF(account_key, ''), 'unattributed:' || agent)`
+                // ISO timestamps are lexicographically date-sortable; the date is the
+                // first 10 chars (YYYY-MM-DD).
+                : `substr(timestamp, 1, 10)`;
     const sql = `
     SELECT
       ${keyExpr} AS key,
+      ${options.groupBy === 'account'
+        // One label per account_key by construction, so MAX just picks it out.
+        ? `MAX(CASE WHEN account_org IS NOT NULL AND account IS NOT NULL
+                    THEN account_org || ' <' || account || '>' END) AS label,`
+        : ''}
       IFNULL(SUM(cost_usd), 0) AS costUsd,
       IFNULL(SUM(duration_ms), 0) AS durationMs,
       COUNT(*) AS sessionCount,

package/dist/lib/session/discover.js

@@ -23,6 +23,7 @@ import { walkForFilesWithStat } from '../fs-walk.js';
 import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
+import { buildClaudeAccountIndex, resolveClaudeAccount } from './claude-accounts.js';
 import { extractSessionTopic, extractSlashCommandName, extractSlashCommandFromToolInput } from './prompt.js';
 import { isSkillInvocation, extractSkills, extractSlashCommands } from './highlights.js';
 import { parseAntigravity, parseCursor } from './parse.js';
@@ -891,45 +892,20 @@ async function scanRoutineArchivesIncremental(agent, onProgress) {
 // ---------------------------------------------------------------------------
 // Claude account info
 // ---------------------------------------------------------------------------
-let cachedClaudeAccount;
-/** Read the Claude OAuth account email from .claude.json across all version homes. */
-function getClaudeAccount() {
-    if (cachedClaudeAccount !== undefined)
-        return cachedClaudeAccount || undefined;
-    // Claude's active config lives at $CLAUDE_CONFIG_DIR/.claude.json; for our shim
-    // that's <version>/home/.claude/.claude.json. The home-level .claude.json is a
-    // legacy path used when Claude runs without CLAUDE_CONFIG_DIR set.
-    const candidates = [
-        path.join(HOME, '.claude', '.claude.json'),
-        path.join(HOME, '.claude.json'),
-    ];
-    for (const root of VERSIONS_ROOTS) {
-        const versionsBase = path.join(root, 'versions', 'claude');
-        if (!fs.existsSync(versionsBase))
-            continue;
-        try {
-            for (const version of fs.readdirSync(versionsBase)) {
-                candidates.push(path.join(versionsBase, version, 'home', '.claude', '.claude.json'));
-                candidates.push(path.join(versionsBase, version, 'home', '.claude.json'));
-            }
-        }
-        catch { /* versions dir unreadable */ }
-    }
-    for (const candidate of candidates) {
-        try {
-            if (!fs.existsSync(candidate))
-                continue;
-            const data = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
-            const name = data.oauthAccount?.emailAddress || data.oauthAccount?.displayName;
-            if (name) {
-                cachedClaudeAccount = name;
-                return name;
-            }
-        }
-        catch { /* auth file unreadable or malformed */ }
-    }
-    cachedClaudeAccount = '';
-    return undefined;
+let cachedClaudeAccountIndex;
+/**
+ * The account-attribution index, built at most once per scan pass.
+ *
+ * Rebuilt when `refresh` is set — `scanClaudeIncremental` does that at the start of
+ * each pass so a long-lived process (the daemon) picks up an `agents use` switch or a
+ * fresh login instead of attributing later sessions to a stale set of homes. Per-file
+ * resolution then reads the cached index, because rebuilding it per transcript would
+ * re-read every home's `.claude.json` thousands of times.
+ */
+function claudeAccountIndex(refresh = false) {
+    if (refresh || !cachedClaudeAccountIndex)
+        cachedClaudeAccountIndex = buildClaudeAccountIndex();
+    return cachedClaudeAccountIndex;
 }
 // ---------------------------------------------------------------------------
 // Claude
@@ -974,7 +950,8 @@ export function buildClaudeLabelMap() {
 }
 /** Incrementally re-scan changed Claude session files and upsert into the DB. */
 async function scanClaudeIncremental(onProgress) {
-    const account = getClaudeAccount();
+    // Rebuild once per pass; readClaudeMeta resolves each transcript against it.
+    claudeAccountIndex(true);
     const labelMap = buildClaudeLabelMap();
     // Enumerate every leaf project dir across all Claude roots. The FIRST root
     // returned by getAgentSessionDirs is the agent's live `~/.claude/projects` —
@@ -1042,7 +1019,7 @@ async function scanClaudeIncremental(onProgress) {
                 const sessionId = path.basename(filePath).replace('.jsonl', '');
                 const label = labelMap.get(sessionId) ?? undefined;
                 const priorRow = priorStates.get(filePath);
-                const result = await readClaudeMeta(filePath, sessionId, scan, priorRow, account, label);
+                const result = await readClaudeMeta(filePath, sessionId, scan, priorRow, label);
                 if (result) {
                     entries.push({
                         meta: result.meta,
@@ -1079,7 +1056,7 @@ async function scanClaudeIncremental(onProgress) {
  * the serialized continuation (parser_state + content_text) to persist for the
  * next scan.
  */
-async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account, label) {
+async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
     const prior = parsePriorClaudeState(priorRow);
     const { scan, newState, toolCalls, mode } = await scanClaudeSessionResumable(filePath, prior, scanStamp.fileMtimeMs, scanStamp.fileSize, priorRow?.fileMtimeMs);
     if (mode === 'incremental')
@@ -1087,6 +1064,10 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
     else
         claudeFullScanCount++;
     const isTeamOrigin = scan.entrypoint === 'sdk-cli';
+    // Which account produced this transcript. Resolved from the path plus the version
+    // recorded inside the file, so rows under the mutable ~/.claude symlink are
+    // attributed to the version that actually wrote them. See claude-accounts.ts.
+    const acct = resolveClaudeAccount(claudeAccountIndex(), filePath, scan.version);
     let meta;
     if (scan.timestamp) {
         const cwd = normalizeCwd(scan.cwd || '');
@@ -1102,7 +1083,9 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             gitBranch: scan.gitBranch,
             version: scan.version,
             model: scan.model,
-            account,
+            account: acct.email ?? undefined,
+            accountKey: acct.key,
+            accountOrg: acct.orgName ?? undefined,
             topic: scan.topic,
             label,
             messageCount: scan.messageCount,
@@ -1134,7 +1117,9 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, account,
             timestamp: stat ? stat.mtime.toISOString() : new Date().toISOString(),
             lastActivity: scan.lastActivity,
             filePath,
-            account,
+            account: acct.email ?? undefined,
+            accountKey: acct.key,
+            accountOrg: acct.orgName ?? undefined,
             model: scan.model,
             label,
             messageCount: scan.messageCount,

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

@@ -152,7 +152,20 @@ export interface SessionMeta {
     model?: string;
     toolCallCount?: number;
     version?: string;
+    /**
+     * Email of the account that produced the session. Display-only: two orgs can share
+     * one email, so never group on this — group on `accountKey`.
+     */
     account?: string;
+    /**
+     * Org-scoped identity of the producing account (`claude:org=<uuid>`), or
+     * `unattributed:<reason>` when it cannot be established. The correct grouping key:
+     * a Team seat and a personal Max plan under one email are separate quota buckets.
+     * See lib/session/claude-accounts.ts for how a transcript is attributed.
+     */
+    accountKey?: string;
+    /** Organization display name of the producing account, when known. */
+    accountOrg?: string;
     /** Effective normalized launch mode captured by the SessionStart hook. */
     mode?: SessionRunMode;
     topic?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.18",
+  "version": "1.22.20",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",