@phnx-labs/agents-cli 1.20.72 → 1.20.74

package/dist/lib/resource-profiles.js

@@ -0,0 +1,157 @@
+/**
+ * Top-level resource profiles.
+ *
+ * These are distinct from model-provider run profiles in lib/profiles.ts. A
+ * resource profile is a global mode switch stored in agents.yaml that filters
+ * the resolved DotAgents resource view and secrets bundles.
+ */
+import { readMeta, updateMeta } from './state.js';
+import { brandProfileName } from './brand.js';
+const PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9-_]{0,48}$/i;
+const PATTERNED_KINDS = [
+    'commands',
+    'skills',
+    'hooks',
+    'subagents',
+    'plugins',
+    'workflows',
+    'permissions',
+    'mcp',
+];
+export function validateResourceProfileName(name) {
+    if (!PROFILE_NAME_PATTERN.test(name)) {
+        throw new Error(`Invalid profile name '${name}'. Use letters, digits, dash, underscore (max 48 chars).`);
+    }
+}
+export function listResourceProfileNames() {
+    return Object.keys(readMeta().profiles?.presets ?? {}).sort((a, b) => a.localeCompare(b));
+}
+export function getResourceProfilePreset(name) {
+    validateResourceProfileName(name);
+    return readMeta().profiles?.presets?.[name] ?? null;
+}
+export function getActiveResourceProfileName() {
+    // A white-label brand pins its own profile; when running under a brand
+    // (AGENTS_BRAND set) that preset wins over the global `profiles.active`, so
+    // every resource filter that keys off the active profile becomes brand-scoped.
+    // See lib/brand.ts.
+    const branded = brandProfileName();
+    if (branded)
+        return branded;
+    return readMeta().profiles?.active ?? null;
+}
+export function getActiveResourceProfile() {
+    const meta = readMeta();
+    const name = getActiveResourceProfileName();
+    if (!name)
+        return null;
+    const preset = meta.profiles?.presets?.[name];
+    return preset ? { name, preset } : null;
+}
+export function upsertResourceProfilePreset(name, preset) {
+    validateResourceProfileName(name);
+    updateMeta((meta) => ({
+        ...meta,
+        profiles: {
+            ...meta.profiles,
+            presets: {
+                ...(meta.profiles?.presets ?? {}),
+                [name]: preset,
+            },
+        },
+    }));
+}
+export function setActiveResourceProfile(name) {
+    if (name) {
+        validateResourceProfileName(name);
+        const preset = getResourceProfilePreset(name);
+        if (!preset)
+            throw new Error(`Profile '${name}' not found.`);
+    }
+    updateMeta((meta) => ({
+        ...meta,
+        profiles: {
+            ...meta.profiles,
+            active: name || undefined,
+        },
+    }));
+}
+export function patternedProfileKinds() {
+    return [...PATTERNED_KINDS];
+}
+function plainPatternMatches(pattern, name) {
+    if (pattern === '*')
+        return true;
+    if (!pattern.includes('*'))
+        return pattern === name;
+    const escaped = pattern
+        .split('*')
+        .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .join('.*');
+    return new RegExp(`^${escaped}$`).test(name);
+}
+function filterByPlainPatterns(names, patterns) {
+    const include = patterns.filter((p) => !p.startsWith('!'));
+    const exclude = patterns.filter((p) => p.startsWith('!')).map((p) => p.slice(1));
+    return names.filter((name) => include.some((p) => plainPatternMatches(p, name)) &&
+        !exclude.some((p) => plainPatternMatches(p, name)));
+}
+function sourcePatternMatches(pattern, name, sourceMap) {
+    const colon = pattern.indexOf(':');
+    if (colon === -1)
+        return false;
+    const source = pattern.slice(0, colon);
+    const rawName = pattern.slice(colon + 1);
+    const actualSource = sourceMap.get(name);
+    if (actualSource !== source)
+        return false;
+    const patternNames = rawName === '*' ? ['*'] : rawName.split(',').map((n) => n.trim()).filter(Boolean);
+    return patternNames.some((patternName) => plainPatternMatches(patternName, name));
+}
+function expandProfilePatterns(names, patterns, sourceMap) {
+    if (sourceMap) {
+        const included = new Set();
+        const excluded = new Set();
+        for (const pattern of patterns) {
+            const negate = pattern.startsWith('!');
+            const raw = negate ? pattern.slice(1) : pattern;
+            const target = negate ? excluded : included;
+            const matches = raw.includes(':')
+                ? names.filter((name) => sourcePatternMatches(raw, name, sourceMap))
+                : names.filter((name) => plainPatternMatches(raw, name));
+            for (const name of matches)
+                target.add(name);
+        }
+        return names.filter((name) => included.has(name) && !excluded.has(name));
+    }
+    return filterByPlainPatterns(names, patterns);
+}
+export function activeRulesPreset() {
+    const preset = getActiveResourceProfile()?.preset;
+    return preset?.rules ?? preset?.rulesPreset ?? null;
+}
+export function filterNamesForActiveResourceProfile(kind, names, sourceMap) {
+    const profile = getActiveResourceProfile();
+    if (!profile)
+        return names;
+    if (kind === 'memory') {
+        const rules = activeRulesPreset();
+        return rules ? names.filter((name) => name === rules) : names;
+    }
+    const patterns = profile.preset[kind];
+    if (!patterns)
+        return names;
+    return expandProfilePatterns(names, patterns, sourceMap);
+}
+export function isNameActiveInResourceProfile(kind, name, source) {
+    const sourceMap = source ? new Map([[name, source]]) : undefined;
+    return filterNamesForActiveResourceProfile(kind, [name], sourceMap).includes(name);
+}
+export function assertNameActiveInResourceProfile(kind, name) {
+    const active = getActiveResourceProfile();
+    if (!active)
+        return;
+    if (isNameActiveInResourceProfile(kind, name))
+        return;
+    throw new Error(`${kind === 'secrets' ? 'Secrets bundle' : 'Resource'} '${name}' is not active in profile '${active.name}'.`);
+}

