@phnx-labs/agents-cli 1.20.71 → 1.20.73

package/dist/lib/routines.js

@@ -107,11 +107,29 @@ const JOB_DEFAULTS = {
     timeout: '10m',
     enabled: true,
 };
+function overlayUserRoutineDevices(job, userJob) {
+    if (job.devices !== undefined)
+        return job;
+    if (!userJob)
+        return job;
+    const merged = { ...job };
+    if (userJob.devices && userJob.devices.length > 0) {
+        merged.devices = userJob.devices;
+    }
+    else {
+        delete merged.devices;
+    }
+    return merged;
+}
 /**
  * List all job configs, scanning project > user > system routine dirs.
  * Higher layers shadow lower ones of the same name (first-seen wins): a project
  * routine shadows a user routine, and a user routine shadows a built-in system
  * routine (`~/.agents/.system/routines/`, shipped via gh:phnx-labs/.agents-system).
+ * When a same-name project routine wins for inspection, the user-layer
+ * `devices` allowlist is overlaid only if the project routine does not declare
+ * its own allowlist, so CWD project discovery cannot hide an operational fleet
+ * pin or erase a project-authored one.
  * Project discovery is opt-in via `cwd`; the daemon (which calls `listJobs()`
  * with no argument) sees user + system routines, so a built-in routine fires for
  * every install unless the user overrides or disables it by name.
@@ -120,22 +138,26 @@ export function listJobs(cwd) {
     ensureAgentsDir();
     const seen = new Set();
     const jobs = [];
+    const userDir = getRoutinesDir();
     const dirs = [];
     if (cwd) {
         const projectDir = getProjectRoutinesDir(cwd);
         if (projectDir)
-            dirs.push(projectDir);
+            dirs.push({ scope: 'project', path: projectDir });
     }
-    dirs.push(getRoutinesDir());
-    dirs.push(getSystemRoutinesDir());
-    for (const dir of dirs) {
+    dirs.push({ scope: 'user', path: userDir });
+    dirs.push({ scope: 'system', path: getSystemRoutinesDir() });
+    for (const { scope, path: dir } of dirs) {
         if (!fs.existsSync(dir))
             continue;
         const files = fs.readdirSync(dir).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
         for (const file of files) {
-            const job = readJobFile(path.join(dir, file));
+            let job = readJobFile(path.join(dir, file));
             if (!job)
                 continue;
+            if (scope === 'project') {
+                job = overlayUserRoutineDevices(job, readJobFromDir(userDir, job.name));
+            }
             if (seen.has(job.name))
                 continue;
             seen.add(job.name);
@@ -146,26 +168,39 @@ export function listJobs(cwd) {
 }
 /**
  * Read a single job config by name, checking project > user > system.
+ * Same-name project routines keep the user-layer `devices` allowlist only when
+ * the project routine does not declare its own allowlist, for the same reason
+ * as listJobs().
  * Project discovery is opt-in via `cwd`; daemon callers pass no argument and
  * resolve user + system routines (a user routine of the same name shadows a
  * built-in system routine).
  */
 export function readJob(name, cwd) {
     ensureAgentsDir();
+    const userDir = getRoutinesDir();
     const dirs = [];
     if (cwd) {
         const projectDir = getProjectRoutinesDir(cwd);
         if (projectDir)
-            dirs.push(projectDir);
-    }
-    dirs.push(getRoutinesDir());
-    dirs.push(getSystemRoutinesDir());
-    for (const dir of dirs) {
-        for (const ext of ['.yml', '.yaml']) {
-            const filePath = safeJoin(dir, name + ext);
-            if (fs.existsSync(filePath)) {
-                return readJobFile(filePath);
-            }
+            dirs.push({ scope: 'project', path: projectDir });
+    }
+    dirs.push({ scope: 'user', path: userDir });
+    dirs.push({ scope: 'system', path: getSystemRoutinesDir() });
+    for (const { scope, path: dir } of dirs) {
+        const job = readJobFromDir(dir, name);
+        if (job) {
+            if (scope === 'project')
+                return overlayUserRoutineDevices(job, readJobFromDir(userDir, name));
+            return job;
+        }
+    }
+    return null;
+}
+function readJobFromDir(dir, name) {
+    for (const ext of ['.yml', '.yaml']) {
+        const filePath = safeJoin(dir, name + ext);
+        if (fs.existsSync(filePath)) {
+            return readJobFile(filePath);
         }
     }
     return null;
@@ -440,6 +475,12 @@ export function validateTrigger(trigger) {
         if (github.branch !== undefined && typeof github.branch !== 'string') {
             errors.push('trigger.branch must be a string');
         }
+        if (github.action !== undefined && typeof github.action !== 'string') {
+            errors.push('trigger.action must be a string');
+        }
+        if (github.label !== undefined && typeof github.label !== 'string') {
+            errors.push('trigger.label must be a string');
+        }
         return errors;
     }
     const linear = t;

package/dist/lib/runner.d.ts

@@ -25,6 +25,7 @@ export interface RunResult {
 }
 /** Build the full CLI argv for executing a job, applying mode, model, and permission flags. */
 export declare function buildJobCommand(config: JobConfig, resolvedPrompt: string): string[];
+export declare function archiveRoutineTranscripts(meta: Pick<RunMeta, 'jobName' | 'runId' | 'agent'>, runDir: string, overlayHome?: string): void;
 /** Pre-flight version/account selection for a routine job. */
 export interface RoutineLaunchPlan {
     /** Ordered attempts: primary first, then same-agent failover accounts. */

package/dist/lib/runner.js

@@ -19,13 +19,14 @@ import * as path from 'path';
 import * as os from 'os';
 import { resolveJobPrompt, parseTimeout, writeRunMeta, getRunDir, checkJobDeviceEligibility, finalizeRunMeta, } from './routines.js';
 import { getRunsDir } from './state.js';
-import { prepareJobHome, buildSpawnEnv } from './sandbox.js';
+import { prepareJobHome, buildSpawnEnv, getJobHomePath } from './sandbox.js';
 import { resolveModel, buildReasoningFlags } from './models.js';
 import { createTimer, maybeRotate, redactPrompt } from './events.js';
 import { normalizeMode, resolveHeadlessMode, buildExecEnv, detectRateLimit, } from './exec.js';
 import { loadTask as loadHostTask } from './hosts/tasks.js';
 import { reconcileTask as reconcileHostTask } from './hosts/reconcile.js';
 import { backgroundSpawnOptions } from './platform/process.js';
+import { walkForFiles } from './fs-walk.js';
 import { getBinaryPath, isVersionInstalled, resolveVersion } from './versions.js';
 import { getConfiguredRunStrategy, resolveRunVersion, rotationFailoverChain, readinessFromCandidate, } from './rotate.js';
 /** CLI command templates per agent, with {prompt} as a placeholder. */
@@ -36,6 +37,10 @@ const AGENT_COMMANDS = {
     kimi: ['kimi', '--prompt', '{prompt}', '--output-format', 'stream-json'],
     droid: ['droid', 'exec', '{prompt}', '-o', 'stream-json'],
 };
+const ROUTINE_TRANSCRIPT_SPECS = {
+    claude: [{ root: ['.claude', 'projects'], ext: '.jsonl' }],
+    codex: [{ root: ['.codex', 'sessions'], ext: '.jsonl' }],
+};
 /** Build the full CLI argv for executing a job, applying mode, model, and permission flags. */
 export function buildJobCommand(config, resolvedPrompt) {
     // Workflow branch: delegate to `agents run <workflow>` which handles subagent
@@ -184,6 +189,35 @@ function appendModelAndReasoning(cmd, config) {
 function generateRunId() {
     return new Date().toISOString().replace(/[:.]/g, '-');
 }
+export function archiveRoutineTranscripts(meta, runDir, overlayHome) {
+    if (!meta.agent)
+        return;
+    const specs = ROUTINE_TRANSCRIPT_SPECS[meta.agent];
+    if (!specs)
+        return;
+    const home = overlayHome ?? getJobHomePath(meta.jobName);
+    for (const spec of specs) {
+        const sourceRoot = path.join(home, ...spec.root);
+        if (!fs.existsSync(sourceRoot))
+            continue;
+        const destRoot = path.join(runDir, 'sessions', meta.agent, spec.root[spec.root.length - 1]);
+        for (const sourcePath of walkForFiles(sourceRoot, spec.ext, 100_000)) {
+            const rel = path.relative(sourceRoot, sourcePath);
+            if (rel.startsWith('..') || path.isAbsolute(rel))
+                continue;
+            const destPath = path.join(destRoot, rel);
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            try {
+                fs.copyFileSync(sourcePath, destPath);
+                fs.chmodSync(destPath, 0o600);
+            }
+            catch {
+                // The process already reached a terminal state; a concurrently removed
+                // transcript should not rewrite that outcome.
+            }
+        }
+    }
+}
 /**
  * Build the argv for a command-mode routine: run the shell string directly
  * through the platform shell. No agent binary, no rotation, no sandbox.
@@ -533,6 +567,7 @@ export async function executeJob(config, deps) {
         finalizeRunMeta(meta, loopFailed ? 'failed' : 'completed', loopFailed ? 1 : 0, loopFailed ? { errorMessage: `loop stopped: ${loopResult.stoppedBy}` } : undefined);
         writeRunMeta(meta);
         timer.end({ status: meta.status, exitCode: meta.exitCode ?? undefined, runId });
+        archiveRoutineTranscripts(meta, runDir, overlayHome);
         return { meta, reportPath: null };
     }
     // Single-shot path: build the command once, then walk the launch chain on
@@ -577,6 +612,7 @@ export async function executeJob(config, deps) {
             writeRunMeta(meta);
             timer.end({ status: 'timeout', runId });
             const reportPath = extractAndSaveReport(stdoutPath, effectiveAgent, runDir);
+            archiveRoutineTranscripts(meta, runDir, overlayHome);
             return { meta, reportPath };
         }
         if (attempt.status === 'completed') {
@@ -584,6 +620,7 @@ export async function executeJob(config, deps) {
             writeRunMeta(meta);
             timer.end({ status: 'completed', exitCode: 0, runId });
             const reportPath = extractAndSaveReport(stdoutPath, effectiveAgent, runDir);
+            archiveRoutineTranscripts(meta, runDir, overlayHome);
             return { meta, reportPath };
         }
         // Failed — cascade only on rate/usage limit when more chain entries remain.
@@ -608,6 +645,7 @@ export async function executeJob(config, deps) {
             ...(attempt.error ? { error: attempt.error } : {}),
         });
         const reportPath = extractAndSaveReport(stdoutPath, effectiveAgent, runDir);
+        archiveRoutineTranscripts(meta, runDir, overlayHome);
         return { meta, reportPath };
     }
     // Unreachable: chain is always non-empty, but keep a safe fallback.
@@ -830,13 +868,32 @@ export async function executeJobDetached(config) {
         ...backgroundSpawnOptions({ fdStdio: true }),
         env: spawnEnv,
     });
+    let settled = false;
+    const settle = (status, exitCode, errorMessage) => {
+        if (settled)
+            return;
+        settled = true;
+        finalizeRunMeta(meta, status, exitCode, errorMessage ? { errorMessage } : undefined);
+        writeRunMeta(meta);
+        archiveRoutineTranscripts(meta, runDir, overlayHome);
+        if (status !== 'timeout')
+            extractAndSaveReport(stdoutPath, effectiveAgent, runDir);
+    };
+    child.on('exit', (code) => {
+        const inferred = inferFinalStatusFromLog(stdoutPath, effectiveAgent);
+        if (inferred) {
+            settle(inferred.status, inferred.exitCode);
+        }
+        else {
+            settle(code === 0 ? 'completed' : 'failed', code ?? 1);
+        }
+    });
     child.on('error', (err) => {
         try {
             fs.closeSync(stdoutFd);
         }
         catch { /* fd already closed */ }
-        finalizeRunMeta(meta, 'failed', 1, { errorMessage: err.message });
-        writeRunMeta(meta);
+        settle('failed', 1, err.message);
         process.stderr.write(`[agents] daemon: spawn failed for job "${config.name}": ${err.message}\n`);
     });
     child.unref();
@@ -1098,8 +1155,10 @@ export function monitorRunningJobs() {
                 if (Number.isFinite(wallClockMs) && wallClockMs > MAX_WALL_CLOCK_MS) {
                     finalizeRunMeta(meta, 'timeout', null, { errorMessage: 'exceeded max wall clock' });
                     writeRunMeta(meta);
-                    if (!isCommandRun)
+                    if (!isCommandRun) {
                         extractAndSaveReport(stdoutPath, meta.agent, runDirPath);
+                        archiveRoutineTranscripts(meta, runDirPath);
+                    }
                     continue;
                 }
                 if (!isPidOurs(meta.pid, meta.spawnedAt)) {
@@ -1122,8 +1181,10 @@ export function monitorRunningJobs() {
                         }
                     }
                     writeRunMeta(meta);
-                    if (!isCommandRun)
+                    if (!isCommandRun) {
                         extractAndSaveReport(stdoutPath, meta.agent, runDirPath);
+                        archiveRoutineTranscripts(meta, runDirPath);
+                    }
                 }
             }
             catch { /* corrupt or unreadable meta.json */ }

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

@@ -13,13 +13,16 @@
  *    SSH). The item-name scheme is identical, so the only difference is where
  *    bytes land. A file-backed bundle is discovered by the presence of its
  *    metadata item in the file store.
