@phnx-labs/agents-cli 1.15.0 → 1.16.0

package/dist/lib/models.js

@@ -11,8 +11,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
 import { getVersionDir } from './versions.js';
-import { getAgentsDir } from './state.js';
-const CACHE_PATH = path.join(getAgentsDir(), '.models-cache.json');
+import { getModelsCachePath } from './state.js';
+const CACHE_PATH = getModelsCachePath();
 /**
  * Bump when the extractor logic changes shape in an incompatible way so cached
  * catalogs from older agents-cli builds are re-extracted.

package/dist/lib/permissions.d.ts

@@ -42,26 +42,26 @@ export declare function discoverPermissionGroups(): PermissionGroupInfo[];
  */
 export declare function getTotalPermissionRuleCount(): number;
 /**
- * A permission set recipe — names a set and lists which groups it composes.
- * Lives at ~/.agents/permissions/sets/<name>.yaml.
+ * A permission preset recipe — names a preset and lists which groups it composes.
+ * Lives at ~/.agents/permissions/presets/<name>.yaml.
  */
-export interface PermissionSetRecipe {
+export interface PermissionPresetRecipe {
     name: string;
     description?: string;
     includes: string[];
 }
 /** Env var that selects which set recipe to apply at sync time. */
-export declare const PERMISSION_SET_ENV_VAR = "AGENTS_PERMISSION_SET";
+export declare const PERMISSION_PRESET_ENV_VAR = "AGENTS_PERMISSION_PRESET";
 /**
- * Read a permission set recipe by name from ~/.agents/permissions/sets/.
+ * Read a permission preset recipe by name from ~/.agents/permissions/presets/.
  * Returns null if the recipe file is missing or malformed.
  */
-export declare function readPermissionSetRecipe(name: string): PermissionSetRecipe | null;
+export declare function readPermissionPresetRecipe(name: string): PermissionPresetRecipe | null;
 /**
- * Return the active permission set name from AGENTS_PERMISSION_SET env var,
+ * Return the active permission preset name from AGENTS_PERMISSION_PRESET env var,
  * or null if unset. Caller decides the default behavior when null.
  */
-export declare function getActivePermissionSetName(): string | null;
+export declare function getActivePermissionPresetName(): string | null;
 /**
  * Build a PermissionSet from selected groups.
  * Concatenates allow/deny rules from each group.

package/dist/lib/permissions.js

@@ -159,15 +159,15 @@ export function getTotalPermissionRuleCount() {
     return groups.reduce((sum, g) => sum + g.ruleCount, 0);
 }
 /** Env var that selects which set recipe to apply at sync time. */
-export const PERMISSION_SET_ENV_VAR = 'AGENTS_PERMISSION_SET';
+export const PERMISSION_PRESET_ENV_VAR = 'AGENTS_PERMISSION_PRESET';
 /**
- * Read a permission set recipe by name from ~/.agents/permissions/sets/.
+ * Read a permission preset recipe by name from ~/.agents/permissions/presets/.
  * Returns null if the recipe file is missing or malformed.
  */
-export function readPermissionSetRecipe(name) {
-    const setsDir = path.join(getPermissionsDir(), 'sets');
+export function readPermissionPresetRecipe(name) {
+    const presetsDir = path.join(getPermissionsDir(), 'presets');
     for (const ext of ['.yaml', '.yml']) {
-        const filePath = safeJoin(setsDir, name + ext);
+        const filePath = safeJoin(presetsDir, name + ext);
         if (!fs.existsSync(filePath))
             continue;
         try {
@@ -190,11 +190,11 @@ export function readPermissionSetRecipe(name) {
     return null;
 }
 /**
- * Return the active permission set name from AGENTS_PERMISSION_SET env var,
+ * Return the active permission preset name from AGENTS_PERMISSION_PRESET env var,
  * or null if unset. Caller decides the default behavior when null.
  */
-export function getActivePermissionSetName() {
-    const v = process.env[PERMISSION_SET_ENV_VAR];
+export function getActivePermissionPresetName() {
+    const v = process.env[PERMISSION_PRESET_ENV_VAR];
     return v && v.trim() ? v.trim() : null;
 }
 /**

package/dist/lib/plugins.d.ts

@@ -73,7 +73,36 @@ export declare function removePluginFromVersion(pluginName: string, pluginRoot:
 };
 /**
  * Remove orphaned plugin skill directories from a version home.
+ * Soft-deletes to ~/.agents/.trash/plugins/.
  * An orphan is a skill dir with the plugin prefix pattern (name--skill)
  * where the plugin no longer exists in ~/.agents/plugins/.
  */
-export declare function cleanOrphanedPluginSkills(agent: AgentId, versionHome: string, activePluginNames: Set<string>): string[];
+export declare function cleanOrphanedPluginSkills(agent: AgentId, versionHome: string, activePluginNames: Set<string>, version?: string): string[];
+export interface VersionPluginDiff {
+    agent: AgentId;
+    version: string;
+    orphans: string[];
+}
+/**
+ * Compare a version home's plugin skills against discovered plugins.
+ * Returns orphan plugin skill names (pattern: pluginName--skillName).
+ */
+export declare function diffVersionPlugins(agent: AgentId, version: string): VersionPluginDiff;
+/**
+ * Iterate all (agent, version) pairs that support plugins and are installed.
+ */
+export declare function iterPluginsCapableVersions(filter?: {
+    agent?: AgentId;
+    version?: string;
+}): Array<{
+    agent: AgentId;
+    version: string;
+}>;
+/**
+ * Remove a single orphan plugin skill from a version home.
+ * Soft-deletes to ~/.agents/.trash/plugins/.
+ */
+export declare function removePluginSkillFromVersion(agent: AgentId, version: string, skillName: string): {
+    success: boolean;
+    error?: string;
+};

package/dist/lib/plugins.js

@@ -7,7 +7,8 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { getPluginsDir } from './state.js';
+import { getPluginsDir, getTrashPluginsDir } from './state.js';
+import { listInstalledVersions, getVersionHomePath } from './versions.js';
 import { AGENTS, PLUGINS_CAPABLE_AGENTS } from './agents.js';
 const PLUGIN_MANIFEST_DIR = '.claude-plugin';
 const PLUGIN_MANIFEST_FILE = 'plugin.json';
@@ -527,10 +528,11 @@ export function removePluginFromVersion(pluginName, pluginRoot, agent, versionHo
 }
 /**
  * Remove orphaned plugin skill directories from a version home.
+ * Soft-deletes to ~/.agents/.trash/plugins/.
  * An orphan is a skill dir with the plugin prefix pattern (name--skill)
  * where the plugin no longer exists in ~/.agents/plugins/.
  */
-export function cleanOrphanedPluginSkills(agent, versionHome, activePluginNames) {
+export function cleanOrphanedPluginSkills(agent, versionHome, activePluginNames, version) {
     const removed = [];
     const skillsDir = path.join(versionHome, `.${agent}`, 'skills');
     if (!fs.existsSync(skillsDir))
@@ -546,7 +548,11 @@ export function cleanOrphanedPluginSkills(agent, versionHome, activePluginNames)
         const pluginName = entry.name.slice(0, dashIdx);
         if (!activePluginNames.has(pluginName)) {
             try {
-                fs.rmSync(path.join(skillsDir, entry.name), { recursive: true, force: true });
+                const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const trashDir = path.join(getTrashPluginsDir(), agent, version || 'unknown', entry.name);
+                const trashDest = path.join(trashDir, stamp);
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(path.join(skillsDir, entry.name), trashDest);
                 removed.push(entry.name);
             }
             catch {
@@ -556,3 +562,69 @@ export function cleanOrphanedPluginSkills(agent, versionHome, activePluginNames)
     }
     return removed;
 }
+/**
+ * Compare a version home's plugin skills against discovered plugins.
+ * Returns orphan plugin skill names (pattern: pluginName--skillName).
+ */
+export function diffVersionPlugins(agent, version) {
+    const versionHome = getVersionHomePath(agent, version);
+    const skillsDir = path.join(versionHome, `.${agent}`, 'skills');
+    const orphans = [];
+    if (!fs.existsSync(skillsDir)) {
+        return { agent, version, orphans };
+    }
+    const activePlugins = new Set(discoverPlugins().map(p => p.name));
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const dashIdx = entry.name.indexOf('--');
+        if (dashIdx === -1)
+            continue;
+        const pluginName = entry.name.slice(0, dashIdx);
+        if (!activePlugins.has(pluginName)) {
+            orphans.push(entry.name);
+        }
+    }
+    return { agent, version, orphans: orphans.sort() };
+}
+/**
+ * Iterate all (agent, version) pairs that support plugins and are installed.
+ */
+export function iterPluginsCapableVersions(filter) {
+    const pairs = [];
+    const agents = filter?.agent ? [filter.agent] : PLUGINS_CAPABLE_AGENTS;
+    for (const agent of agents) {
+        if (!PLUGINS_CAPABLE_AGENTS.includes(agent))
+            continue;
+        const versions = listInstalledVersions(agent);
+        for (const version of versions) {
+            if (filter?.version && filter.version !== version)
+                continue;
+            pairs.push({ agent, version });
+        }
+    }
+    return pairs;
+}
+/**
+ * Remove a single orphan plugin skill from a version home.
+ * Soft-deletes to ~/.agents/.trash/plugins/.
+ */
+export function removePluginSkillFromVersion(agent, version, skillName) {
+    const versionHome = getVersionHomePath(agent, version);
+    const skillPath = path.join(versionHome, `.${agent}`, 'skills', skillName);
+    if (!fs.existsSync(skillPath)) {
+        return { success: true };
+    }
+    try {
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const trashDir = path.join(getTrashPluginsDir(), agent, version, skillName);
+        const trashDest = path.join(trashDir, stamp);
+        fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+        fs.renameSync(skillPath, trashDest);
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+    return { success: true };
+}

package/dist/lib/pty-server.js

@@ -14,7 +14,7 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import { execFileSync } from 'child_process';
 import { fileURLToPath } from 'url';
-import { getAgentsDir } from './state.js';
+import { getPtyDir as getPtyDirRoot } from './state.js';
 /**
  * Capture a stable identifier for a process at the moment it was started.
  * Used to defeat PID reuse: a kill(pid, ...) is only safe when the process
@@ -53,7 +53,6 @@ export function captureProcessStartTime(pid) {
 }
 // --- Constants ---
 const SENTINEL = '__AGENTS_PTY_DONE__';
-const PTY_DIR = 'helpers/pty';
 const SOCKET_NAME = 'pty.sock';
 const PID_FILE = 'pty.pid';
 const LOG_FILE = 'logs.jsonl';
@@ -84,7 +83,7 @@ function buildPtyEnv() {
 }
 /** Get the PTY helper directory, creating it if needed. */
 function getPtyDir() {
-    const dir = path.join(getAgentsDir(), PTY_DIR);
+    const dir = getPtyDirRoot();
     fs.mkdirSync(dir, { recursive: true });
     return dir;
 }
@@ -178,7 +177,7 @@ export async function runPtyServer() {
     }
     catch (err) {
         console.error('node-pty is required for PTY support.');
-        console.error('Install: cd ' + getAgentsDir() + '/../agents-cli && bun add node-pty');
+        console.error('Install: cd ' + '~/agents-cli && bun add node-pty');
         process.exit(1);
     }
     try {
@@ -188,7 +187,7 @@ export async function runPtyServer() {
     }
     catch {
         console.error('@xterm/headless is required for PTY support.');
-        console.error('Install: cd ' + getAgentsDir() + '/../agents-cli && bun add @xterm/headless');
+        console.error('Install: cd ' + '~/agents-cli && bun add @xterm/headless');
         process.exit(1);
     }
     const sessions = new Map();
@@ -493,11 +492,11 @@ export async function runPtyServer() {
         });
         conn.on('error', () => { });
     });
-    // Lock down ~/.agents-system/ before opening the socket — without this, any local
-    // user with execute on the parent dir could connect to the socket during
-    // the listen()-to-chmod() window. macOS BSD AF_UNIX semantics make socket
-    // mode advisory only, so the parent dir is the real boundary.
-    const agentsDir = getAgentsDir();
+    // Lock down the PTY scratch dir before opening the socket — without this,
+    // any local user with execute on the parent dir could connect to the socket
+    // during the listen()-to-chmod() window. macOS BSD AF_UNIX semantics make
+    // socket mode advisory only, so the parent dir is the real boundary.
+    const agentsDir = getPtyDirRoot();
     fs.mkdirSync(agentsDir, { recursive: true });
     fs.chmodSync(agentsDir, 0o700);
     // umask covers any inherited group/other bits while listen() is creating

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

@@ -1,7 +1,11 @@
 /**
  * HooksHandler - ResourceHandler implementation for hooks.
  *
- * Hooks are declared in hooks.yaml at each layer (system, user, project).
+ * Hook declarations live in:
+ *   - System: ~/.agents-system/hooks.yaml (npm-shipped defaults)
+ *   - User:   `hooks:` section of ~/.agents/agents.yaml
+ *   - Project: <project>/.agents/hooks.yaml
+ *
  * Resolution: project > user > system (higher layer wins on name conflict).
  * Non-conflicting hooks from all layers are unioned together.
  */

package/dist/lib/resources/hooks.js

@@ -1,7 +1,11 @@
 /**
  * HooksHandler - ResourceHandler implementation for hooks.
  *
- * Hooks are declared in hooks.yaml at each layer (system, user, project).
+ * Hook declarations live in:
+ *   - System: ~/.agents-system/hooks.yaml (npm-shipped defaults)
+ *   - User:   `hooks:` section of ~/.agents/agents.yaml
+ *   - Project: <project>/.agents/hooks.yaml
+ *
  * Resolution: project > user > system (higher layer wins on name conflict).
  * Non-conflicting hooks from all layers are unioned together.
  */
@@ -10,13 +14,20 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { getSystemAgentsDir, getUserAgentsDir, getProjectAgentsDir, } from '../state.js';
 /**
- * Get the hooks.yaml path for a given layer directory.
+ * Get the hook manifest path for a layer dir. The user layer reads from
+ * agents.yaml (hooks: section) since that's where user hooks now live.
+ * Other layers continue to use a standalone hooks.yaml.
  */
 function getHooksYamlPath(layerDir) {
+    if (layerDir === getUserAgentsDir()) {
+        return path.join(layerDir, 'agents.yaml');
+    }
     return path.join(layerDir, 'hooks.yaml');
 }
 /**
- * Parse hooks.yaml from a directory.
+ * Parse hooks for a layer directory.
+ * - User layer: read `hooks:` section from agents.yaml.
+ * - System / project layer: read top-level map from hooks.yaml.
  * Returns empty object if file doesn't exist or is invalid.
  */
 function parseHooksYaml(dir) {
@@ -27,7 +38,13 @@ function parseHooksYaml(dir) {
     try {
         const content = fs.readFileSync(manifestPath, 'utf-8');
         const parsed = yaml.parse(content);
-        return parsed || {};
+        if (!parsed)
+            return {};
+        if (dir === getUserAgentsDir()) {
+            const hooks = parsed.hooks;
+            return (hooks && typeof hooks === 'object') ? hooks : {};
+        }
+        return parsed;
     }
     catch {
         return {};

package/dist/lib/rotate.js

@@ -8,12 +8,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { getAccountInfo } from './agents.js';
-import { readMeta, writeMeta, getAgentsDir } from './state.js';
+import { readMeta, writeMeta, getHelpersDir, getUserAgentsDir } from './state.js';
 import { listInstalledVersions, getVersionHomePath, resolveVersion } from './versions.js';
 import { getUsageInfoByIdentity, getUsageLookupKey, isClaudeAuthValid, } from './usage.js';
-const ROTATE_DIR = 'helpers/rotate';
 function getRotateDir() {
-    const dir = path.join(getAgentsDir(), ROTATE_DIR);
+    const dir = path.join(getHelpersDir(), 'rotate');
     fs.mkdirSync(dir, { recursive: true });
     return dir;
 }
@@ -35,7 +34,7 @@ export function normalizeRunStrategy(value) {
 /** Read project-local run strategy from the nearest agents.yaml, if present. */
 export function getProjectRunStrategy(agent, startPath) {
     let dir = path.resolve(startPath);
-    const userAgentsYaml = path.join(getAgentsDir(), 'agents.yaml');
+    const userAgentsYaml = path.join(getUserAgentsDir(), 'agents.yaml');
     while (dir !== path.dirname(dir)) {
         const manifestPath = path.join(dir, 'agents.yaml');
         if (manifestPath !== userAgentsYaml && fs.existsSync(manifestPath)) {

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

@@ -8,7 +8,10 @@ export interface ActiveSession {
     pid?: number;
     sessionId?: string;
     cwd?: string;
+    /** User-given name from /rename command. */
     label?: string;
+    /** First meaningful line of the initial prompt (extracted topic). */
+    topic?: string;
     sessionFile?: string;
     startedAtMs?: number;
     status: ActiveStatus;

package/dist/lib/session/active.js

@@ -2,7 +2,7 @@
  * Active-session detection across every context an agent can run in:
  *
  *   - `terminal` — agents launched from VS Code / Cursor / Codium via the
- *     agents-cli extension. Published to `~/.agents/runtime/live-terminals.json`
+ *     agents-cli extension. Published to `~/.agents/.cache/terminals/live-terminals.json`
  *     with PID + session UUID per entry.
  *   - `teams`    — agents spawned by `agents teams add`, tracked in
  *     `~/.agents/teams/agents/<id>/meta.json` with a PID the manager polls.
@@ -23,10 +23,12 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { listActiveTasks } from '../cloud/store.js';
 import { AgentManager } from '../teams/agents.js';
-import { getUserAgentsDir } from '../state.js';
+import { getTerminalsDir } from '../state.js';
+import { buildClaudeLabelMap } from './discover.js';
+import { extractSessionTopic } from './prompt.js';
 const execFileAsync = promisify(execFile);
 const HOME = os.homedir();
-const LIVE_TERMINALS_FILE = path.join(getUserAgentsDir(), 'runtime', 'live-terminals.json');
+const LIVE_TERMINALS_FILE = path.join(getTerminalsDir(), 'live-terminals.json');
 /**
  * A process is classified `running` if its session file was touched in the
  * last 2 minutes. Every Claude/Codex tool-call appends an event, so a
@@ -80,9 +82,9 @@ function readLiveTerminals() {
     }
     return Array.from(merged.values());
 }
-/** Convert an absolute cwd to the Claude-project folder name (slashes → dashes). */
+/** Convert an absolute cwd to the Claude-project folder name (slashes and dots → dashes). */
 function claudeProjectDirName(cwd) {
-    return cwd.replace(/\//g, '-');
+    return cwd.replace(/[/.]/g, '-');
 }
 /**
  * Locate the active Claude session file for a process. If we know the session
@@ -126,6 +128,79 @@ function classifyActivity(sessionFile) {
         return 'running';
     }
 }
+/**
+ * Extract the first user message's content from a Claude JSONL file.
+ * Reads only the first ~50 lines for speed, since the user message is
+ * typically near the top (after system/queue events).
+ */
+function extractClaudeUserText(parsed) {
+    const msg = parsed.message;
+    if (!msg?.content)
+        return undefined;
+    const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+    const texts = [];
+    for (const block of content) {
+        if (typeof block === 'string')
+            texts.push(block);
+        else if (block?.type === 'text' && typeof block.text === 'string')
+            texts.push(block.text);
+    }
+    return texts.join('\n').trim() || undefined;
+}
+function quickExtractTopic(sessionFile) {
+    let fd;
+    try {
+        fd = fs.openSync(sessionFile, 'r');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const chunkSize = 256 * 1024;
+        const maxBytes = 2 * 1024 * 1024;
+        let buffer = '';
+        let totalRead = 0;
+        let linesChecked = 0;
+        const maxLines = 30;
+        while (totalRead < maxBytes && linesChecked < maxLines) {
+            const chunk = Buffer.alloc(chunkSize);
+            const bytesRead = fs.readSync(fd, chunk, 0, chunkSize, totalRead);
+            if (bytesRead === 0)
+                break;
+            totalRead += bytesRead;
+            buffer += chunk.toString('utf8', 0, bytesRead);
+            let lineStart = 0;
+            let lineEnd;
+            while ((lineEnd = buffer.indexOf('\n', lineStart)) !== -1 && linesChecked < maxLines) {
+                const line = buffer.slice(lineStart, lineEnd);
+                lineStart = lineEnd + 1;
+                linesChecked++;
+                if (!line.trim())
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (parsed.type === 'user') {
+                    const text = extractClaudeUserText(parsed);
+                    if (text) {
+                        const topic = extractSessionTopic(text);
+                        if (topic)
+                            return topic;
+                    }
+                }
+            }
+            buffer = buffer.slice(lineStart);
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return undefined;
+}
 /** Live teams teammates. Reuses AgentManager which already polls PIDs via `kill -0`. */
 export async function listTeamsActive() {
     const mgr = new AgentManager();
@@ -135,6 +210,7 @@ export async function listTeamsActive() {
         const sessionFile = a.agentType === 'claude' && a.cwd
             ? findClaudeSessionFile(a.cwd, sessionId ?? undefined)
             : undefined;
+        const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         return {
             context: 'teams',
             kind: a.agentType,
@@ -142,6 +218,7 @@ export async function listTeamsActive() {
             sessionId,
             cwd: a.cwd ?? undefined,
             label: a.name ?? undefined,
+            topic,
             sessionFile,
             startedAtMs: a.startedAt.getTime(),
             status: classifyActivity(sessionFile),
@@ -160,10 +237,16 @@ export async function listTerminalsActive() {
     const procByPid = new Map();
     for (const r of await readProcessTable())
         procByPid.set(r.pid, r);
+    // Build label map from Claude's sessions/*.json for /rename support
+    const labelMap = buildClaudeLabelMap();
     return entries.map((t) => {
         const sessionFile = t.kind === 'claude' && t.cwd
             ? findClaudeSessionFile(t.cwd, t.sessionId)
             : undefined;
+        // Prefer label from live terminal, fall back to Claude's session label
+        const label = t.label ?? (t.sessionId ? labelMap.get(t.sessionId) : undefined) ?? undefined;
+        // Extract topic from session file (first meaningful user message)
+        const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         return {
             context: 'terminal',
             kind: t.kind,
@@ -171,7 +254,8 @@ export async function listTerminalsActive() {
             pid: t.pid,
             sessionId: t.sessionId,
             cwd: t.cwd ?? undefined,
-            label: t.label ?? undefined,
+            label,
+            topic,
             sessionFile,
             startedAtMs: t.startedAtMs,
             status: classifyActivity(sessionFile),
@@ -355,6 +439,7 @@ export async function listUnattributedActive(attributed) {
         const { pid, kind } = candidates[i];
         const cwd = cwds[i];
         const sessionFile = kind === 'claude' && cwd ? findClaudeSessionFile(cwd) : undefined;
+        const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const host = detectHost(pid, procByPid);
         const context = host && UI_HOSTS.has(host) ? 'terminal' : 'headless';
         out.push({
@@ -363,6 +448,7 @@ export async function listUnattributedActive(attributed) {
             host,
             pid,
             cwd,
+            topic,
             sessionFile,
             status: classifyActivity(sessionFile),
         });

package/dist/lib/session/cloud.js

@@ -13,10 +13,10 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
-import { getAgentsDir } from '../state.js';
+import { getCacheDir } from '../state.js';
 const PROXY_BASE = process.env.RUSH_PROXY_BASE ?? 'https://api.prix.dev';
 const USER_YAML = path.join(os.homedir(), '.rush', 'user.yaml');
-const CLOUD_CACHE_DIR = path.join(getAgentsDir(), 'cache', 'cloud-runs');
+const CLOUD_CACHE_DIR = path.join(getCacheDir(), 'cloud-runs');
 function readToken() {
     if (!fs.existsSync(USER_YAML)) {
         throw new Error('Not logged in to Rush. Run `rush login` first.');

package/dist/lib/session/db.js

@@ -9,9 +9,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from '../sqlite.js';
-import { getUserAgentsDir } from '../state.js';
-const SESSIONS_DIR = path.join(getUserAgentsDir(), 'sessions');
-const DB_PATH = path.join(SESSIONS_DIR, 'sessions.db');
+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 = 5;
 /**
@@ -151,6 +151,11 @@ export function getDB() {
     db.pragma('journal_mode = WAL');
     db.pragma('synchronous = NORMAL');
     db.pragma('temp_store = MEMORY');
+    // Wait up to 10s instead of failing immediately on SQLITE_BUSY. Multiple
+    // agents (CLIs, indexers, hooks) all open this DB concurrently; without a
+    // busy timeout, parallel writers throw "database is locked" the moment one
+    // holds the write lock. 10s is well above any realistic transaction here.
+    db.pragma('busy_timeout = 10000');
     db.exec(SCHEMA);
     const current = db.prepare(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
     const currentVersion = current ? parseInt(current.value, 10) : 0;