package/dist/lib/resources/permissions.js

@@ -77,6 +77,12 @@ function getAgentConfigPath(agent, versionHome) {
             return path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
         case 'openclaw':
             return path.join(versionHome, '.openclaw', 'openclaw.json');
+        case 'copilot':
+            return path.join(versionHome, '.copilot', 'permissions-config.json');
+        case 'forge':
+            return path.join(versionHome, '.forge', 'permissions.yaml');
+        case 'hermes':
+            return path.join(versionHome, '.hermes', 'config.yaml');
         case 'goose':
             return path.join(versionHome, '.config', 'goose', 'permission.yaml');
         default:
@@ -173,7 +179,7 @@ export const PermissionsHandler = {
             merged = mergePermissionSets(merged, r.item);
         }
         // Apply to the agent's config file
-        applyPermissionsToVersion(agent, merged, versionHome, true);
+        applyPermissionsToVersion(agent, merged, versionHome, true, cwd);
     },
     /**
      * Permissions use YAML format.

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

@@ -5,7 +5,7 @@
  * - Union: All resources from all layers are combined
  * - Override on name conflict: Higher layer wins (project > user > system)
  */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'forge';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'forge';
 export type Layer = 'system' | 'user' | 'project';
 export type ResourceKind = 'command' | 'hook' | 'skill' | 'rule' | 'mcp' | 'permission' | 'subagent' | 'workflow' | 'memory';
 /** A resolved resource with its origin layer. */

package/dist/lib/resources.d.ts

@@ -5,7 +5,7 @@
 import type { AgentId } from './types.js';
 import { type SkillParseError } from './skills.js';
 /** Resource kind — matches the subdirectory name under each repo root. */
