@aiwg/cli 2026.10.6 → 2026.10.8

package/dist/src/cli/handlers/marketplace.js

@@ -9,6 +9,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { sensitiveInputOptions } from '../../auth/sensitive-input.js';
 import { searchSkills } from '../../skills/registry.js';
 import { installPackage, listInstalledPackages } from '../../packages/registry.js';
 import { GitAdapter } from '../../packages/adapters/git.js';
@@ -24,7 +25,7 @@ const USAGE = [
     '  aiwg marketplace verify <package|lock>    Verify cached content and receipts offline',
     '  aiwg marketplace export <package> --output <archive.json>',
     '  aiwg marketplace import <archive.json> [--project-local]',
-    '  aiwg marketplace publish <source> --key <pem> --publisher <id>',
+    '  aiwg marketplace publish <source> --publisher <id> [--key-file <pem> | --key-stdin]',
     '  aiwg marketplace remove <catalog-id>',
     '  aiwg marketplace list                    List installed marketplace packages',
     '',
@@ -33,6 +34,11 @@ const USAGE = [
     '  --project-local    Store/read state below the target project .aiwg directory',
     '  --global           Store/read state in the user AIWG directory (default)',
     '  --policy <name>    Named trust policy or JSON policy path',
+    'Git fetch token sources:',
+    '  --token-interactive | --token-stdin | --token-file <path> | --token-store <name> | --token-env <name>',
+    'Publish key sources (multiline PEM):',
+    '  --key-interactive | --key-stdin | --key-file <path> | --key-store <name> | --key-env <name>',
+    '  --key <path>       Compatibility alias for --key-file (private file required)',
 ].join('\n');
 function parseFlag(args, flag) {
     const idx = args.indexOf(flag);
@@ -105,7 +111,10 @@ async function handleAdd(ctx) {
         const requestedRef = parseFlag(ctx.args, '--ref') ?? 'HEAD';
         const adapter = new GitAdapter();
         const source = { gitUrl: argument, ref: requestedRef, label: argument };
-        const cachePath = await adapter.fetch(source, { refresh: hasFlag(ctx.args, '--refresh') });
+        const cachePath = await adapter.fetch(source, {
+            refresh: hasFlag(ctx.args, '--refresh'),
+            tokenInput: sensitiveInputOptions(ctx.args, 'token'),
+        });
         const identity = await inspectGitCheckout(cachePath);
         const candidates = [
             path.join(cachePath, 'aiwg-marketplace-catalog.json'),
@@ -251,6 +260,7 @@ async function handleInstall(ctx) {
         }
         const installed = await installPackage(rawRef, {
             configDir,
+            tokenInput: sensitiveInputOptions(ctx.args, 'token'),
             ref,
             packageSelector: parseFlag(ctx.args, '--package'),
             refresh: hasFlag(ctx.args, '--refresh'),
@@ -342,8 +352,8 @@ async function handlePublish(ctx) {
         return argument;
     const privateKeyPath = parseFlag(ctx.args, '--key');
     const publisher = parseFlag(ctx.args, '--publisher');
-    if (!privateKeyPath || !publisher) {
-        return { exitCode: 1, message: 'Error: Usage: aiwg marketplace publish <source> --key <ed25519.pem> --publisher <id> [--output <dir>]' };
+    if (!publisher) {
+        return { exitCode: 1, message: 'Error: Usage: aiwg marketplace publish <source> [--key-file <ed25519.pem> | --key-stdin] --publisher <id> [--output <dir>]' };
     }
     try {
         const outputDir = parseFlag(ctx.args, '--output') ?? path.join(path.resolve(argument), '.aiwg', 'marketplace');
@@ -355,6 +365,7 @@ async function handlePublish(ctx) {
             sourceDir: argument,
             outputDir,
             privateKeyPath,
+            keyInput: sensitiveInputOptions(ctx.args, 'key'),
             publicKeyPath: parseFlag(ctx.args, '--public-key'),
             keyId: parseFlag(ctx.args, '--key-id'),
             publisher,

package/dist/src/cli/handlers/setup.js

@@ -1,4 +1,7 @@
 import { boundedSpawnSync } from '../../process/bounded-child-process.mjs';
+import { helperEnvironment, HELPER_ENV_ALLOWLIST } from '../../process/cli-command.mjs';
+import { readPrivateValueFile } from '../../auth/sensitive-input.js';
+import { setupJev } from '../../decision/driver.js';
 import { existsSync } from 'fs';
 import { emptyConfig, FORCE_PUSH_POLICY_ALIAS_NOTE, normalizeForcePushPolicy as normalizeForcePushPolicyShared, getConfigPath, getProjectDir, readAiwgConfig, resolveRemoteProvider, VALID_PROVIDERS, writeAiwgConfig, } from '../../config/aiwg-config.js';
 import { AiwgError, EXIT_CODES } from '../errors.js';
@@ -133,6 +136,7 @@ export function parseSetupProjectOptions(ctx) {
 }
 export function detectGitRemotes(projectDir) {
     const result = boundedSpawnSync('git', ['-C', projectDir, 'remote', '-v'], 'quick', {
+        env: helperEnvironment(),
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'ignore'],
     });
@@ -156,6 +160,7 @@ export function detectGitRemotes(projectDir) {
 }
 function detectDefaultBranch(projectDir) {
     const symbolic = boundedSpawnSync('git', ['-C', projectDir, 'symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], 'quick', {
+        env: helperEnvironment(),
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'ignore'],
     });
@@ -163,6 +168,7 @@ function detectDefaultBranch(projectDir) {
     if (symbolic.status === 0 && fromOrigin)
         return fromOrigin;
     const branch = boundedSpawnSync('git', ['-C', projectDir, 'branch', '--show-current'], 'quick', {
+        env: helperEnvironment(),
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'ignore'],
     });
@@ -170,6 +176,7 @@ function detectDefaultBranch(projectDir) {
 }
 function gitConfig(projectDir, key) {
     const result = boundedSpawnSync('git', ['-C', projectDir, 'config', '--get', key], 'quick', {
+        env: helperEnvironment(),
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'ignore'],
     });
@@ -656,7 +663,7 @@ function defaultGuidedApplyIO(plan, fresh, ctx, projectDir, frameworkRoot, canPr
                     chunks.push(Buffer.from(chunk));
                 return Buffer.concat(chunks).toString('utf8');
             } } : {}),
-        readCredentialFile: async (path) => readFile(path, 'utf8'),
+        readCredentialFile: async (path) => readPrivateValueFile(path, '--credential'),
         // stdin-at-apply prompts for the value without echoing it anywhere: the
         // label names the consumer only, and the value never reaches output.
         ...(canPrompt ? { promptCredential: async (label) => {
@@ -674,26 +681,20 @@ function defaultGuidedApplyIO(plan, fresh, ctx, projectDir, frameworkRoot, canPr
             await writeSetupPlan(projectDir, next);
         },
         owners: {
-            configureJev: async ({ action, token, options, credential }) => {
+            configureJev: async ({ action, token, options }) => {
                 if (options != null)
                     validateJevOptions(options);
                 const settings = (options ?? {});
-                const args = ['decision', 'setup', 'jev', ...(settings.remove === true ? ['--remove'] : ['--token-stdin']),
-                    ...(typeof settings.region === 'string' ? ['--region', settings.region] : []),
-                    ...(typeof settings.endpoint === 'string' ? ['--endpoint', settings.endpoint] : []),
-                    ...(settings.verify === true ? ['--verify'] : [])];
-                const environment = { ...process.env };
-                delete environment.JEV_API_KEY;
-                delete environment.AIWG_DECISION_JEV_API_KEY;
-                if (credential?.source === 'env')
-                    delete environment[credential.name];
-                const child = boundedSpawnSync(process.execPath, [join(frameworkRoot, 'bin', 'aiwg.mjs'), ...args], 'network', {
-                    cwd: action.workspace, env: environment, input: token ? `${token}\n` : '', encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
-                    maxBuffer: 1024 * 1024,
-                });
-                if (child.error || child.status !== 0)
-                    throw new Error('Jev setup failed.');
-                if (settings.verify === true && settings.remove !== true && JSON.parse(child.stdout).verified !== true) {
+                // Invoke the existing owner directly. spawnSync's input option is
+                // rendered by NODE_DEBUG=child_process before the child can read it.
+                const result = await setupJev({
+                    token,
+                    ...(typeof settings.region === 'string' ? { region: settings.region } : {}),
+                    ...(typeof settings.endpoint === 'string' ? { endpoint: settings.endpoint } : {}),
+                    verify: settings.verify === true,
+                    remove: settings.remove === true,
+                }, { env: process.env, cwd: action.workspace });
+                if (settings.verify === true && settings.remove !== true && result.verified !== true) {
                     throw new Error('Jev verification incomplete.');
                 }
             },
@@ -711,7 +712,10 @@ function defaultGuidedApplyIO(plan, fresh, ctx, projectDir, frameworkRoot, canPr
                 await writeAiwgConfig(action.workspace, next);
                 const child = boundedSpawnSync(process.execPath, [join(frameworkRoot, 'bin', 'aiwg.mjs'),
                     'doctor', '--probe-workers', '--qualify', '--yes', '--json'], 'long', {
-                    cwd: action.workspace, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 1024 * 1024,
+                    cwd: action.workspace, env: helperEnvironment(process.env, [...HELPER_ENV_ALLOWLIST,
+                        'AIWG_ROOT', 'AIWG_HOME', 'AIWG_CONFIG', 'XDG_CONFIG_HOME', 'XDG_DATA_HOME',
+                        'AIWG_ARTIFACTS_PATH', 'AIWG_PROJECT_ARTIFACTS_PATH', 'AIWG_PROJECT_AIWG_DIR',
+                        'AIWG_PROJECT_MEMORY_HOME', 'NO_UPDATE_NOTIFIER', 'NO_COLOR', 'CI']), encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 1024 * 1024,
                 });
                 if (child.error || child.status !== 0)
                     throw new Error('Worker qualification failed.');
@@ -813,7 +817,7 @@ Options:
   --intent code|docs|ops|mixed     Workspace usage intent
   --jev enable|decline|defer     Optional external decision service (default off)
   --region <r> --endpoint <url> --verify --remove --token-stdin  Existing Jev options
-  --credential <provider>=env:NAME|file:PATH|stdin  Credential reference only
+  --credential <provider>=stdin|file:PATH|store:NAME|env:NAME  Credential reference only
   --yes                           Confirm writes without prompting
   --dry-run                       Preview the setup plan
   --review                        Render the saved guided plan per workspace/provider (writes nothing)

package/dist/src/cli/handlers/use.js

@@ -1,3 +1,4 @@
+import { ContextWriteJournal } from '../../smiths/context-pipeline/context-file-safety.js';
 import { trackTemporaryDirectory } from '../../utils/temporary-directory.js';
 /**
  * Use Command Handler
@@ -1675,6 +1676,11 @@ export async function countPiAgentFiles(target, agentsPath) {
 // and additive passes can describe the same destination more than once.
 let usePreviewActions;
 // Recursive framework/addon/provider passes share the boundary's resolved policy.
+async function generateDeploymentContextFiles(options) {
+    const result = await generateContextFiles(options);
+    useDeployment?.contextFiles.push(result);
+    return result;
+}
 let useDeployment;
 function useDeploymentArgs(args) {
     const forwarded = [...args];
@@ -2118,7 +2124,7 @@ async function generateGlobalProjectContext(opts) {
         skills: userPaths.skills,
         behaviors: userPaths.behaviors,
     });
-    await generateContextFiles({
+    await generateDeploymentContextFiles({
         provider: opts.provider,
         projectPath: opts.projectPath,
         sections,
@@ -2181,7 +2187,7 @@ async function ensurePostDeployPhases(opts) {
         behaviors: paths.behaviors,
     });
     try {
-        await generateContextFiles({
+        await generateDeploymentContextFiles({
             provider: opts.provider,
             projectPath: opts.projectPath,
             sections,
@@ -2194,8 +2200,8 @@ async function ensurePostDeployPhases(opts) {
             },
         });
     }
-    catch {
-        // The shared verifier reports context or provider-wiring failures.
+    catch (error) {
+        throw new Error(`Context generation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
 async function deploySourceDirectory(opts) {
@@ -2544,11 +2550,40 @@ export class UseHandler {
         useDeployment = {
             version: previousDeployment?.version ?? resolveDeployVersion(ctx.frameworkRoot || await getFrameworkRoot()),
             skipContextFiles: previousDeployment?.skipContextFiles || ctx.args.includes('--no-context-files'),
+            contextFiles: previousDeployment?.contextFiles ?? [],
         };
+        const journal = previousDeployment ? undefined : new ContextWriteJournal();
         try {
-            return await this.executeDeployment(ctx);
+            let result;
+            try {
+                result = await this.executeDeployment(ctx);
+            }
+            catch (error) {
+                result = { exitCode: 1, message: error instanceof Error ? error.message : String(error) };
+            }
+            if (journal) {
+                const rollback = result.exitCode !== 0 ? journal.rollback() : undefined;
+                if (ctx.args.includes('--json')) {
+                    let structured;
+                    try {
+                        structured = JSON.parse(result.message || '{}');
+                    }
+                    catch {
+                        structured = { exitCode: result.exitCode, message: result.message };
+                    }
+                    structured.contextFiles = useDeployment.contextFiles;
+                    if (rollback)
+                        structured.contextRollback = rollback;
+                    result = { ...result, message: JSON.stringify(structured, null, 2), rawOutput: true };
+                }
+                else if (rollback?.conflicts.length) {
+                    result.message = [result.message, ...rollback.conflicts.map(conflict => `Context rollback conflict: ${conflict.path}: ${conflict.reason}`)].filter(Boolean).join('\n');
+                }
+            }
+            return result;
         }
         finally {
+            journal?.dispose();
             useDeployment = previousDeployment;
         }
     }
@@ -2639,6 +2674,9 @@ export class UseHandler {
         try {
             coreResult = await this.executeCore({ ...ctx, args: coreArgs });
         }
+        catch (error) {
+            coreResult = { exitCode: 1, message: error instanceof Error ? error.message : String(error) };
+        }
         finally {
             usePreviewActions = previousPreview;
             if (json || dryRun) {
@@ -2664,12 +2702,18 @@ export class UseHandler {
         else {
             if (coreResult.exitCode === 0 && !dryRun && !VALID_FRAMEWORKS.includes(requestedBundle)) {
                 for (const provider of providers) {
-                    await ensurePostDeployPhases({
-                        frameworkRoot,
-                        projectPath: projectDir,
-                        provider,
-                        args: remainingArgs,
-                    });
+                    try {
+                        await ensurePostDeployPhases({
+                            frameworkRoot,
+                            projectPath: projectDir,
+                            provider,
+                            args: remainingArgs,
+                        });
+                    }
+                    catch (error) {
+                        coreResult = { exitCode: 1, message: error instanceof Error ? error.message : String(error) };
+                        break;
+                    }
                 }
             }
             const providerResults = [];
@@ -4377,7 +4421,7 @@ export class UseHandler {
                     skills: paths.skills,
                     behaviors: paths.behaviors,
                 });
-                const ctxResult = await generateContextFiles({
+                const ctxResult = await generateDeploymentContextFiles({
                     provider: provider,
                     projectPath: target,
                     sections,
@@ -4431,10 +4475,8 @@ export class UseHandler {
                 }
             }
             catch (err) {
-                // Non-fatal: context-pipeline emission must not block deployment.
-                // Operator can re-run aiwg use to retry.
                 const msg = err instanceof Error ? err.message : String(err);
-                console.error(`Warning: context-pipeline emission failed: ${msg}`);
+                return { exitCode: 1, message: `Context generation failed: ${msg}` };
             }
         }
         span.end('use:complete', { framework });

package/dist/src/cli/prompt-utils.js

@@ -88,7 +88,16 @@ export function askWithTimeout(rl, prompt, parse, fallback, fallbackLabel, timeo
         const cleanup = () => {
             clearTimeout(timer);
             signal?.removeEventListener('abort', onAbort);
+            rl.removeListener('close', onClose);
         };
+        const onClose = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(fallback);
+        };
+        rl.on('close', onClose);
         if (signal?.aborted) {
             // Fire synchronously so the caller's try/catch sees the reject without
             // awaiting a tick.
@@ -112,6 +121,70 @@ export function askWithTimeout(rl, prompt, parse, fallback, fallbackLabel, timeo
 export async function askString(rl, prompt, fallback = '', signal) {
     return askWithTimeout(rl, prompt, (a) => a.trim(), fallback, fallback || '(empty)', promptTimeoutMs(), signal);
 }
+/** Collect a hidden paste through an empty line, with one overall prompt deadline. */
+export function askMultilineSecret(rl, signal) {
+    return new Promise((resolve, reject) => {
+        const lines = [];
+        let length = 0;
+        let settled = false;
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            rl.removeListener('line', onLine);
+            rl.removeListener('close', onClose);
+            lines.length = 0;
+        };
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(value);
+        };
+        const onLine = (line) => {
+            if (!line) {
+                finish(lines.join('\n'));
+                return;
+            }
+            length += line.length + (lines.length ? 1 : 0);
+            if (length > 16384) {
+                settled = true;
+                cleanup();
+                reject(new Error('Sensitive input exceeds 16384 characters.'));
+                return;
+            }
+            lines.push(line);
+        };
+        // A closed terminal or timeout discards incomplete input, never echoes it.
+        const onClose = () => finish('');
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            try {
+                rl.close();
+            }
+            catch { /* already closed */ }
+            reject(signal.reason ?? new Error('Aborted'));
+        };
+        const timeoutMs = promptTimeoutMs();
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            ui.warn(`  No input completed within ${Math.round(timeoutMs / 1000)}s — discarding incomplete sensitive input`);
+            finish('');
+        }, timeoutMs);
+        timer.unref?.();
+        rl.on('line', onLine);
+        rl.on('close', onClose);
+        if (signal?.aborted) {
+            onAbort();
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
 /**
  * Prompt for a yes/no answer with timeout and default. Answers starting with
  * 'y' (case-insensitive) are considered yes; everything else is no. On

package/dist/src/config/gitignore.js

@@ -13,6 +13,7 @@ import * as path from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { boundedSpawnSync } from '../process/bounded-child-process.mjs';
+import { helperEnvironment, HELPER_ENV_ALLOWLIST } from '../process/cli-command.mjs';
 const execFileAsync = promisify(execFile);
 const GITIGNORE_PROBE_BASENAME = '.aiwg-ignore-probe';
 // ===========================
@@ -94,6 +95,7 @@ async function isGitWorktree(projectRoot) {
     try {
         const { stdout } = await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], {
             cwd: projectRoot,
+            env: helperEnvironment(process.env, [...HELPER_ENV_ALLOWLIST, 'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR']),
             windowsHide: true,
         });
         return stdout.trim() === 'true';
@@ -117,6 +119,7 @@ async function resolveCoveredPatterns(projectRoot, patterns, lines) {
         try {
             await execFileAsync('git', ['check-ignore', '--quiet', '--', probePath(pattern)], {
                 cwd: projectRoot,
+                env: helperEnvironment(process.env, [...HELPER_ENV_ALLOWLIST, 'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR']),
                 windowsHide: true,
             });
             return true;
@@ -239,6 +242,7 @@ export function dropGitignored(targetDir, files) {
         }
         const result = boundedSpawnSync('git', ['check-ignore', '-z', '--stdin'], 'quick', {
             cwd: targetDir,
+            env: helperEnvironment(process.env, [...HELPER_ENV_ALLOWLIST, 'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR']),
             input: `${files.join('\0')}\0`,
             encoding: 'utf8',
         });

package/dist/src/config/workspace.js

@@ -13,6 +13,7 @@ import { existsSync, statSync } from 'fs';
 import { homedir } from 'os';
 import { dirname, isAbsolute, relative, resolve } from 'path';
 import { promisify } from 'util';
+import { helperEnvironment } from '../process/cli-command.mjs';
 import { getConfigPath, readAiwgConfig, resolveDelivery, resolveRemoteProvider, resolveRemotes, } from './aiwg-config.js';
 const execFileAsync = promisify(execFile);
 function expandHome(value) {
@@ -96,7 +97,7 @@ async function readRemoteUrl(repoPath, remote) {
     if (remote.includes('://') || /^[^@/\s]+@[^:/\s]+:/.test(remote))
         return remote;
     try {
-        const { stdout } = await execFileAsync('git', ['-C', repoPath, 'remote', 'get-url', remote], { encoding: 'utf8' });
+        const { stdout } = await execFileAsync('git', ['-C', repoPath, 'remote', 'get-url', remote], { encoding: 'utf8', env: helperEnvironment() });
         return stdout.trim() || undefined;
     }
     catch {

package/dist/src/cost/fleet-report.js

@@ -1,7 +1,7 @@
 /**
  * OpenRouter fleet spend observation and local activity correlation.
  *
- * Secrets are resolved only from the process environment or the user's
+ * Secrets are resolved from named sources or the user's
  * ~/.config/aiwg/keys directory. Fleet configuration contains references,
  * never credential values.
  *
@@ -11,6 +11,7 @@ import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { load as loadYaml } from 'js-yaml';
+import { resolveSensitiveInput } from '../auth/sensitive-input.js';
 const OPENROUTER_API = 'https://openrouter.ai/api/v1';
 const KEY_REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const SECRET_FIELD_PATTERN = /(?:api[_-]?key|token|secret|credential|authorization)/i;
@@ -60,6 +61,9 @@ function validateFleetConfig(value) {
         if (!KEY_REF_PATTERN.test(entry.key_ref)) {
             throw new Error(`fleet[${index}].key_ref contains unsupported characters.`);
         }
+        if (entry.key_store !== undefined && (typeof entry.key_store !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/.test(entry.key_store))) {
+            throw new Error(`fleet[${index}].key_store must name a native-store entry (1–128 letters, digits, dots, underscores or hyphens).`);
+        }
         if (typeof entry.monthly_cap !== 'number' || !Number.isFinite(entry.monthly_cap) || entry.monthly_cap < 0) {
             throw new Error(`fleet[${index}].monthly_cap must be a non-negative number.`);
         }
@@ -73,6 +77,7 @@ function validateFleetConfig(value) {
             bot: entry.bot.trim(),
             machine: entry.machine.trim(),
             key_ref: entry.key_ref,
+            ...(entry.key_store !== undefined ? { key_store: entry.key_store } : {}),
             monthly_cap: entry.monthly_cap,
         };
     });
@@ -101,10 +106,16 @@ export async function loadFleetKey(keyRef, options = {}) {
     if (!KEY_REF_PATTERN.test(keyRef))
         throw new Error('Invalid key_ref.');
     const env = options.env ?? process.env;
+    const dependencies = { environment: env, readStore: options.readStore, isTTY: false };
+    // An explicit reference is scoped to this entry. Never probe a global key or
+    // another bot's store when the selected source is unavailable.
+    if (options.store !== undefined) {
+        return resolveSensitiveInput({ prefix: 'key', store: options.store }, dependencies);
+    }
     const environmentName = keyEnvironmentName(keyRef);
     const environmentValue = env[environmentName]?.trim();
     if (environmentValue)
-        return environmentValue;
+        return resolveSensitiveInput({ prefix: 'key', env: environmentName }, dependencies);
     const homeDir = options.homeDir ?? os.homedir();
     const keyDirectory = path.resolve(homeDir, '.config', 'aiwg', 'keys');
     const keyPath = path.resolve(keyDirectory, keyRef);
@@ -116,7 +127,7 @@ export async function loadFleetKey(keyRef, options = {}) {
     }
     catch (error) {
         if (error.code === 'ENOENT') {
-            throw new Error(`No secure credential directory exists for key_ref '${keyRef}'; use ${environmentName} or create ~/.config/aiwg/keys with mode 0700.`);
+            throw new Error(`No secure credential directory exists for key_ref '${keyRef}'; use ${environmentName}, --key-store <name> (fleet: key_store), or create ~/.config/aiwg/keys with mode 0700.`);
         }
         throw error;
     }
@@ -129,27 +140,12 @@ export async function loadFleetKey(keyRef, options = {}) {
     if (typeof process.getuid === 'function' && directoryStat.uid !== process.getuid()) {
         throw new Error('The AIWG credential directory must be owned by the current user.');
     }
-    let stat;
     try {
-        stat = await fs.lstat(keyPath);
+        return await resolveSensitiveInput({ prefix: 'key', file: keyPath }, dependencies);
     }
     catch (error) {
-        if (error.code === 'ENOENT') {
-            throw new Error(`No credential found for key_ref '${keyRef}' in the secure key directory or ${environmentName}.`);
-        }
-        throw error;
-    }
-    if (stat.isSymbolicLink() || !stat.isFile())
-        throw new Error(`Credential for key_ref '${keyRef}' must be a regular file, not a symlink.`);
-    if ((stat.mode & 0o077) !== 0)
-        throw new Error(`Credential file for key_ref '${keyRef}' must not be accessible by group or other users.`);
-    if (typeof process.getuid === 'function' && stat.uid !== process.getuid()) {
-        throw new Error(`Credential file for key_ref '${keyRef}' must be owned by the current user.`);
+        throw new Error(`Credential for key_ref '${keyRef}': ${error.message} Use ${environmentName}, --key-store <name> (fleet: key_store), or a private ~/.config/aiwg/keys/<key_ref> file.`);
     }
-    const value = (await fs.readFile(keyPath, 'utf8')).trim();
-    if (!value)
-        throw new Error(`Credential file for key_ref '${keyRef}' is empty.`);
-    return value;
 }
 function parseActivityLog(raw) {
     const entries = [];
@@ -202,7 +198,9 @@ async function openRouterGet(endpoint, key, options) {
     }
     if (!payload || typeof payload !== 'object' || !payload.data)
         throw new Error('OpenRouter returned an invalid response.');
-    return payload.data;
+    // Generation metadata can reflect a request header in free-text fields. Keep
+    // such content out of both structured and human-readable reports.
+    return JSON.parse(JSON.stringify(payload.data, (_name, value) => (typeof value === 'string' ? value.split(key).join('[REDACTED]') : value)));
 }
 function correlateGenerations(records) {
     const sessions = new Map();
@@ -223,7 +221,7 @@ function correlateGenerations(records) {
 }
 async function reportBot(entry, activity, options) {
     try {
-        const key = await loadFleetKey(entry.key_ref, options);
+        const key = await loadFleetKey(entry.key_ref, { ...options, store: entry.key_store });
         const keyData = await openRouterGet('/key', key, options);
         const spend = Number(keyData.usage_monthly ?? keyData.usage ?? 0);
         if (!Number.isFinite(spend) || spend < 0)

package/dist/src/decision/adapters/jev.js

@@ -44,22 +44,15 @@ export class JevDecisionAdapter {
         this.region = options.region?.trim() ? options.region : null;
         this.observeResponseBody = options.observeResponseBody;
     }
-    /** Used only for non-2xx error bodies, where there is no separate successful parse to stay consistent with. */
-    observeResponse(body) {
-        if (!this.observeResponseBody)
-            return;
-        let parsed = {};
-        try {
-            parsed = asRecord(parseBoundedJson(body));
-        }
-        catch { /* Invalid answers still have bounded body evidence. */ }
-        let usage = emptyUsage();
+    /** An error response may still report billed usage and correlation metadata. */
+    parseErrorResponse(body) {
+        let parsed;
         try {
-            usage = normalizeUsage(parsed.usage);
+            parsed = parseBoundedJson(body);
         }
-        catch { /* Missing usage is unknown, including on auth errors. */ }
-        this.observeResponseBody(body, { actualModel: typeof parsed.model === 'string' && parsed.model ? parsed.model : null,
-            usage });
+        catch { /* Error classification does not require valid JSON. */ }
+        this.observeParsed(body, parsed);
+        return parsed;
     }
     /**
      * Derives the observer's model/usage from a value `parseBoundedJson` has already produced (or `undefined`
@@ -81,6 +74,15 @@ export class JevDecisionAdapter {
         catch { /* Missing usage is unknown, including on auth errors. */ }
         return { actualModel: typeof record.model === 'string' && record.model ? record.model : null, usage };
     }
+    responseMetadata(parsed, metadata) {
+        let body = {};
+        try {
+            body = asRecord(parsed);
+        }
+        catch { /* No body correlation metadata. */ }
+        const id = metadata.requestId ? null : safeRequestId(body.request_id ?? body.requestId);
+        return { ...metadata, ...this.observationMetadataOf(parsed), ...(id ? { requestId: id, requestIdSource: 'body' } : {}) };
+    }
     /** Observes exactly once, from the single parse attempt `parsed` already represents (successful or not). */
     observeParsed(body, parsed) {
         this.observeResponseBody?.(body, this.observationMetadataOf(parsed));
@@ -209,22 +211,7 @@ export class JevDecisionAdapter {
         if (!response.ok) {
             try {
                 const errorBody = await readBoundedBody(response, signal);
-                this.observeResponse(errorBody);
-                if (!metadata.requestId && response.headers.get('content-type')?.includes('json')) {
-                    let parsedError;
-                    try {
-                        parsedError = parseBoundedJson(errorBody);
-                    }
-                    catch {
-                        parsedError = null;
-                    }
-                    if (parsedError && typeof parsedError === 'object' && !Array.isArray(parsedError)) {
-                        const field = parsedError.request_id ?? parsedError.requestId;
-                        const safe = safeRequestId(field);
-                        if (safe)
-                            metadata = { ...metadata, requestId: safe, requestIdSource: 'body' };
-                    }
-                }
+                metadata = this.responseMetadata(this.parseErrorResponse(errorBody), metadata);
             }
             catch {
                 if (request.signal.aborted)
@@ -248,6 +235,7 @@ export class JevDecisionAdapter {
             finally {
                 this.observeParsed(encoded, parsed);
             }
+            metadata = this.responseMetadata(parsed, metadata);
             if (request.signal.aborted)
                 return externalInterruption(request, 'terminal-response', metadata);
             if (deadline.aborted)
@@ -353,7 +341,7 @@ export class JevDecisionAdapter {
         }
         if (!response.ok) {
             try {
-                this.observeResponse(await readBoundedBody(response, signal));
+                metadata = this.responseMetadata(this.parseErrorResponse(await readBoundedBody(response, signal)), metadata);
             }
             catch {
                 return batchFailure(requests, failure('invalid-output', metadata));
@@ -371,6 +359,7 @@ export class JevDecisionAdapter {
             finally {
                 this.observeParsed(encoded, parsed);
             }
+            metadata = this.responseMetadata(parsed, metadata);
             const normalized = normalizeBatchResponse(requests, parsed).map(answer => ({
                 questionId: answer.questionId,
                 observation: { ...answer.observation, ...metadata },