@phnx-labs/agents-cli 1.14.7 → 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.
@@ -72,21 +72,24 @@ export declare function getActivePermissionSetName(): string | null;
 export declare function buildPermissionsFromGroups(groupNames: string[]): PermissionSet;
 /**
  * List installed permission sets from central storage.
+ * User dir takes precedence; system entries are surfaced when user has no
+ * same-named override.
  */
 export declare function listInstalledPermissions(): InstalledPermission[];
 /**
- * Get a specific permission set by name.
+ * Get a specific permission set by name. Searches user dir first, then system.
  */
 export declare function getPermissionSet(name: string): InstalledPermission | null;
 /**
- * Install a permission set to central storage.
+ * Install a permission set to user-level central storage.
  */
 export declare function installPermissionSet(sourcePath: string, name: string): {
     success: boolean;
     error?: string;
 };
 /**
- * Remove a permission set from central storage.
+ * Remove a permission set from user-level central storage. System-shipped
+ * sets are intentionally not deletable from user commands.
  */
 export declare function removePermissionSet(name: string): {
     success: boolean;

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;
 }
 /**
@@ -259,55 +259,58 @@ export function buildPermissionsFromGroups(groupNames) {
 }
 /**
  * List installed permission sets from central storage.
+ * User dir takes precedence; system entries are surfaced when user has no
+ * same-named override.
  */
 export function listInstalledPermissions() {
     ensureAgentsDir();
-    const dir = getPermissionsDir();
-    if (!fs.existsSync(dir)) {
-        return [];
-    }
+    const seen = new Set();
     const results = [];
-    try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isFile())
-                continue;
-            if (!entry.name.endsWith('.yml') && !entry.name.endsWith('.yaml'))
-                continue;
-            const filePath = path.join(dir, entry.name);
-            const set = parsePermissionSet(filePath);
-            if (set) {
-                results.push({
-                    name: set.name,
-                    path: filePath,
-                    set,
-                });
+    for (const dir of [getUserPermissionsDir(), getPermissionsDir()]) {
+        if (!fs.existsSync(dir))
+            continue;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isFile())
+                    continue;
+                if (!entry.name.endsWith('.yml') && !entry.name.endsWith('.yaml'))
+                    continue;
+                const filePath = path.join(dir, entry.name);
+                const set = parsePermissionSet(filePath);
+                if (!set)
+                    continue;
+                if (seen.has(set.name))
+                    continue;
+                seen.add(set.name);
+                results.push({ name: set.name, path: filePath, set });
             }
         }
