@aiwg/cli 2026.10.5 → 2026.10.7

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

@@ -13,6 +13,7 @@ import { getFrameworkRoot } from '../../channel/manager.mjs';
 import { maybePrintCommunityFooter } from '../../community/footer.js';
 import { buildDeploymentStatusProbe } from '../services/deployment-verification.js';
 import { detectScope } from '../scope-resolver.js';
+import { readNativeSandboxWarnings } from '../../config/native-sandbox-warnings.js';
 function statusProjectRoot(args, fallback) {
     const valueFlags = new Set(['--scope', '--provider', '--bundle']);
     for (let index = 0; index < args.length; index += 1) {
@@ -57,9 +58,10 @@ export const statusHandler = {
             });
             const { inspectGrokBuildNative } = await import('../../mcp/grok-build-config.mjs');
             const grokBuildNative = await inspectGrokBuildNative({ projectDir: projectRoot });
+            const nativeSandboxWarnings = await readNativeSandboxWarnings(projectRoot);
             return {
                 exitCode: probe.status === 'needs-repair' ? 1 : 0,
-                message: JSON.stringify({ ...probe, grokBuildNative }, null, 2),
+                message: JSON.stringify({ ...probe, grokBuildNative, nativeSandboxWarnings }, null, 2),
                 rawOutput: true,
             };
         }

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

@@ -16,6 +16,7 @@
  * migration mechanical.
  */
 import readline from 'readline';