+ *  - `vault`: a single age-encrypted ~/.agents/vault.age file unlocked by
+ *    `agents login`; intended for user-managed cross-machine file sync.
  *
- * Cross-machine sync is handled by src/lib/secrets/sync.ts via an explicit
- * encrypted export/import flow; the bundle layer is sync-agnostic.
+ * Server-backed cross-machine sync is handled by src/lib/secrets/sync.ts via
+ * an explicit encrypted export/import flow; the bundle layer also supports the
+ * local vault backend for user-managed file sync.
  */
 import { type BundleValue, type SecretRef } from './index.js';
 /** Which store carries a bundle's items. */
-export type SecretsBackend = 'keychain' | 'file';
+export type SecretsBackend = 'keychain' | 'file' | 'vault';
 /**
  * Discover a bundle's backend by location: a file-backed bundle's metadata
  * item exists in the encrypted-file store. This is a plain file-existence
@@ -91,10 +94,12 @@ export interface LegacyBundleCandidate {
 }
 export declare const BUNDLE_NAME_PATTERN: RegExp;
 export declare const ENV_KEY_PATTERN: RegExp;
+export declare const BUNDLE_KEY_PATTERN: RegExp;
 export declare const BUNDLE_META_PREFIX = "agents-cli.bundles.";
 export declare const RESERVED_ENV_NAMES: Set<string>;
 export declare function bundleToEnvPrefix(name: string): string;
 export declare function isReservedEnvName(key: string): boolean;
+export declare function bundleKeyToEnvKey(key: string): string;
 export declare function isLoaderOrInterpreterEnv(name: string): boolean;
 export declare function sanitizeProcessEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** Validate a bundle name against the allowed pattern. Throws on invalid input. */