-    }
-    catch {
-        // Ignore errors
+        catch {
+            // Skip inaccessible directory
+        }
     }
     return results;
 }
 /**
- * Get a specific permission set by name.
+ * Get a specific permission set by name. Searches user dir first, then system.
  */
 export function getPermissionSet(name) {
-    const dir = getPermissionsDir();
-    for (const ext of ['.yml', '.yaml']) {
-        const filePath = safeJoin(dir, name + ext);
-        if (fs.existsSync(filePath)) {
-            const set = parsePermissionSet(filePath);
-            if (set) {
-                return { name: set.name, path: filePath, set };
+    for (const dir of [getUserPermissionsDir(), getPermissionsDir()]) {
+        for (const ext of ['.yml', '.yaml']) {
+            const filePath = safeJoin(dir, name + ext);
+            if (fs.existsSync(filePath)) {
+                const set = parsePermissionSet(filePath);
+                if (set) {
+                    return { name: set.name, path: filePath, set };
+                }
             }
         }
     }
     return null;
 }
 /**
- * Install a permission set to central storage.
+ * Install a permission set to user-level central storage.
  */
 export function installPermissionSet(sourcePath, name) {
     ensurePermissionsDir();
@@ -315,7 +318,7 @@ export function installPermissionSet(sourcePath, name) {
     if (!set) {
         return { success: false, error: 'Invalid permission file' };
     }
-    const targetPath = safeJoin(getPermissionsDir(), name + '.yml');
+    const targetPath = safeJoin(getUserPermissionsDir(), name + '.yml');
     try {
         fs.copyFileSync(sourcePath, targetPath);
         return { success: true };
@@ -325,10 +328,11 @@ export function installPermissionSet(sourcePath, name) {
     }
 }
 /**
- * Remove a permission set from central storage.
+ * Remove a permission set from user-level central storage. System-shipped
+ * sets are intentionally not deletable from user commands.
  */
 export function removePermissionSet(name) {
-    const dir = getPermissionsDir();
+    const dir = getUserPermissionsDir();
     for (const ext of ['.yml', '.yaml']) {
         const filePath = safeJoin(dir, name + ext);
         if (fs.existsSync(filePath)) {

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/routines.d.ts

@@ -96,3 +96,18 @@ export declare function installJobFromSource(sourcePath: string, name: string):
     success: boolean;
     error?: string;
 };
+/** List all job names that have run directories. */
+export declare function listJobsWithRuns(): string[];
+/** Count total runs across all jobs. */
+export declare function countAllRuns(): number;
+/** Preview runs that would be pruned (keeping only the most recent `keep` per job). */
+export declare function previewRunsPrune(keep: number): Array<{
+    jobName: string;
+    runId: string;
+    startedAt: string;
+}>;
+/** Delete old runs, keeping only the most recent `keep` per job. Returns bytes freed and run count. */
+export declare function pruneRuns(keep: number): {
+    deleted: number;
+    bytesFreed: number;
+};

package/dist/lib/routines.js

@@ -350,3 +350,71 @@ export function installJobFromSource(sourcePath, name) {
         return { success: false, error: err.message };
     }
 }
+/** List all job names that have run directories. */
+export function listJobsWithRuns() {
+    const runsDir = getRunsDir();
+    if (!fs.existsSync(runsDir))
+        return [];
+    return fs.readdirSync(runsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name);
+}
+/** Count total runs across all jobs. */
+export function countAllRuns() {
+    let total = 0;
+    for (const jobName of listJobsWithRuns()) {
+        total += listRuns(jobName).length;
+    }
+    return total;
+}
+/** Preview runs that would be pruned (keeping only the most recent `keep` per job). */
+export function previewRunsPrune(keep) {
+    const toPrune = [];
+    for (const jobName of listJobsWithRuns()) {
+        const runs = listRuns(jobName);
+        if (runs.length > keep) {
+            const toRemove = runs.slice(0, runs.length - keep);
+            for (const run of toRemove) {
+                toPrune.push({ jobName, runId: run.runId, startedAt: run.startedAt });
+            }
+        }
+    }
+    return toPrune;
+}
+/** Delete old runs, keeping only the most recent `keep` per job. Returns bytes freed and run count. */
+export function pruneRuns(keep) {
+    let deleted = 0;
+    let bytesFreed = 0;
+    for (const jobName of listJobsWithRuns()) {
+        const runs = listRuns(jobName);
+        if (runs.length <= keep)
+            continue;
+        const toRemove = runs.slice(0, runs.length - keep);
+        for (const run of toRemove) {
+            const runDir = getRunDir(jobName, run.runId);
+            bytesFreed += getDirSize(runDir);
+            fs.rmSync(runDir, { recursive: true, force: true });
+            deleted++;
+        }
+    }
+    return { deleted, bytesFreed };
+}
+function getDirSize(dirPath) {
+    if (!fs.existsSync(dirPath))
+        return 0;
+    let size = 0;
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            size += getDirSize(fullPath);
+        }
+        else {
+            try {
+                size += fs.statSync(fullPath).size;
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return size;
+}

package/dist/lib/runner.js

@@ -14,7 +14,7 @@ import { resolveJobPrompt, parseTimeout, writeRunMeta, getRunDir, } from './rout
 import { getRunsDir } from './state.js';
 import { prepareJobHome, buildSpawnEnv } from './sandbox.js';
 import { resolveModel, buildReasoningFlags } from './models.js';
-import { emitStart, maybeRotate } from './events.js';
+import { createTimer, maybeRotate, truncate } from './events.js';
 /** CLI command templates per agent, with {prompt} as a placeholder. */
 const AGENT_COMMANDS = {
     claude: ['claude', '-p', '--verbose', '{prompt}', '--output-format', 'stream-json', '--permission-mode', 'plan'],
@@ -109,11 +109,13 @@ function generateRunId() {
 /** Execute a job synchronously (waits for completion or timeout before resolving). */
 export async function executeJob(config) {
     maybeRotate();
-    const done = emitStart('agent.run.start', {
+    const timer = createTimer('agent.run', {
         agent: config.agent,
         version: config.version,
         jobName: config.name,
         mode: config.mode,
+        prompt: truncate(config.prompt, 200),
+        schedule: config.schedule,
     });
     const resolvedPrompt = resolveJobPrompt(config);
     const cmd = buildJobCommand(config, resolvedPrompt);
@@ -146,6 +148,8 @@ export async function executeJob(config) {
             detached: true,
             env: spawnEnv,
         });
+        // Mark startup time (time from function call to process spawn)
+        timer.mark('startup');
         meta.pid = child.pid || null;
         writeRunMeta(meta);
         let settled = false;
@@ -168,7 +172,7 @@ export async function executeJob(config) {
             meta.status = 'timeout';
             meta.completedAt = new Date().toISOString();
             writeRunMeta(meta);
-            done({ status: 'timeout', runId });
+            timer.end({ status: 'timeout', runId });
             const reportPath = extractAndSaveReport(stdoutPath, config.agent, runDir);
             resolve({ meta, reportPath });
         }, timeoutMs);
@@ -185,7 +189,7 @@ export async function executeJob(config) {
             meta.status = code === 0 ? 'completed' : 'failed';
             meta.completedAt = new Date().toISOString();
             writeRunMeta(meta);
-            done({ status: meta.status, exitCode: code, runId });
+            timer.end({ status: meta.status, exitCode: code ?? undefined, runId });
             const reportPath = extractAndSaveReport(stdoutPath, config.agent, runDir);
             resolve({ meta, reportPath });
         });
@@ -201,7 +205,7 @@ export async function executeJob(config) {
             meta.status = 'failed';
             meta.completedAt = new Date().toISOString();
             writeRunMeta(meta);
-            done({ status: 'failed', error: err.message, runId });
+            timer.end({ status: 'failed', error: err.message, runId });
             resolve({ meta, reportPath: null });
         });
         child.unref();