-export type ResourceKind = 'commands' | 'skills' | 'hooks' | 'rules' | 'mcp' | 'cli' | 'permissions' | 'subagents' | 'profiles' | 'secrets';
+export type ResourceKind = 'commands' | 'skills' | 'hooks' | 'rules' | 'mcp' | 'cli' | 'permissions' | 'subagents' | 'workflows' | 'profiles' | 'secrets';
 /** A resource resolved with its origin. */
 export interface ResolvedResource {
     name: string;

package/dist/lib/resources.js

@@ -14,6 +14,27 @@ import { listMcpServerConfigs } from './mcp.js';
 import { WorkflowsHandler } from './resources/workflows.js';
 import { isCapable } from './capabilities.js';
 import { getProjectAgentsDir, getUserAgentsDir, getSystemAgentsDir, getEnabledExtraRepos, } from './state.js';
+import { isNameActiveInResourceProfile } from './resource-profiles.js';
+function profiledKind(kind) {
+    switch (kind) {
+        case 'commands':
+        case 'skills':
+        case 'hooks':
+        case 'mcp':
+        case 'permissions':
+        case 'subagents':
+        case 'secrets':
+            return kind;
+        case 'rules':
+            return 'memory';
+        default:
+            return null;
+    }
+}
+function resourceIsActive(kind, name, source) {
+    const activeKind = profiledKind(kind);
+    return activeKind ? isNameActiveInResourceProfile(activeKind, name, source) : true;
+}
 /**
  * Resolve a single resource by kind + name using project > user > system precedence.
  * For file-based resources the path ends in `.md`, `.yaml`, or `.yml` as appropriate.
@@ -36,13 +57,19 @@ export function resolveResource(kind, name, cwd) {
         // Try exact name (for directories like skills/subagents)
         const exactPath = path.join(dir, name);
         if (fs.existsSync(exactPath)) {
-            return { name, path: exactPath, source };
+            if (resourceIsActive(kind, name, source)) {
+                return { name, path: exactPath, source };
+            }
+            continue;
         }
         // Try with common file extensions
         for (const ext of ['.md', '.yaml', '.yml']) {
             const withExt = exactPath + ext;
             if (fs.existsSync(withExt)) {
-                return { name, path: withExt, source };
+                if (resourceIsActive(kind, name, source)) {
+                    return { name, path: withExt, source };
+                }
+                continue;
             }
         }
     }
@@ -80,6 +107,8 @@ export function listResources(kind, cwd) {
             const rawName = entry.name.replace(/\.(md|yaml|yml)$/, '');
             if (seen.has(rawName))
                 continue;
+            if (!resourceIsActive(kind, rawName, source))
+                continue;
             seen.add(rawName);
             results.push({
                 name: rawName,
@@ -162,7 +191,7 @@ export function getAgentResources(agentId, options = {}) {
             hooks.push({ name: hook.name, path: hook.path, scope: hook.scope });
         }
     }
-    // Workflows (claude only)
+    // Workflows
     const workflows = [];
     if (isCapable(agentId, 'workflows')) {
         for (const w of WorkflowsHandler.listAll(agentId, cwd)) {

package/dist/lib/routines.d.ts

@@ -41,6 +41,10 @@ export interface GithubJobTrigger {
     repo?: string;
     /** git branch (ref short name) — when set, only payloads for this branch match. */
     branch?: string;
+    /** GitHub webhook action, e.g. `opened`, `synchronize`, or `labeled`. */
+    action?: string;
+    /** Required GitHub label name. For `pull_request.labeled`, this is the added label. */
+    label?: string;
 }
 export interface LinearJobTrigger {
     type: 'linear_event';
@@ -184,6 +188,10 @@ export declare function checkJobDeviceEligibility(config: Pick<JobConfig, 'name'
  * 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.
@@ -191,6 +199,9 @@ export declare function checkJobDeviceEligibility(config: Pick<JobConfig, 'name'
 export declare function listJobs(cwd?: string): JobConfig[];
 /**
  * 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).

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