@phnx-labs/agents-cli 1.20.72 → 1.20.74

package/dist/lib/secrets/vault.js

@@ -0,0 +1,397 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawnSync } from 'child_process';
+import { armor } from 'age-encryption';
+import { getUserAgentsDir } from '../state.js';
+import { getCliLaunch } from '../cli-entry.js';
+import { atomicWriteFileSync, withFileLock } from '../fs-atomic.js';
+import { deleteKeychainToken, getKeychainToken, setKeychainToken, } from './index.js';
+const VAULT_FILE_NAME = 'vault.age';
+const VAULT_SESSION_ITEM = 'agents-cli.vault.session';
+export const VAULT_SESSION_TTL_MS = 8 * 60 * 60 * 1000;
+export const VAULT_SCRYPT_WORK_FACTOR = 18;
+const VAULT_LOCK_STALE_MS = 120_000;
+const VAULT_LOCK_ACQUIRE_TIMEOUT_MS = 180_000;
+let overrideVaultPath = null;
+let vaultDataCache = null;
+let ageOperationCountForTest = 0;
+let ageHelperLaunchForTest = null;
+export function vaultPath() {
+    return overrideVaultPath ?? process.env.AGENTS_VAULT_PATH ?? path.join(getUserAgentsDir(), VAULT_FILE_NAME);
+}
+export function vaultExists() {
+    return fs.existsSync(vaultPath());
+}
+export function _setVaultPathForTest(filePath) {
+    overrideVaultPath = filePath;
+    clearVaultDataCache();
+}
+export function _clearVaultDataCacheForTest() {
+    clearVaultDataCache();
+}
+export function _resetVaultAgeOperationCountForTest() {
+    ageOperationCountForTest = 0;
+}
+export function _getVaultAgeOperationCountForTest() {
+    return ageOperationCountForTest;
+}
+export function _setVaultAgeHelperLaunchForTest(launch) {
+    ageHelperLaunchForTest = launch;
+}
+function emptyVault() {
+    return { v: 1, bundles: {} };
+}
+function parseVault(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('Vault content is malformed.');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Vault content has an invalid shape.');
+    }
+    const obj = parsed;
+    if (obj.v !== 1 || !obj.bundles || typeof obj.bundles !== 'object' || Array.isArray(obj.bundles)) {
+        throw new Error('Vault content has an invalid shape.');
+    }
+    const bundles = {};
+    for (const [name, record] of Object.entries(obj.bundles)) {
+        if (!record || typeof record !== 'object' || Array.isArray(record)) {
+            throw new Error(`Vault bundle '${name}' has an invalid shape.`);
+        }
+        const rec = record;
+        if (rec.metadata !== undefined && typeof rec.metadata !== 'string') {
+            throw new Error(`Vault bundle '${name}' metadata is invalid.`);
+        }
+        if (!rec.keys || typeof rec.keys !== 'object' || Array.isArray(rec.keys)) {
+            throw new Error(`Vault bundle '${name}' keys are invalid.`);
+        }
+        const keys = {};
+        for (const [key, value] of Object.entries(rec.keys)) {
+            if (typeof value !== 'string')
+                throw new Error(`Vault key '${name}.${key}' is invalid.`);
+            keys[key] = value;
+        }
+        bundles[name] = { metadata: rec.metadata, keys };
+    }
+    return { v: 1, bundles };
+}
+function runAgeSync(input) {
+    ageOperationCountForTest++;
+    const launch = ageHelperLaunchForTest ?? getCliLaunch(['__vault-age-helper']);
+    const child = spawnSync(launch.command, launch.args, {
+        input: JSON.stringify(input),
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (child.status !== 0) {
+        const msg = child.stderr.trim();
+        throw new Error(msg || child.error?.message || 'age operation failed');
+    }
+    return child.stdout;
+}
+export function encrypt(key, json) {
+    return runAgeSync({
+        action: 'encrypt',
+        passphrase: key.passphrase,
+        plaintext: JSON.stringify(json),
+        scryptWorkFactor: VAULT_SCRYPT_WORK_FACTOR,
+    });
+}
+export function decrypt(key, blob) {
+    try {
+        // Validate armor in-process so malformed files fail before spawning.
+        armor.decode(blob);
+        const plaintext = runAgeSync({
+            action: 'decrypt',
+            passphrase: key.passphrase,
+            blob,
+        });
+        return parseVault(plaintext);
+    }
+    catch (err) {
+        throw new Error(`Failed to decrypt vault. Wrong password or tampered vault file. (${err.message})`);
+    }
+}
+function vaultFileStat(file) {
+    const stat = fs.statSync(file);
+    return { mtimeMs: stat.mtimeMs, size: stat.size };
+}
+function sameVaultFileStat(a, b) {
+    return a.mtimeMs === b.mtimeMs && a.size === b.size;
+}
+function clearVaultDataCache() {
+    vaultDataCache = null;
+}
+function cacheVaultData(file, key, data) {
+    vaultDataCache = {
+        file,
+        passphrase: key.passphrase,
+        stat: vaultFileStat(file),
+        data,
+    };
+}
+function vaultAlreadyExistsError(file) {
+    return new Error(`Vault file already exists: ${file}. Use --force to replace it.`);
+}
+export function createVault(password, opts = {}) {
+    if (!password)
+        throw new Error('Password is required.');
+    const file = vaultPath();
+    if (!opts.overwrite && fs.existsSync(file))
+        throw vaultAlreadyExistsError(file);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const key = { passphrase: password };
+    const data = emptyVault();
+    const blob = encrypt(key, data);
+    try {
+        fs.writeFileSync(file, blob, { mode: 0o600, flag: opts.overwrite ? 'w' : 'wx' });
+    }
+    catch (err) {
+        if (err.code === 'EEXIST')
+            throw vaultAlreadyExistsError(file);
+        throw err;
+    }
+    cacheVaultData(file, key, data);
+    cacheVaultKey(key);
+    return key;
+}
+export function joinVault(password, sourcePath, opts = {}) {
+    if (!password)
+        throw new Error('Password is required.');
+    const source = path.resolve(sourcePath);
+    const dest = vaultPath();
+    if (!opts.overwrite && fs.existsSync(dest))
+        throw vaultAlreadyExistsError(dest);
+    const blob = fs.readFileSync(source, 'utf-8');
+    const key = { passphrase: password };
+    const data = decrypt(key, blob);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    try {
+        fs.copyFileSync(source, dest, opts.overwrite ? 0 : fs.constants.COPYFILE_EXCL);
+    }
+    catch (err) {
+        if (err.code === 'EEXIST')
+            throw vaultAlreadyExistsError(dest);
+        throw err;
+    }
+    fs.chmodSync(dest, 0o600);
+    cacheVaultData(dest, key, data);
+    cacheVaultKey(key);
+    return key;
+}
+export function unlock(password) {
+    if (!password)
+        throw new Error('Password is required.');
+    const file = vaultPath();
+    if (!fs.existsSync(file))
+        throw new Error(`Vault file not found: ${file}`);
+    const key = { passphrase: password };
+    const data = decrypt(key, fs.readFileSync(file, 'utf-8'));
+    cacheVaultData(file, key, data);
+    cacheVaultKey(key);
+    return key;
+}
+export function cacheVaultKey(key, ttlMs = VAULT_SESSION_TTL_MS) {
+    const session = {
+        v: 1,
+        passphrase: key.passphrase,
+        expiresAt: Date.now() + ttlMs,
+    };
+    setKeychainToken(VAULT_SESSION_ITEM, JSON.stringify(session), { noAcl: true });
+}
+export function clearVaultKey() {
+    clearVaultDataCache();
+    deleteKeychainToken(VAULT_SESSION_ITEM);
+}
+export function getVaultSession() {
+    let raw;
+    try {
+        raw = getKeychainToken(VAULT_SESSION_ITEM);
+    }
+    catch {
+        return { loggedIn: false };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        clearVaultKey();
+        return { loggedIn: false };
+    }
+    if (parsed.v !== 1 || typeof parsed.passphrase !== 'string' || typeof parsed.expiresAt !== 'number') {
+        clearVaultKey();
+        return { loggedIn: false };
+    }
+    if (parsed.expiresAt <= Date.now()) {
+        clearVaultKey();
+        return { loggedIn: false, expiresAt: parsed.expiresAt };
+    }
+    return { loggedIn: true, key: { passphrase: parsed.passphrase }, expiresAt: parsed.expiresAt };
+}
+function requireVaultKey() {
+    const session = getVaultSession();
+    if (!session.loggedIn) {
+        throw new Error('Not logged in. Run: agents login');
+    }
+    return session.key;
+}
+function parseVaultItem(item) {
+    const metaPrefix = 'agents-cli.bundles.';
+    const keyPrefix = 'agents-cli.secrets.';
+    if (item.startsWith(metaPrefix)) {
+        return { kind: 'meta', bundle: item.slice(metaPrefix.length) };
+    }
+    if (item.startsWith(keyPrefix)) {
+        const rest = item.slice(keyPrefix.length);
+        const dot = rest.lastIndexOf('.');
+        if (dot <= 0 || dot >= rest.length - 1)
+            return null;
+        return { kind: 'key', bundle: rest.slice(0, dot), key: rest.slice(dot + 1) };
+    }
+    return null;
+}
+function vaultMissingError(file) {
+    return new Error(`Vault file is missing: ${file}. A vault was created but the file is gone` +
+        ' (a sync conflict, an undownloaded placeholder, or an accidental move/delete).' +
+        ' Restore it before writing, or run: agents login --create --force to start over.');
+}
+function readVaultData() {
+    const file = vaultPath();
+    if (!fs.existsSync(file)) {
+        // A live session means a vault was created/joined/unlocked, so the file
+        // must exist. If it is gone, refuse rather than silently starting from an
+        // empty vault (which a subsequent write would persist, destroying data).
+        if (getVaultSession().loggedIn)
+            throw vaultMissingError(file);
+        return emptyVault();
+    }
+    const key = requireVaultKey();
+    const stat = vaultFileStat(file);
+    if (vaultDataCache &&
+        vaultDataCache.file === file &&
+        vaultDataCache.passphrase === key.passphrase &&
+        sameVaultFileStat(vaultDataCache.stat, stat)) {
+        return vaultDataCache.data;
+    }
+    const data = decrypt(key, fs.readFileSync(file, 'utf-8'));
+    vaultDataCache = { file, passphrase: key.passphrase, stat, data };
+    return data;
+}
+function writeVaultData(data) {
+    const file = vaultPath();
+    const key = requireVaultKey();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    atomicWriteFileSync(file, encrypt(key, data), { encoding: 'utf-8', mode: 0o600 });
+    cacheVaultData(file, key, data);
+}
+function withVaultMutation(mutate) {
+    const file = vaultPath();
+    requireVaultKey();
+    if (!fs.existsSync(file))
+        throw vaultMissingError(file);
+    return withFileLock(file, () => {
+        const data = readVaultData();
+        const { changed, result } = mutate(data);
+        if (changed)
+            writeVaultData(data);
+        return result;
+    }, { staleMs: VAULT_LOCK_STALE_MS, acquireTimeoutMs: VAULT_LOCK_ACQUIRE_TIMEOUT_MS });
+}
+export function vaultHasItem(item) {
+    const parsed = parseVaultItem(item);
+    if (!parsed)
+        return false;
+    const data = readVaultData();
+    const bundle = data.bundles[parsed.bundle];
+    if (!bundle)
+        return false;
+    return parsed.kind === 'meta' ? bundle.metadata !== undefined : parsed.key in bundle.keys;
+}
+export function vaultGetItem(item) {
+    const parsed = parseVaultItem(item);
+    if (!parsed)
+        throw new Error(`Vault item '${item}' is invalid.`);
+    const data = readVaultData();
+    const bundle = data.bundles[parsed.bundle];
+    const value = parsed.kind === 'meta' ? bundle?.metadata : bundle?.keys[parsed.key];
+    if (value === undefined)
+        throw new Error(`Vault item '${item}' not found.`);
+    return value;
+}
+export function vaultGetItems(items) {
+    const data = readVaultData();
+    const out = new Map();
+    for (const item of items) {
+        const parsed = parseVaultItem(item);
+        if (!parsed)
+            continue;
+        const bundle = data.bundles[parsed.bundle];
+        const value = parsed.kind === 'meta' ? bundle?.metadata : bundle?.keys[parsed.key];
+        if (value !== undefined)
+            out.set(item, value);
+    }
+    return out;
+}
+export function vaultSetItem(item, value) {
+    vaultSetItems(new Map([[item, value]]));
+}
+export function vaultSetItems(items) {
+    if (items.size === 0)
+        return;
+    withVaultMutation((data) => {
+        for (const [item, value] of items) {
+            const parsed = parseVaultItem(item);
+            if (!parsed)
+                throw new Error(`Vault item '${item}' is invalid.`);
+            const bundle = data.bundles[parsed.bundle] ?? { keys: {} };
+            if (parsed.kind === 'meta')
+                bundle.metadata = value;
+            else
+                bundle.keys[parsed.key] = value;
+            data.bundles[parsed.bundle] = bundle;
+        }
+        return { changed: true, result: undefined };
+    });
+}
+export function vaultDeleteItem(item) {
+    const parsed = parseVaultItem(item);
+    if (!parsed)
+        return false;
+    return withVaultMutation((data) => {
+        const bundle = data.bundles[parsed.bundle];
+        if (!bundle)
+            return { changed: false, result: false };
+        let deleted = false;
+        if (parsed.kind === 'meta') {
+            deleted = bundle.metadata !== undefined;
+            delete bundle.metadata;
+        }
+        else {
+            deleted = parsed.key in bundle.keys;
+            delete bundle.keys[parsed.key];
+        }
+        if (bundle.metadata === undefined && Object.keys(bundle.keys).length === 0) {
+            delete data.bundles[parsed.bundle];
+        }
+        return { changed: deleted, result: deleted };
+    });
+}
+export function vaultListItems(prefix) {
+    const data = readVaultData();
+    const out = [];
+    for (const [bundleName, bundle] of Object.entries(data.bundles)) {
+        const meta = `agents-cli.bundles.${bundleName}`;
+        if (bundle.metadata !== undefined && meta.startsWith(prefix))
+            out.push(meta);
+        for (const key of Object.keys(bundle.keys)) {
+            const item = `agents-cli.secrets.${bundleName}.${key}`;
+            if (item.startsWith(prefix))
+                out.push(item);
+        }
+    }
+    return out.sort();
+}

package/dist/lib/self-heal/checks/path.js

@@ -6,12 +6,14 @@
 // Caveat: an already-open shell won't pick up the new rc/PATH entry until it reloads
 // — but new shells will, so the recurring prompt stops.
 import { resultOf } from '../types.js';
-import { isShimsInPath, addShimsToPath } from '../../shims.js';
+import { isShimsInPath, addShimsToPath, listAgentsWithNonIsolatedInstalledVersions } from '../../shims.js';
 export const pathCheck = {
     id: 'path',
     title: 'Shims directory on PATH',
     cadence: 'startup',
     async run(ctx) {
+        if (listAgentsWithNonIsolatedInstalledVersions().length === 0)
+            return resultOf([], []);
         if (isShimsInPath())
             return resultOf([], []);
         if (ctx.dryRun)

package/dist/lib/self-heal/checks/shadowing.js

@@ -5,7 +5,7 @@
 // and PATH-order problem are POSIX; Windows resolves via the registry PATH).
 import { resultOf } from '../types.js';
 import { AGENTS } from '../../agents.js';
-import { getPathShadowingExecutable, adoptShadowingLauncher, listAgentsWithInstalledVersions, } from '../../shims.js';
+import { getPathShadowingExecutable, adoptShadowingLauncher, listAgentsWithNonIsolatedInstalledVersions, } from '../../shims.js';
 import { getGlobalDefault } from '../../versions.js';
 export const shadowingCheck = {
     id: 'shadowing',
@@ -15,7 +15,15 @@ export const shadowingCheck = {
     async run(ctx) {
         const fixed = [];
         const needsAttention = [];
-        for (const agent of listAgentsWithInstalledVersions()) {
+        // Isolated-only agents are skipped outright. Adoption repoints the user's OWN
+        // launcher (e.g. the npm symlink ~/.npm-global/bin/codex) at our shim — the most
+        // invasive thing self-heal does, and the exact opposite of what `--isolated`
+        // promises. The `getGlobalDefault` guard below already blocked this in practice,
+        // since an isolated install never sets a default; but that made the boundary
+        // depend on an invariant enforced elsewhere. Any path that pins a default from
+        // an isolated copy would silently re-arm the adoption. Gate on the installs
+        // themselves so it cannot happen regardless of how a default got recorded.
+        for (const agent of listAgentsWithNonIsolatedInstalledVersions()) {
             if (!getGlobalDefault(agent))
                 continue; // only default agents, like the interactive flow
             const cmd = AGENTS[agent].cliCommand;

package/dist/lib/self-heal/checks/shims.js

@@ -4,7 +4,7 @@
 // background so the shim schema settles without user-facing churn.
 import { resultOf } from '../types.js';
 import { AGENTS } from '../../agents.js';
-import { createShim, ensureShimCurrent, ensureVersionedAliasCurrent, isShimCurrent, isVersionedAliasCurrent, shimPointsAtLiveInstall, removeLegacyUserShim, listAgentsWithInstalledVersions, listShimFileNames, pruneOrphanedCommandShim, } from '../../shims.js';
+import { createShim, ensureShimCurrent, ensureVersionedAliasCurrent, isShimCurrent, isVersionedAliasCurrent, removeShim, shimExists, shimPointsAtLiveInstall, removeLegacyUserShim, listAgentsWithInstalledVersions, listAgentsWithNonIsolatedInstalledVersions, listShimFileNames, pruneOrphanedCommandShim, } from '../../shims.js';
 import { listInstalledVersions } from '../../versions.js';
 export const shimsCheck = {
     id: 'shims',
@@ -12,20 +12,28 @@ export const shimsCheck = {
     cadence: 'frequent',
     async run(ctx) {
         const fixed = [];
+        const agentsWithBareShims = new Set(listAgentsWithNonIsolatedInstalledVersions());
         for (const agent of listAgentsWithInstalledVersions()) {
             const cmd = AGENTS[agent].cliCommand;
-            if (!isShimCurrent(agent)) {
-                if (!ctx.dryRun)
-                    ensureShimCurrent(agent);
-                fixed.push(`${cmd} shim`);
+            if (agentsWithBareShims.has(agent)) {
+                if (!isShimCurrent(agent)) {
+                    if (!ctx.dryRun)
+                        ensureShimCurrent(agent);
+                    fixed.push(`${cmd} shim`);
+                }
+                else if (!shimPointsAtLiveInstall(agent)) {
+                    // Schema is current but the baked AGENTS_BIN points at a different, removed
+                    // install (dev build, old npm-global, rotated version dir). ensureShimCurrent
+                    // would no-op on a schema-current shim, so force a rewrite to the current install.
+                    if (!ctx.dryRun)
+                        createShim(agent);
+                    fixed.push(`${cmd} shim (repointed to current install)`);
+                }
             }
-            else if (!shimPointsAtLiveInstall(agent)) {
-                // Schema is current but the baked AGENTS_BIN points at a different, removed
-                // install (dev build, old npm-global, rotated version dir). ensureShimCurrent
-                // would no-op on a schema-current shim, so force a rewrite to the current install.
+            else if (shimExists(agent)) {
                 if (!ctx.dryRun)
-                    createShim(agent);
-                fixed.push(`${cmd} shim (repointed to current install)`);
+                    removeShim(agent);
+                fixed.push(`removed ${cmd} shim (isolated-only)`);
             }
             for (const version of listInstalledVersions(agent)) {
                 if (!isVersionedAliasCurrent(agent, version)) {

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

@@ -1,10 +1,10 @@
 /**
  * Rush Cloud session source.
  *
- * Fetches cloud-captured sessions from halo/proxy (api.prix.dev) and caches
+ * Fetches cloud-captured sessions from the cloud proxy (api.prix.dev) and caches
  * them locally so the existing filesystem-based parse pipeline works unchanged.
  *
- * Endpoints consumed (implemented in halo/proxy/src/cloud-runs.ts):
+ * Endpoints consumed by the cloud proxy:
  *   GET /api/v1/cloud-runs                  → list executions
  *   GET /api/v1/cloud-runs/:id              → get one (used for meta)
  *   GET /api/v1/cloud-runs/:id/session.jsonl → raw captured jsonl

package/dist/lib/session/cloud.js

@@ -1,10 +1,10 @@
 /**
  * Rush Cloud session source.
  *
- * Fetches cloud-captured sessions from halo/proxy (api.prix.dev) and caches
+ * Fetches cloud-captured sessions from the cloud proxy (api.prix.dev) and caches
  * them locally so the existing filesystem-based parse pipeline works unchanged.
  *
- * Endpoints consumed (implemented in halo/proxy/src/cloud-runs.ts):
+ * Endpoints consumed by the cloud proxy:
  *   GET /api/v1/cloud-runs                  → list executions
  *   GET /api/v1/cloud-runs/:id              → get one (used for meta)
  *   GET /api/v1/cloud-runs/:id/session.jsonl → raw captured jsonl

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

@@ -13,6 +13,9 @@ export interface SessionRow {
     id: string;
     short_id: string;
     agent: string;
+    origin: string | null;
+    routine_name: string | null;
+    routine_run_id: string | null;
     version: string | null;
     account: string | null;
     timestamp: string;
@@ -48,6 +51,7 @@ export interface ScanStamp {
 export interface QueryOptions {
     agent?: SessionAgentId;
     agents?: SessionAgentId[];
+    origin?: 'cli' | 'routine';
     version?: string;
     cwd?: string;
     /** Match any session whose cwd equals this or is a descendant of it. */

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 = 12;
+const SCHEMA_VERSION = 13;
 /**
  * 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`
@@ -43,6 +43,9 @@ CREATE TABLE IF NOT EXISTS sessions (
   id TEXT PRIMARY KEY,
   short_id TEXT NOT NULL,
   agent TEXT NOT NULL,
+  origin TEXT DEFAULT 'cli',
+  routine_name TEXT,
+  routine_run_id TEXT,
   version TEXT,
   account TEXT,
   timestamp TEXT NOT NULL,
@@ -235,6 +238,20 @@ function migrateSchema(db, fromVersion) {
             db.exec(`ALTER TABLE sessions ADD COLUMN output_tokens INTEGER`);
         db.exec(`DELETE FROM scan_ledger;`);
     }
+    if (fromVersion < 13) {
+        // v12 → v13: routine runs archive their sandboxed transcript into the run
+        // directory and get indexed as origin='routine', linked by routine_name and
+        // routine_run_id. Existing rows are normal CLI-origin sessions.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'origin'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN origin TEXT DEFAULT 'cli'`);
+        if (!cols.some(c => c.name === 'routine_name'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN routine_name TEXT`);
+        if (!cols.some(c => c.name === 'routine_run_id'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN routine_run_id TEXT`);
+        db.exec(`UPDATE sessions SET origin = 'cli' WHERE origin IS NULL OR origin = ''`);
+        db.exec(`DELETE FROM scan_ledger;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -266,6 +283,8 @@ export function getDB() {
     // run. It must NOT live in SCHEMA (executed before migration) or an existing
     // DB would fail the index build on a column it doesn't have yet.
     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)`);
     // One-shot cleanup of the pre-SQLite JSONL indexes. Safe — nothing reads
     // them anymore. Guarded by a meta flag so we only try once.
     const cleaned = db.prepare(`SELECT value FROM meta WHERE key = 'legacy_indexes_removed'`).get();
@@ -447,13 +466,15 @@ export function recordScans(entries) {
 }
 const upsertSessionStmt = (db) => db.prepare(`
   INSERT INTO sessions (
-    id, short_id, agent, version, account, timestamp, last_activity,
+    id, short_id, agent, origin, routine_name, routine_run_id,
+    version, account, timestamp, last_activity,
     project, cwd, git_branch, topic, label, message_count, token_count,
     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,
+    @id, @short_id, @agent, @origin, @routine_name, @routine_run_id,
+    @version, @account, @timestamp, @last_activity,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
     @output_tokens, @cost_usd, @duration_ms,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
@@ -462,6 +483,9 @@ const upsertSessionStmt = (db) => db.prepare(`
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
     agent = excluded.agent,
+    origin = excluded.origin,
+    routine_name = excluded.routine_name,
+    routine_run_id = excluded.routine_run_id,
     version = excluded.version,
     account = excluded.account,
     timestamp = excluded.timestamp,
@@ -511,6 +535,9 @@ export function upsertSession(meta, content, scan) {
         id: meta.id,
         short_id: meta.shortId,
         agent: meta.agent,
+        origin: meta.origin ?? 'cli',
+        routine_name: meta.routineName ?? null,
+        routine_run_id: meta.routineRunId ?? null,
         version: meta.version ?? null,
         account: meta.account ?? null,
         timestamp: meta.timestamp,
@@ -601,6 +628,9 @@ export function upsertSessionsBatch(entries) {
                     id: meta.id,
                     short_id: meta.shortId,
                     agent: meta.agent,
+                    origin: meta.origin ?? 'cli',
+                    routine_name: meta.routineName ?? null,
+                    routine_run_id: meta.routineRunId ?? null,
                     version: meta.version ?? null,
                     account: meta.account ?? null,
                     timestamp: meta.timestamp,
@@ -778,6 +808,9 @@ function rowToMeta(row) {
         id: row.id,
         shortId: row.short_id,
         agent: row.agent,
+        origin: (row.origin === 'routine' ? 'routine' : 'cli'),
+        routineName: row.routine_name ?? undefined,
+        routineRunId: row.routine_run_id ?? undefined,
         timestamp: row.timestamp,
         lastActivity: row.last_activity ?? undefined,
         project: row.project ?? undefined,
@@ -867,6 +900,10 @@ function buildSessionWhere(options) {
         where.push('version = ?');
         params.push(options.version);
     }
+    if (options.origin) {
+        where.push("IFNULL(origin, 'cli') = ?");
+        params.push(options.origin);
+    }
     if (options.cwd) {
         where.push('cwd = ?');
         params.push(options.cwd);
@@ -887,12 +924,12 @@ function buildSessionWhere(options) {
     // for the same reason. short_id carries its own index (idx_sessions_short_id);
     // id is the PRIMARY KEY.
     if (options.idExact) {
-        where.push('(id = ? COLLATE NOCASE OR short_id = ? COLLATE NOCASE)');
-        params.push(options.idExact, options.idExact);
+        where.push('(id = ? COLLATE NOCASE OR short_id = ? COLLATE NOCASE OR routine_run_id = ? COLLATE NOCASE)');
+        params.push(options.idExact, options.idExact, options.idExact);
     }
     if (options.idPrefix) {
-        where.push('(id LIKE ? OR short_id LIKE ?)');
-        params.push(`${options.idPrefix}%`, `${options.idPrefix}%`);
+        where.push('(id LIKE ? OR short_id LIKE ? OR routine_run_id LIKE ?)');
+        params.push(`${options.idPrefix}%`, `${options.idPrefix}%`, `${options.idPrefix}%`);
     }
     if (typeof options.sinceMs === 'number') {
         // Compare as strings; ISO 8601 timestamps sort lexicographically.

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

@@ -26,6 +26,8 @@ export interface DiscoverOptions {
     excludeTeamOrigin?: boolean;
     /** Keep only team-spawned sessions (used for hidden-count queries). */
     onlyTeamOrigin?: boolean;
+    /** Keep only sessions from this source. */
+    origin?: 'cli' | 'routine';
     /** Column to order results by (all descending): 'timestamp' (default), 'cost', or 'duration'. */
     sortBy?: 'timestamp' | 'cost' | 'duration';
     /** Called as each agent makes parsing progress. Totals count only files that need re-parsing (cache misses). */