+import { Writable } from 'node:stream';
 import * as ui from './ui.js';
 /**
  * Resolve the prompt timeout from env. Falsy / non-numeric / non-positive
@@ -36,6 +37,13 @@ export function createPromptInterface() {
         output: process.stdout,
     });
 }
+/** Readline still owns timeout/cancellation; discard terminal echo for secret input. */
+export function createSecretPromptInterface() {
+    const output = new Writable({ write(_chunk, _encoding, done) { done(); } });
+    const rl = readline.createInterface({ input: process.stdin, output, terminal: true });
+    rl.once('close', () => output.destroy());
+    return rl;
+}
 /**
  * Ask a single question with a hard timeout. On timeout, resolves to `fallback`
  * and emits a warn-level UI message describing what default was used.
@@ -80,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.
@@ -104,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/cli/router.js

@@ -176,6 +176,20 @@ export async function run(args, options = {}) {
     }
     // Build context for handler and hooks
     const ctx = await buildContext(commandArgs, args, options);
+    // Read-only memory views (audit, cost, recommend, plan, verify, --preview) cannot invoke mutation-capable hooks or append command telemetry.
+    // Keep dispatch through the existing memory handler and strict parser.
+    if (commandId === 'memory' && (['audit', 'cost', 'recommend', 'plan', 'verify'].includes(commandArgs[0]) || commandArgs.includes('--preview'))) {
+        const result = await handler.execute(ctx);
+        if (result.message) {
+            if (result.exitCode !== 0)
+                ui.error(result.message);
+            else
+                ui.info(result.message);
+        }
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
+        return;
+    }
     // Build hook context
     const hookCtx = {
         event: 'pre-command',
@@ -332,8 +346,9 @@ async function buildContext(args, rawArgs, options) {
     const readOnlyRuleInventory = rawArgs[0] === 'rules' && ['inventory', 'list'].includes(args[0]);
     const readOnlyOffloadReport = (['doctor', '-doctor', '--doctor'].includes(rawArgs[0] ?? '') && args.includes('--decision-offload'))
         || (rawArgs[0] === 'steward' && args[0] === 'decision-offload');
+    const readOnlyMemoryAudit = rawArgs[0] === 'memory' && (['audit', 'cost', 'recommend', 'plan', 'verify'].includes(args[0]) || args.includes('--preview') || args.includes('--help') || args.includes('-h'));
     const frameworkRoot = await getFrameworkRoot({
-        createIfMissing: !args.includes('--dry-run') && !readOnlyRuleInventory && !readOnlyOffloadReport,
+        createIfMissing: !args.includes('--dry-run') && !readOnlyRuleInventory && !readOnlyOffloadReport && !readOnlyMemoryAudit,
     });
     const ctx = {
         args,

package/dist/src/config/aiwg-config.js

@@ -201,6 +201,17 @@ export function validateParallelismConfig(value) {
             error(`clis/${id}/adapter`, 'Unknown provider binding');
     }
     for (const [id, group] of Object.entries(policy.groups ?? {})) {
+        if (group.execution?.launchMode === 'native-sandbox'
+            && (!['read-only', 'workspace-write'].includes(group.execution.sandbox ?? '')
+                || (group.execution.transport ?? 'shell') !== 'shell')) {
+            error(`groups/${id}/execution/launchMode`, 'native-sandbox requires an enforcing read-only or workspace-write shell sandbox');
+        }
+        if (group.execution?.launchMode === 'native-sandbox') {
+            if (group.execution.approval === 'on-request')
+                error(`groups/${id}/execution/approval`, 'native-sandbox requires approval="never"');
+            if (group.execution.network === 'allowlisted')
+                error(`groups/${id}/execution/network`, 'native-sandbox requires network="deny"');
+        }
         const ids = new Set();
         for (const member of group.members) {
             if (ids.has(member.id))
@@ -208,6 +219,10 @@ export function validateParallelismConfig(value) {
             ids.add(member.id);
             if (!policy.clis?.[member.cli] && !builtinIds.has(member.cli))
                 error(`groups/${id}/members/${member.id}/cli`, 'Unknown installation');
+            if (group.execution?.launchMode === 'native-sandbox'
+                && (policy.clis?.[member.cli]?.adapter ?? `providers:${member.cli}`) !== 'providers:codex') {
+                error(`groups/${id}/members/${member.id}/cli`, 'native-sandbox requires a codex adapter');
+            }
         }
         for (const member of group.fallback ?? [])
             if (!ids.has(member))
@@ -461,6 +476,33 @@ export function validateIndexConfig(index) {
     if (indexObject.graphBackend !== undefined && !GRAPH_BACKENDS.includes(indexObject.graphBackend)) {
         errors.push(`index.graphBackend: must be one of ${GRAPH_BACKENDS.join(' | ')}`);
     }
+    if (indexObject.freshness !== undefined) {
+        const policies = indexObject.freshness;
+        if (!policies || typeof policies !== 'object' || Array.isArray(policies)) {
+            errors.push('index.freshness: must map adapter names to policies');
+        }
+        else
+            for (const [name, policy] of Object.entries(policies)) {
+                const where = `index.freshness.${name}`;
+                if (!policy || typeof policy !== 'object' || Array.isArray(policy)) {
+                    errors.push(`${where}: must be an object`);
+                    continue;
+                }
+                for (const [key, value] of Object.entries(policy)) {
+                    if (key === 'measureConvergence') {
+                        if (typeof value !== 'boolean')
+                            errors.push(`${where}.${key}: must be a boolean`);
+                    }
+                    else if (key === 'targetStaleAfterMs' || key === 'maxRetriesPerDay') {
+                        if (!Number.isSafeInteger(value) || value < (key === 'targetStaleAfterMs' ? 1 : 0)) {
+                            errors.push(`${where}.${key}: must be a ${key === 'targetStaleAfterMs' ? 'positive' : 'non-negative'} integer`);
+                        }
+                    }
+                    else
+                        errors.push(`${where}.${key}: unknown policy key`);
+                }
+            }
+    }
     const isStringArray = (v) => Array.isArray(v) && v.every((x) => typeof x === 'string');
     errors.push(...validateIndexGraphOverrides(indexObject.graphOverrides));
     const graphs = indexObject.graphs;

package/dist/src/config/cli.js

@@ -24,6 +24,7 @@ import { normalizeProviderDefinitionId } from '../providers/provider-definitions
 import { UserConfig } from './user-config.js';
 import { AiwgError, EXIT_CODES } from '../cli/errors.js';
 import { isInteractive } from '../cli/env.js';
+import { splitParams } from '../cli/agent-spawn.js';
 import { exitCodeForSpawnResult } from '../cli/child-process-result.js';
 import { projectControlPath, resolveProjectAiwgDir } from './project-artifacts.js';
 const _scriptDir = path.dirname(fileURLToPath(import.meta.url));
@@ -400,7 +401,7 @@ async function projectConfigSet(key, raw, args, quiet = false) {
         }
         value = n;
     }
-    if (key === 'decision.ask.cost.llm_per_mtok' || key === 'decision.ask.cost.jev_per_mtok') {
+    if (['decision.ask.cost.llm_per_mtok', 'decision.ask.cost.jev_per_mtok', 'decision.ask.cost.jev_input_per_mtok', 'decision.ask.cost.jev_output_per_mtok'].includes(key)) {
         const n = Number(raw);
         if (!raw.trim() || !Number.isFinite(n) || n < 0 || n > 1_000_000) {
             throw new AiwgError({ code: 'ERR_INVALID_VALUE', message: `${key} must be a non-negative number <= 1000000`, exitCode: EXIT_CODES.USAGE });
@@ -733,14 +734,17 @@ async function handleEdit(config, args = []) {
     const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
     // Ensure the config file exists before opening
     await config.ensureDir();
-    const { execSync } = await import('child_process');
+    const { execFileSync } = await import('child_process');
     try {
+        const [executable, ...editorArgs] = splitParams(editor);
+        if (!executable)
+            throw new Error('Editor command is empty');
         // sync-spawn: interactive editor-launch — launches $EDITOR/$VISUAL on the
         // config file; the user interacts with it directly (see tools/testing/
         // sync-spawn-allowlist.json). Reached only when isInteractive() is true
         // (#3062) — the no-terminal path above refuses before spawning anything.
         // Not a candidate for a bounded timeout.
-        execSync(`${editor} "${configPath}"`, { stdio: 'inherit' });
+        execFileSync(executable, [...editorArgs, configPath], { stdio: 'inherit', shell: false });
     }
     catch (err) {
         throw new AiwgError({

package/dist/src/config/decision-config.js

@@ -57,10 +57,23 @@ export function validateDecisionConfig(value) {
             sampling.push(`decision.ask.${section} must be an object`);
             continue;
         }
-        const allowed = section === 'cost' ? ['llm_per_mtok', 'jev_per_mtok'] : ['caller_model_class', 'reasoning_tokens', 'output_tokens'];
+        const allowed = section === 'cost' ? ['llm_per_mtok', 'jev_per_mtok', 'jev_input_per_mtok', 'jev_output_per_mtok', 'source', 'checked_at', 'jev_model'] : ['caller_model_class', 'reasoning_tokens', 'output_tokens'];
         for (const [key, value] of Object.entries(settings)) {
             if (!allowed.includes(key))
                 sampling.push(`unknown decision.ask.${section}.${key}`);
+            else if (key === 'source') {
+                if (!['typesafe-docs', 'manual', 'typesafe-snapshot'].includes(value))
+                    sampling.push('decision.ask.cost.source must be typesafe-docs, manual or typesafe-snapshot');
+            }
+            else if (key === 'checked_at') {
+                if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)
+                    || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value)
+                    sampling.push('decision.ask.cost.checked_at must be an ISO date (YYYY-MM-DD)');
+            }
+            else if (key === 'jev_model') {
+                if (typeof value !== 'string' || !/^jev-\d+\.\d+\.\d+$/.test(value))
+                    sampling.push('decision.ask.cost.jev_model must be a versioned Jev model (jev-X.Y.Z)');
+            }
             else if (key === 'caller_model_class') {
                 if (value !== 'standard' && value !== 'reasoning')
                     sampling.push('decision.ask.savings.caller_model_class must be standard or reasoning');

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/native-sandbox-warnings.js

@@ -0,0 +1,25 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getConfigPath, readAiwgConfig } from './aiwg-config.js';
+import { projectAiwgPath } from './project-artifacts.js';
+/** Advisory only: native-sandbox bypasses the systemd launcher boundary. */
+export function nativeSandboxWarnings(config, projectDir) {
+    const groups = Object.entries(config?.parallelism?.groups ?? {})
+        .filter(([, group]) => group.execution?.launchMode === 'native-sandbox')
+        .map(([id]) => id);
+    if (groups.length === 0)
+        return [];
+    // Match readAiwgConfig's repository-control-plane-first compatibility lookup.
+    const localPath = getConfigPath(projectDir);
+    const configPath = resolve(existsSync(localPath) ? localPath : projectAiwgPath(projectDir, 'aiwg.config'));
+    return groups.map(group => ({
+        code: 'NATIVE_SANDBOX_ISOLATION',
+        group,
+        configPath,
+        message: `Group "${group}" selects launchMode: native-sandbox in ${configPath}; systemd-unit isolation and its memory limit do not apply; only the worker CLI's own sandbox applies.`,
+    }));
+}
+export async function readNativeSandboxWarnings(projectDir) {
+    return nativeSandboxWarnings(await readAiwgConfig(projectDir), projectDir);
+}
+//# sourceMappingURL=native-sandbox-warnings.js.map

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/contributors/validation.js