@@ -140,6 +145,7 @@ export interface WriteBundleOptions {
  */
 export declare function shouldEvictAfterBundleWrite(skipRequested: boolean, noAgentEnv: string | undefined, backendOverridden: boolean): boolean;
 export declare function writeBundle(bundle: SecretsBundle, opts?: WriteBundleOptions): void;
+export declare function writeBundleWithItems(bundle: SecretsBundle, items: Map<string, string>, opts?: WriteBundleOptions): void;
 export declare function deleteBundle(name: string): boolean;
 export declare function listBundles(): SecretsBundle[];
 export interface BundleEntryInfo {
@@ -185,7 +191,14 @@ export interface ResolveBundleOptions {
      * bundle-level expiry has passed) aborts the run before Touch ID is popped.
      */
     allowExpired?: boolean;
+    /**
+     * `process` projects dotted account keys like `GITHUB_USERNAME.personal` to
+     * the shell-safe base env name (`GITHUB_USERNAME`). Direct value lookups and
+     * backup/export flows use `storage` to preserve the exact bundle key names.
+     */
+    keyMode?: 'process' | 'storage';
 }
+export declare function canCacheResolvedEnv(bundle: SecretsBundle, selectedKeys: Set<string>, keyMode: ResolveBundleOptions['keyMode']): boolean;
 /**
  * Apply the --keys subset + expiry gate to an already-resolved snapshot from
  * the secrets-agent fast-path. The agent stores the FULL bundle env, so a