@aiwg/cli 2026.10.0 → 2026.10.3

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

@@ -2,7 +2,6 @@ import { DecisionValidationError, validateDecisionValue, validateDistribution }
 import { canonicalJson } from '../../security/artifact-trust.js';
 import { partitionProjectedState } from '../projection.js';
 import { isTraceparent } from '../telemetry/context.js';
-import { runInNewContext } from 'node:vm';
 import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
 import { request as httpsRequest } from 'node:https';
@@ -12,7 +11,7 @@ export const JEV_ENDPOINT = 'https://api.typesafe.ai/v1/systemone';
 const MAX_HEADER_BYTES = 32 * 1024;
 const MAX_BODY_BYTES = 1024 * 1024;
 const MAX_REQUEST_ID_LENGTH = 128;
-const MAX_PARSE_MS = 50;
+const MAX_PARSE_DEPTH = 64;
 /** Safe resolver taxonomy; messages are intentionally discarded at this boundary. */
 export class JevCredentialError extends Error {
     category;
@@ -45,6 +44,7 @@ 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;
@@ -61,6 +61,30 @@ export class JevDecisionAdapter {
         this.observeResponseBody(body, { actualModel: typeof parsed.model === 'string' && parsed.model ? parsed.model : null,
             usage });
     }
+    /**
+     * Derives the observer's model/usage from a value `parseBoundedJson` has already produced (or `undefined`
+     * on a failed parse) -- never from a second, independent parse of the same bytes. `parseBoundedJson` runs
+     * inside a bounded-time VM context (`MAX_PARSE_MS`); calling it twice on identical bytes let one call
+     * succeed while the other spuriously hit that wall-clock bound under host contention, so the reported
+     * metadata could disagree with the actual parsed answer even though both described one response.
+     */
+    observationMetadataOf(parsed) {
+        let record = {};
+        try {
+            record = asRecord(parsed);
+        }
+        catch { /* A non-object (or absent) top-level value has no model; usage stays unknown. */ }
+        let usage = emptyUsage();
+        try {
+            usage = normalizeUsage(record.usage);
+        }
+        catch { /* Missing usage is unknown, including on auth errors. */ }
+        return { actualModel: typeof record.model === 'string' && record.model ? record.model : null, usage };
+    }
+    /** Observes exactly once, from the single parse attempt `parsed` already represents (successful or not). */
+    observeParsed(body, parsed) {
+        this.observeResponseBody?.(body, this.observationMetadataOf(parsed));
+    }
     async capabilities() {
         return {
             answerKinds: ['choice', 'ordinal-score', 'truth-probability'],
@@ -191,9 +215,7 @@ export class JevDecisionAdapter {
                     try {
                         parsedError = parseBoundedJson(errorBody);
                     }
-                    catch (error) {
-                        if (error && typeof error === 'object' && 'code' in error && error.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT')
-                            throw error;
+                    catch {
                         parsedError = null;
                     }
                     if (parsedError && typeof parsedError === 'object' && !Array.isArray(parsedError)) {
@@ -217,8 +239,15 @@ export class JevDecisionAdapter {
         let parsed;
         try {
             const encoded = await readBoundedBody(response, signal);
-            this.observeResponse(encoded);
-            parsed = parseBoundedJson(encoded);
+            // One parse attempt; the observer reads its outcome (success or failure) before answer validation,
+            // so an invalid answer still gets model/usage checked, and a parse failure is reported as unknown
+            // to both the observer and the main path -- never divergently.
+            try {
+                parsed = parseBoundedJson(encoded);
+            }
+            finally {
+                this.observeParsed(encoded, parsed);
+            }
             if (request.signal.aborted)
                 return externalInterruption(request, 'terminal-response', metadata);
             if (deadline.aborted)
@@ -334,8 +363,14 @@ export class JevDecisionAdapter {
         }
         try {
             const encoded = await readBoundedBody(response, signal);
-            this.observeResponse(encoded);
-            const parsed = parseBoundedJson(encoded);
+            // One parse attempt; see the single-request `evaluate()` for why observation never re-parses.
+            let parsed;
+            try {
+                parsed = parseBoundedJson(encoded);
+            }
+            finally {
+                this.observeParsed(encoded, parsed);
+            }
             const normalized = normalizeBatchResponse(requests, parsed).map(answer => ({
                 questionId: answer.questionId,
                 observation: { ...answer.observation, ...metadata },
@@ -453,7 +488,11 @@ function normalizeAnswer(request, body, questionId) {
                 throw new DecisionValidationError('Score legend does not match declared levels');
         });
         const mean = Object.entries(distribution).reduce((sum, [index, probability]) => sum + Number(index) * probability, 0);
-        if (Math.abs(mean - answer.score) > 0.02)
+        // Jev reports probabilities and the score to two decimals, so each probability carries up to
+        // 0.005 of rounding error, weighted by its index, plus 0.005 on the score itself.
+        const indexSum = Object.keys(distribution).reduce((sum, index) => sum + Number(index), 0);
+        const tolerance = Math.max(0.02, 0.005 * indexSum + 0.005) + 1e-9;
+        if (Math.abs(mean - answer.score) > tolerance)
             throw new DecisionValidationError('Score is not the distribution weighted mean');
         validateDecisionValue(request.definition, answer.score);
         return success(answer.score, model, usage, uncertainty(answer.confidence, distribution, 'typesafe-distribution-v1'));
@@ -570,19 +609,21 @@ function safeRequestId(value) {
     return typeof value === 'string' && value.length > 0 && value.length <= MAX_REQUEST_ID_LENGTH
         && /^[\x21-\x7e]+$/.test(value) && !value.includes(',') ? value : null;
 }
-function parseBoundedJson(text) {
-    rejectDuplicateAnswerKeys(text);
-    return structuredClone(runInNewContext('JSON.parse(input)', { input: text }, { timeout: MAX_PARSE_MS }));
-}
-/** Detect duplicate keys in the response's answer map before JSON.parse erases them. */
-function rejectDuplicateAnswerKeys(text) {
-    const marker = /"answers"\s*:\s*\{/g.exec(text);
-    if (!marker)
-        return;
-    let index = marker.index + marker[0].length;
-    let depth = 1;
-    const keys = new Set();
-    while (index < text.length && depth > 0) {
+/** @internal Exported from this module for direct admission and CPU-cost evidence, not the public barrel. */
+export function parseBoundedJson(text) {
+    // Bound work, not elapsed time: a VM timeout includes host scheduling delay.
+    // The stream reader also enforces this bound, before UTF-8 decoding.
+    if (text.length > MAX_BODY_BYTES || Buffer.byteLength(text, 'utf8') > MAX_BODY_BYTES) {
+        throw new DecisionValidationError('Jev response too large');
+    }
+    // Scan iteratively before allocation by JSON.parse. Total key text/count is
+    // bounded by body bytes; no recursive walk or suffix copying is needed.
+    // String/key spans are disjoint; skip the whitespace consumed by lookahead.
+    // Each code unit is visited once. Key slicing/decoding/hashing sum to
+    // O(body bytes), as does native parsing.
+    const containers = [];
+    let index = 0;
+    while (index < text.length) {
         const char = text[index];
         if (char === '"') {
             const start = index++;
@@ -596,20 +637,31 @@ function rejectDuplicateAnswerKeys(text) {
                 else if (next === '"')
                     break;
             }
-            if (depth === 1 && /^\s*:/.test(text.slice(index))) {
+            let next = index;
+            while (next < text.length && /[\x20\t\r\n]/.test(text[next]))
+                next += 1;
+            const keys = containers.at(-1);
+            if (keys && text[next] === ':') {
                 const key = JSON.parse(text.slice(start, index));
                 if (keys.has(key))
-                    throw new DecisionValidationError('duplicate Jev answer key');
+                    throw new DecisionValidationError('duplicate Jev response key');
                 keys.add(key);
             }
+            index = next;
             continue;
         }
-        if (char === '{' || char === '[')
-            depth += 1;
+        if (char === '{' || char === '[') {
+            if (containers.length >= MAX_PARSE_DEPTH)
+                throw new DecisionValidationError('Jev response nesting too deep');
+            containers.push(char === '{' ? new Set() : null);
+        }
         else if (char === '}' || char === ']')
-            depth -= 1;
+            containers.pop();
         index += 1;
     }
+    // Native parsing checks the complete JSON grammar, with no reviver or code
+    // execution. Input bytes and nesting bound its work and allocated graph.
+    return JSON.parse(text);
 }
 function headersWithinLimit(headers) {
     let bytes = 0;

package/dist/src/decision/ask.js

@@ -0,0 +1,352 @@
+import { readFile } from 'node:fs/promises';
+import { JEV_ENDPOINT, JevDecisionAdapter } from './adapters/jev.js';
+import { evaluateDecisionRuleset } from './evaluate.js';
+import { artifactPin } from './validate.js';
+import { JEV_CREDENTIAL_REF, JEV_DEFAULT_REGION, lookupJevCredential, removeJevCredentialFile, resolveJevCredentialBytes, writeJevCredentialFile, } from './jev-credentials.js';
+const CONTEXT_LIMIT_BYTES = 32 * 1024;
+const MODEL = 'jev-latest';
+const PURPOSE = 'agent-bounded-decision';
+const INPUT_SCHEMA = {
+    type: 'object',
+    properties: { message: { type: 'string', minLength: 1 } },
+    required: ['message'],
+    additionalProperties: false,
+};
+export class DecisionAskUsageError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = 'DecisionAskUsageError';
+    }
+}
+function usageError(reason, message) {
+    throw new DecisionAskUsageError(reason, message);
+}
+function byteLength(value) {
+    return Buffer.byteLength(value, 'utf8');
+}
+function validateQuestion(question) {
+    if (!question.trim())
+        usageError('question-required', 'decision ask requires --question <q>');
+}
+export function validateDecisionAskInput(input) {
+    validateQuestion(input.question);
+    if (input.context !== undefined && byteLength(input.context) > CONTEXT_LIMIT_BYTES) {
+        usageError('context-too-large', 'decision ask context exceeds 32 KiB');
+    }
+    const threshold = input.threshold ?? 0.8;
+    if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+        usageError('invalid-threshold', '--threshold must be a probability from 0 to 1');
+    }
+    const timeoutMs = input.timeoutMs ?? 15_000;
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0)
+        usageError('invalid-timeout', '--timeout-ms must be a positive integer');
+    if (input.mode.kind === 'choices') {
+        if (input.mode.choices.length < 2 || input.mode.choices.length > 255)
+            usageError('invalid-choices', '--choices requires 2..255 ids');
+        const seen = new Set();
+        for (const { id, description } of input.mode.choices.map(parseChoice)) {
+            if (!/^[A-Za-z0-9_.-]{1,64}$/.test(id))
+                usageError('invalid-choices', 'choice ids must match [A-Za-z0-9_.-]{1,64}');
+            if (description !== undefined && (!description || description.length > 200)) {
+                usageError('invalid-choices', 'choice descriptions after = must be 1..200 characters');
+            }
+            if (seen.has(id))
+                usageError('invalid-choices', 'choice ids must not contain duplicates');
+            seen.add(id);
+        }
+    }
+    if (input.mode.kind === 'scale') {
+        const count = input.mode.high - input.mode.low + 1;
+        if (!Number.isInteger(input.mode.low) || !Number.isInteger(input.mode.high) || input.mode.low > input.mode.high || count < 2 || count > 10) {
+            usageError('invalid-scale', '--scale must be an integer range like 1-5 with at most 10 levels');
+        }
+    }
+}
+function usage(usageValue) {
+    if (!usageValue)
+        return null;
+    return { inputTokens: usageValue.inputTokens, outputTokens: usageValue.outputTokens };
+}
+function fallback(reason, latencyMs, attempt) {
+    return {
+        schema: 'aiwg-decision-ask/v1',
+        status: 'fallback',
+        answer: null,
+        confidence: null,
+        fallback: 'llm',
+        reason,
+        model: attempt?.actualModel ?? null,
+        usage: usage(attempt?.usage),
+        latencyMs,
+    };
+}
+/** A choice is `id` or `id=description`; the description tells Jev what the option means. */
+function parseChoice(entry) {
+    const separator = entry.indexOf('=');
+    if (separator < 0)
+        return { id: entry.trim() };
+    return { id: entry.slice(0, separator).trim(), description: entry.slice(separator + 1).trim() };
+}
+function scaleLevel(value, low, high) {
+    const edge = value === low ? ' (lowest)' : value === high ? ' (highest)' : '';
+    return `Level ${value} on a ${low} to ${high} scale${edge}.`;
+}
+function answerKind(mode) {
+    if (mode.kind === 'yes-no')
+        return {
+            kind: 'truth-probability',
+            trueDescription: 'Yes.',
+            falseDescription: 'No.',
+        };
+    if (mode.kind === 'choices')
+        return {
+            kind: 'choice',
+            options: mode.choices.map(parseChoice).map(({ id, description }) => ({ id, description: description ?? id })),
+        };
+    return {
+        kind: 'ordinal-score',
+        levels: Array.from({ length: mode.high - mode.low + 1 }, (_, index) => scaleLevel(mode.low + index, mode.low, mode.high)),
+    };
+}
+function definition(input) {
+    return {
+        apiVersion: 'decision.aiwg.io/v1alpha2',
+        kind: 'DecisionDefinition',
+        metadata: { id: 'aiwg.ask.answer', version: '1.0.0', description: 'Bounded advisory ask decision' },
+        spec: {
+            purpose: PURPOSE,
+            inputSchema: INPUT_SCHEMA,
+            question: input.question,
+            answer: answerKind(input.mode),
+            requiredCapabilities: [input.mode.kind === 'yes-no' ? 'truth-probability' : input.mode.kind === 'choices' ? 'choice' : 'ordinal-score'],
+        },
+    };
+}
+function ruleset(definitionValue) {
+    return {
+        apiVersion: 'decision.aiwg.io/v1alpha2',
+        kind: 'DecisionRuleset',
+        metadata: { id: 'aiwg.ask.ruleset', version: '1.0.0', description: 'Bounded advisory ask ruleset' },
+        spec: {
+            purpose: PURPOSE,
+            inputSchema: INPUT_SCHEMA,
+            evaluations: [{ alias: 'answer', decision: artifactPin(definitionValue), inputPointer: '' }],
+            rules: [{
+                    id: 'answered',
+                    priority: 1,
+                    when: { op: 'exists', left: { source: 'decision', alias: 'answer', pointer: '/value' } },
+                    outcome: 'answered',
+                }],
+            composition: 'first-match',
+            conflict: 'review',
+            defaultOutcome: 'fallback',
+            failureOutcome: 'fallback',
+            outputSchema: { enum: ['answered', 'fallback'] },
+        },
+    };
+}
+function binding(rulesetValue, primitive, timeoutMs) {
+    const target = {
+        adapter: 'jev',
+        adapterVersion: '1.0.0',
+        model: MODEL,
+        requiredCapabilities: [primitive],
+        acceptance: { mode: 'typed-value' },
+        timeoutMs,
+        retry: { maxRetries: 0, initialDelayMs: 250, maxDelayMs: 2_000 },
+        credentialRef: JEV_CREDENTIAL_REF,
+    };
+    return {
+        apiVersion: 'decision.aiwg.io/v1alpha2',
+        kind: 'DecisionBinding',
+        metadata: { id: 'aiwg.ask.binding', version: '1.0.0', description: 'Bounded advisory ask Jev binding' },
+        spec: {
+            ruleset: artifactPin(rulesetValue),
+            totalTimeoutMs: timeoutMs,
+            maxAttempts: 1,
+            concurrency: 1,
+            evaluations: { answer: { targets: [target], fallbackOn: [] } },
+        },
+    };
+}
+function projectionPolicy(region, endpoint) {
+    const origin = new URL(endpoint ?? JEV_ENDPOINT).origin;
+    return {
+        version: '1.0.0',
+        provider: 'jev',
+        model: MODEL,
+        origin,
+        region,
+        purpose: PURPOSE,
+        allowIncompleteContext: false,
+        fields: [{
+                pointer: '/message',
+                output: 'message',
+                source: 'operator',
+                subject: 'aiwg-decision-ask',
+                trust: 'untrusted',
+                sensitivity: 'internal',
+                purpose: PURPOSE,
+                retentionClass: 'ephemeral',
+                accessScopes: ['decision-runtime'],
+                exportPolicy: 'sanitized',
+                deletionPolicy: 'erase',
+                backupPolicy: 'not-persisted',
+                allowedProviders: ['jev'],
+                allowedModels: [MODEL],
+                allowedOrigins: [origin],
+                allowedRegions: [region],
+            }],
+    };
+}
+function contextMessage(input) {
+    return input.context === undefined || input.context === ''
+        ? input.question
+        : `${input.question}\n\nContext:\n${input.context}`;
+}
+function confidenceFor(mode, evaluation) {
+    const uncertainty = evaluation.spec.uncertainty;
+    const value = evaluation.spec.value;
+    if (mode.kind === 'yes-no' && typeof value === 'number')
+        return Math.max(value, 1 - value);
+    if (uncertainty?.distribution && mode.kind === 'choices' && typeof value === 'string')
+        return uncertainty.distribution[value] ?? uncertainty.confidence;
+    if (uncertainty?.distribution && mode.kind === 'scale')
+        return Math.max(...Object.values(uncertainty.distribution));
+    return uncertainty?.confidence ?? null;
+}
+function mostLikelyIndex(distribution) {
+    if (!distribution)
+        return null;
+    let best = null;
+    for (const [index, probability] of Object.entries(distribution)) {
+        if (best === null || probability > (distribution[String(best)] ?? -1))
+            best = Number(index);
+    }
+    return best;
+}
+function publicAnswer(mode, value, distribution) {
+    if (mode.kind === 'yes-no') {
+        const probability = typeof value === 'number' ? value : null;
+        return probability === null ? { answer: null } : { answer: probability >= 0.5, probability };
+    }
+    if (mode.kind === 'scale') {
+        // Jev returns the distribution-weighted mean index; report the most likely level instead.
+        const index = mostLikelyIndex(distribution) ?? (typeof value === 'number' ? Math.round(value) : null);
+        return index === null ? { answer: null } : { answer: mode.low + index };
+    }
+    return typeof value === 'string' ? { answer: value } : { answer: null };
+}
+export async function askDecision(input, options = {}) {
+    validateDecisionAskInput(input);
+    const started = options.now?.() ?? Date.now();
+    let credential;
+    try {
+        credential = await lookupJevCredential(options);
+    }
+    catch {
+        return fallback('not-configured', 0);
+    }
+    if (!credential?.enabled || !credential.token)
+        return fallback('not-configured', 0);
+    const timeoutMs = input.timeoutMs ?? 15_000;
+    const def = definition(input);
+    const rules = ruleset(def);
+    const bind = binding(rules, def.spec.answer.kind, timeoutMs);
+    const adapter = options.adapter ?? options.createAdapter?.({ region: credential.region, endpoint: credential.endpoint })
+        ?? new JevDecisionAdapter({ region: credential.region, ...(credential.endpoint ? {
+                endpoint: credential.endpoint,
+                allowedOrigins: [new URL(credential.endpoint).origin],
+            } : {}) });
+    let result;
+    try {
+        result = await (options.evaluate ?? evaluateDecisionRuleset)({
+            ruleset: rules,
+            binding: bind,
+            definitions: { [def.metadata.id]: def },
+            input: { message: contextMessage(input) },
+            runId: options.runId ?? 'aiwg-decision-ask',
+            invocationId: options.invocationId ?? `ask-${Date.now()}`,
+            adapters: { jev: adapter },
+            resolveCredential: options.resolveCredential ?? (logicalRef => resolveJevCredentialBytes(logicalRef, options)),
+            projection: { resolve: () => projectionPolicy(credential.region, credential.endpoint) },
+        });
+    }
+    catch {
+        return fallback('jev-error', Math.max(0, (options.now?.() ?? Date.now()) - started));
+    }
+    const latencyMs = Math.max(0, (options.now?.() ?? Date.now()) - started);
+    const evaluation = result.spec.evaluations.answer;
+    const attempt = evaluation?.spec.attempts.at(-1);
+    if (!evaluation || evaluation.spec.status !== 'success')
+        return fallback(evaluation?.spec.reason ?? result.spec.reason, latencyMs, attempt);
+    const confidence = confidenceFor(input.mode, evaluation);
+    const threshold = input.threshold ?? 0.8;
+    if (confidence === null || confidence < threshold)
+        return fallback('low-confidence', latencyMs, attempt);
+    const answer = publicAnswer(input.mode, evaluation.spec.value, evaluation.spec.uncertainty?.distribution);
+    return {
+        schema: 'aiwg-decision-ask/v1',
+        status: 'answered',
+        answer: answer.answer,
+        confidence,
+        ...(answer.probability === undefined ? {} : { probability: answer.probability }),
+        fallback: null,
+        reason: 'none',
+        model: attempt?.actualModel ?? null,
+        usage: usage(attempt?.usage),
+        latencyMs,
+    };
+}
+export async function readDecisionContextFile(filePath) {
+    const content = await readFile(filePath, 'utf8');
+    if (byteLength(content) > CONTEXT_LIMIT_BYTES)
+        usageError('context-too-large', 'decision ask context exceeds 32 KiB');
+    return content;
+}
+export async function setupJev(input = {}, options = {}) {
+    const region = input.region?.trim() || JEV_DEFAULT_REGION;
+    if (input.remove) {
+        await removeJevCredentialFile(options);
+        return {
+            schema: 'aiwg-decision-jev-setup/v1',
+            configured: false,
+            credentialSource: 'file',
+            region,
+            next: ['Run aiwg decision setup jev --token-stdin to configure Jev again.'],
+        };
+    }
+    const environment = options.env ?? process.env;
+    const envToken = environment.JEV_API_KEY?.trim() || environment.AIWG_DECISION_JEV_API_KEY?.trim();
+    const token = input.token?.trim() || envToken;
+    if (!token)
+        usageError('token-required', 'Provide --token-stdin or set JEV_API_KEY or AIWG_DECISION_JEV_API_KEY.');
+    await writeJevCredentialFile({
+        token,
+        region,
+        ...(input.endpoint?.trim() ? { endpoint: input.endpoint.trim() } : {}),
+        enabled: true,
+    }, options);
+    const result = {
+        schema: 'aiwg-decision-jev-setup/v1',
+        configured: true,
+        credentialSource: input.token?.trim() ? 'file' : 'env',
+        region,
+        next: ['Run aiwg decision ask --question "<q>" --yes-no --json.'],
+    };
+    if (input.verify) {
+        const verified = await askDecision({
+            question: 'Is this Jev decision setup verification request well formed?',
+            mode: { kind: 'yes-no' },
+            threshold: 0,
+            timeoutMs: 15_000,
+        }, options);
+        result.verified = verified.status === 'answered';
+        result.model = verified.model;
+        result.usage = verified.usage;
+    }
+    return result;
+}
+//# sourceMappingURL=ask.js.map

package/dist/src/decision/driver.js

@@ -2,7 +2,11 @@ import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { askDecision, setupJev, DecisionAskUsageError, readDecisionContextFile, validateDecisionAskInput, } from './ask.js';
+import { recordDecisionAsk, decisionLedgerHistory, decisionLedgerStats, resolveDecisionSessionId, parseDecisionLedgerSince, DecisionLedgerSinceError, DECISION_LEDGER_SCHEMA, ATTRIBUTION_FIELD_PATTERN, MAX_ATTRIBUTION_FIELD_LENGTH, MAX_RECORDED_CHOICE_IDS, MAX_RECORD_TEXT_BYTES, MAX_LEDGER_RECORD_BYTES, DECISION_LEDGER_RECORD_TIMEOUT_MS, DECISION_SAVINGS_REASONING_ALLOWANCE_TOKENS, DECISION_SAVINGS_ESTIMATION_METHOD, buildDecisionLedgerRecord, appendDecisionLedgerRecord, filterDecisionLedgerRecords, } from './ledger.js';
+import { resolveActiveProvider } from '../cli/provider-resolution.js';
 import { assertDecisionEvaluateDispatcherConfig, decisionPatternPacks, getDecisionPatternPack, governedPatternArtifacts, listDecisionPatterns, patternInputSchema, patternOutputSchema, planLiveDecisionPattern, runOfflineDecisionPattern, validateAgainstSchema, validateDecisionDocument, validateDefinition, validateRuleset, } from './index.js';
+export { askDecision, setupJev, readDecisionContextFile, validateDecisionAskInput, DecisionAskUsageError, recordDecisionAsk, decisionLedgerHistory, decisionLedgerStats, resolveDecisionSessionId, parseDecisionLedgerSince, DecisionLedgerSinceError, DECISION_LEDGER_SCHEMA, ATTRIBUTION_FIELD_PATTERN, MAX_ATTRIBUTION_FIELD_LENGTH, MAX_RECORDED_CHOICE_IDS, MAX_RECORD_TEXT_BYTES, MAX_LEDGER_RECORD_BYTES, DECISION_LEDGER_RECORD_TIMEOUT_MS, DECISION_SAVINGS_REASONING_ALLOWANCE_TOKENS, DECISION_SAVINGS_ESTIMATION_METHOD, buildDecisionLedgerRecord, appendDecisionLedgerRecord, filterDecisionLedgerRecords, resolveActiveProvider, };
 const DECISION_ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const VALIDATION_TARGETS = ['request', 'definition', 'ruleset', 'binding'];
 const OFFLINE_ADAPTER = 'agentic/code/addons/decision-engine/examples/fixture-jev-adapter.mjs';

package/dist/src/decision/entry.js

@@ -16,10 +16,42 @@ export class EntryAdmissionError extends Error {
         this.name = 'EntryAdmissionError';
     }
 }
+/**
+ * Starts an admission-budget clock, feature-detecting
+ * `process.threadCpuUsage()` once for this reading. `elapsedAdmissionMs`
+ * below reads the *type* of what this returns rather than re-detecting the
+ * feature, so one admission check always uses one clock end to end.
+ *
+ * Per-thread CPU time measures only the work the admitting call itself did
+ * on this thread, so it is immune both to host scheduling contention
+ * pausing this thread between reads (the root cause of #3047's false
+ * `time-budget` rejections of legitimate input under host load) and to
+ * other threads' or background GC's CPU time landing on this same process
+ * (which a process-wide `process.cpuUsage()` clock would still charge here
+ * -- not a safe substitute for the same reason `performance.now()` was not).
+ *
+ * `process.threadCpuUsage()` was added in Node v22.19.0 (per the installed
+ * `@types/node` `@since` annotation) and is absent on this project's
+ * `engines.node` floor (`>=20.0.0` in package.json) and on Node
+ * 22.0.0-22.18.x. On a runtime without it, this falls back to the
+ * pre-#3047 monotonic wall-clock guard as an explicitly documented
+ * compatibility fallback: it restores the original host-load sensitivity on
+ * those older runtimes, it does not resolve it there.
+ */
+export function admissionClockStart() {
+    return typeof process.threadCpuUsage === 'function' ? process.threadCpuUsage() : performance.now();
+}
+/** Elapsed time since `start` (from `admissionClockStart`), in milliseconds. */
+export function elapsedAdmissionMs(start) {
+    if (typeof start === 'number')
+        return performance.now() - start;
+    const diff = process.threadCpuUsage(start);
+    return (diff.user + diff.system) / 1000;
+}
 /** Check the object graph before JSON serialization, schema validation or digesting. */
 export function admitEntry(value, limits = DEFAULT_ENTRY_LIMITS) {
     const counts = { entries: 0, properties: 0, bytes: 0, estimatedMemoryBytes: 0 };
-    const started = performance.now();
+    const started = admissionClockStart();
     const encoder = new TextEncoder();
     const stack = new Set();
     const fail = (reason) => { throw new EntryAdmissionError(reason, counts); };
@@ -32,7 +64,7 @@ export function admitEntry(value, limits = DEFAULT_ENTRY_LIMITS) {
             fail('memory-budget');
     };
     const visit = (item, depth) => {
-        if (performance.now() - started > limits.timeMs)
+        if (elapsedAdmissionMs(started) > limits.timeMs)
             fail('time-budget');
         if (++counts.entries > limits.entries)
             fail('entry-count');
@@ -107,7 +139,7 @@ export function parseDecisionJson(source, limits = DEFAULT_ENTRY_LIMITS) {
         throw new EntryAdmissionError('serialized-bytes', { bytes });
     if (bytes * 4 > limits.memoryBytes)
         throw new EntryAdmissionError('memory-budget', { bytes });
-    const started = performance.now();
+    const started = admissionClockStart();
     let value;
     try {
         value = JSON.parse(source);
@@ -118,7 +150,7 @@ export function parseDecisionJson(source, limits = DEFAULT_ENTRY_LIMITS) {
     const document = parseDocument(source, { uniqueKeys: true });
     if (document.errors.length)
         throw new EntryAdmissionError('duplicate-or-invalid-key', { bytes });
-    if (performance.now() - started > limits.timeMs)
+    if (elapsedAdmissionMs(started) > limits.timeMs)
         throw new EntryAdmissionError('time-budget', { bytes });
     admitEntry(value, limits);
     return value;
@@ -130,7 +162,7 @@ export function parseDecisionYaml(source, limits = DEFAULT_ENTRY_LIMITS) {
         throw new EntryAdmissionError('serialized-bytes', { bytes });
     if (bytes * 4 > limits.memoryBytes)
         throw new EntryAdmissionError('memory-budget', { bytes });
-    const started = performance.now();
+    const started = admissionClockStart();
     const document = parseDocument(source, { uniqueKeys: true });
     if (document.errors.length)
         throw new EntryAdmissionError('duplicate-or-invalid-key', { bytes });
@@ -160,7 +192,7 @@ export function parseDecisionYaml(source, limits = DEFAULT_ENTRY_LIMITS) {
         }
     };
     inspect(document.contents, 0);
-    if (performance.now() - started > limits.timeMs)
+    if (elapsedAdmissionMs(started) > limits.timeMs)
         throw new EntryAdmissionError('time-budget', { bytes, entries });
     const value = document.toJS();
     admitEntry(value, limits);

package/dist/src/decision/heldout/collector.js

@@ -250,6 +250,12 @@ export async function collectHeldoutStudy(options) {
                     // No raw provider exceptions, model IDs or request IDs cross this boundary when a secret matches.
                     const raw = observation;
                     const metadata = wireMetadata;
+                    // `metadata` is `jev.ts`'s observer, reading model/usage off the exact same single parse that
+                    // produced `raw` (never a second, independent parse of the same bytes -- see jev.ts `observeParsed`).
+                    // The two can therefore no longer disagree on a successful response; preferring `metadata` here
+                    // only matters when `raw` is a failure (e.g. an otherwise-parseable but invalid answer), so the
+                    // model/usage bound checks below still see the wire-observed values jev.ts's `failure()` does not
+                    // carry.
                     const observed = raw && metadata ? { ...raw, actualModel: metadata.actualModel, usage: metadata.usage } : raw;
                     const completed = receipt;
                     const captures = QUALIFICATION_PRIVACY_SURFACES.map(surface => ({ surface,
@@ -275,7 +281,10 @@ export async function collectHeldoutStudy(options) {
                     else if (observed?.usage.costUsd !== null && observed?.usage.costUsd !== undefined && observed.usage.costUsd * 1_000_000 > reserveMicros)
                         outcome = 'price-bound';
                     else if (observed?.status === 'success') {
-                        if (observed.actualModel !== a.servedModel)
+                        // A null model is unknown, not a mismatch: it must complete neither as 'ok' nor as 'served-model'.
+                        if (observed.actualModel === null)
+                            outcome = 'model-unknown';
+                        else if (observed.actualModel !== a.servedModel)
                             outcome = 'served-model';
                         else if (observed.usage.inputTokens === null || observed.usage.outputTokens === null)
                             outcome = 'usage-unknown';