@@ -9,13 +9,14 @@
  * @issue #938
  */
 import { z } from 'zod';
+import { integer } from '../schema/zod-validation.mjs';
 /**
  * Detection spec — declarative globs + counts. Common to every kind.
  */
 const DetectionSpecSchema = z.object({
     glob: z.array(z.string()).min(1, 'detect.glob must have at least one pattern'),
-    minCount: z.number().int().positive().optional(),
-    conditions: z.record(z.string()).optional(),
+    minCount: integer().positive().optional(),
+    conditions: z.record(z.string(), z.string()).optional(),
 });
 /**
  * Base frontmatter shared by every kind. Per-kind schemas extend this.
@@ -39,7 +40,7 @@ export const StatusContributorSchema = ContributorBaseSchema.extend({
      * code-driven; the aggregator reads these to populate the report block.
      */
     fields: z
-        .record(z.object({
+        .record(z.string(), z.object({
         type: z.enum(['string', 'number', 'date']),
         source: z.string(),
         regex: z.string().optional(),
@@ -60,7 +61,7 @@ export const ResearchContributorSchema = ContributorBaseSchema.extend({
     })
         .optional(),
     focus_areas: z.array(z.string()).min(1, 'research contributors must declare at least one focus area'),
-    recency_default_months: z.number().int().positive().optional(),
+    recency_default_months: integer().positive().optional(),
 });
 /**
  * Schema registry. Adding a new kind means adding its schema here — no other
@@ -108,7 +109,7 @@ export function validateContributor(data) {
     if (!result.success) {
         return {
             ok: false,
-            errors: result.error.errors.map(e => `${e.path.join('.') || '<root>'}: ${e.message}`),
+            errors: result.error.issues.map(e => `${e.path.join('.') || '<root>'}: ${e.message}`),
         };
     }
     return { ok: true, data: result.data };

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 },

package/dist/src/decision/admission.js

@@ -43,9 +43,13 @@ export class DecisionAdmissionController {
         this.now = now;
         this.options = options;
     }
-    /** Aggregate counts only; suitable for load harness sampling. */
-    snapshot() {
-        return { active: this.active, queued: this.queuedCount() };
+    /** Host-only counts for load sampling; omitting a scope returns aggregate counts. */
+    snapshot(scope) {
+        const principal = scope?.principalId;
+        const provider = scope?.providerId;
+        const active = principal && provider ? this.activePrincipalProvider.get(`${provider}\u0000${principal}`) ?? 0
+            : principal ? this.activePrincipal.get(principal) ?? 0 : provider ? this.activeProvider.get(provider) ?? 0 : this.active;
+        return { active, queued: this.queuedCount(request => (!principal || request.principalId === principal) && (!provider || request.providerId === provider)) };
     }
     /** Bounded, metadata-only breaker transition history, oldest first. */
     breakerTransitions() {

package/dist/src/decision/ask.js

@@ -495,6 +495,11 @@ export async function setupJev(input = {}, options = {}) {
         next: ['Run aiwg decision ask --question "<q>" --yes-no --json.'],
     };
     if (input.verify) {
+        // Verify the credential just saved, even when the shell still names an
+        // older token. Ordinary ask calls retain their environment precedence.
+        const verificationEnv = { ...environment };
+        delete verificationEnv.JEV_API_KEY;
+        delete verificationEnv.AIWG_DECISION_JEV_API_KEY;
         const verified = await askDecision({
             question: 'Is this Jev decision setup verification request well formed?',
             mode: { kind: 'yes-no' },
@@ -502,7 +507,7 @@ export async function setupJev(input = {}, options = {}) {
             timeoutMs: 15_000,
             passes: 1,
             escalationPasses: 1,
-        }, options);
+        }, { ...options, env: verificationEnv });
         result.verified = verified.status === 'answered';
         result.model = verified.model;
         result.usage = verified.usage;