@aiwg/cli 2026.10.5 → 2026.10.7

package/dist/src/decision/pricing.js

@@ -0,0 +1,147 @@
+import { emptyConfig, readAiwgConfig, writeAiwgConfig } from '../config/aiwg-config.js';
+import { decisionSavingsWeights } from './savings.js';
+export const JEV_PRICING_SOURCE = 'https://docs.typesafe.ai/models.md';
+export const BUNDLED_JEV_PRICING = {
+    schema: 'aiwg-decision-pricing/v1', source: JEV_PRICING_SOURCE,
+    checkedAt: '2026-10-18T00:00:00.000Z', currency: 'USD', endpointOrigin: 'https://api.typesafe.ai',
+    models: { 'jev-1.13.0': { inputPerMillionUsd: 0.042, outputPerMillionUsd: 0 },
+        'jev-1.14.0': { inputPerMillionUsd: 0.042, outputPerMillionUsd: 0 } },
+};
+const MAX_BYTES = 256 * 1024;
+export function validTokenPrice(value) {
+    const p = value;
+    return !!p && [p.inputPerMillionUsd, p.outputPerMillionUsd, ...(p.cachedInputPerMillionUsd === undefined ? [] : [p.cachedInputPerMillionUsd])]
+        .every(n => typeof n === 'number' && Number.isFinite(n) && n >= 0 && n <= 1_000_000);
+}
+function validSnapshot(value) {
+    const p = value;
+    return !!p && p.schema === BUNDLED_JEV_PRICING.schema && p.source === JEV_PRICING_SOURCE && p.currency === 'USD'
+        && p.endpointOrigin === BUNDLED_JEV_PRICING.endpointOrigin && Number.isFinite(Date.parse(p.checkedAt))
+        && !!p.models && Object.keys(p.models).length > 0 && Object.entries(p.models).every(([id, price]) => /^jev-\d+\.\d+\.\d+$/.test(id) && validTokenPrice(price));
+}
+/** Parse only the official versioned-model table; never guess output billing or aliases. */
+export function parseJevPricing(markdown, checkedAt = new Date().toISOString()) {
+    const rows = markdown.split('\n').filter(line => line.trim().startsWith('|')).map(line => line.split('|').slice(1, -1).map(cell => cell.trim()));
+    const ids = rows.find(row => row[0] === 'Model ID');
+    const prices = rows.find(row => row[0] === 'Price (per Btok / per Mtok)');
+    if (!ids || !prices || ids.length !== prices.length || !/Output tokens are free\./i.test(markdown))
+        throw new Error('Official Jev pricing format changed; keeping the prior snapshot.');
+    const models = {};
+    for (let i = 1; i < ids.length; i++) {
+        const id = /^`(jev-\d+\.\d+\.\d+)`$/.exec(ids[i])?.[1];
+        const price = /^\\?\$([\d.]+)\s*\/\s*\\?\$([\d.]+)$/.exec(prices[i]);
+        if (!id || !price || !Number.isFinite(Number(price[1])) || !Number.isFinite(Number(price[2])) || Math.abs(Number(price[1]) / 1000 - Number(price[2])) > 1e-10)
+            throw new Error('Invalid official Jev price table.');
+        if (models[id])
+            throw new Error('Duplicate Jev model in official price table.');
+        models[id] = { inputPerMillionUsd: Number(price[2]), outputPerMillionUsd: 0 };
+    }
+    const snapshot = { ...BUNDLED_JEV_PRICING, models, checkedAt };
+    if (!validSnapshot(snapshot))
+        throw new Error('Invalid Jev pricing snapshot.');
+    return snapshot;
+}
+/** Explicit public-document fetch only; no credentials, redirects, cache or model calls. */
+async function fetchPricing(fetcher, now) {
+    const controller = new AbortController();
+    let timeout;
+    const operation = async () => {
+        const response = await fetcher(JEV_PRICING_SOURCE, {
+            redirect: 'error', credentials: 'omit', signal: controller.signal, headers: { Accept: 'text/markdown' },
+        });
+        if (!response.ok || !response.body)
+            throw new Error(`Jev pricing refresh failed (${response.status}).`);
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+            while (true) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    break;
+                size += chunk.value.byteLength;
+                if (size > MAX_BYTES)
+                    throw new Error('Jev pricing document exceeds limit.');
+                chunks.push(chunk.value);
+            }
+        }
+        finally {
+            void reader.cancel().catch(() => { });
+        }
+        return parseJevPricing(Buffer.concat(chunks).toString('utf8'), now.toISOString());
+    };
+    try {
+        // Bound the entire body read, including injected fetchers which ignore abort.
+        return await Promise.race([operation(), new Promise((_, reject) => {
+                timeout = setTimeout(() => { controller.abort(); reject(new Error('Jev pricing refresh timed out.')); }, 5000);
+            })]);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/** The existing project config is the only persisted pricing system. */
+export async function decisionPricing(options) {
+    if (!options.refresh && (options.offline || options.allowSnapshot || options.dryRun || options.model)) {
+        throw new Error('--offline, --allow-snapshot, --dry-run and --model require --refresh');
+    }
+    const config = (await readAiwgConfig(options.cwd)) ?? emptyConfig();
+    const before = config.decision?.ask?.cost ?? {};
+    if (!options.refresh) {
+        const weights = decisionSavingsWeights(config.decision?.ask);
+        return { refreshed: false, written: false, current: { llm_per_mtok: weights.llm_per_mtok, jev_per_mtok: weights.jev_per_mtok,
+                ...before, source: before.source ?? 'manual', checked_at: before.checked_at ?? null, jev_model: before.jev_model ?? null }, sourceUrl: JEV_PRICING_SOURCE };
+    }
+    // Validate selection before starting any network operation.
+    const model = options.model ?? before.jev_model;
+    if (!model || !/^jev-\d+\.\d+\.\d+$/.test(model))
+        throw new Error('Refresh requires --model jev-X.Y.Z or a configured jev_model. Config unchanged.');
+    let snapshot;
+    let warning = null;
+    let source = 'typesafe-docs';
+    if (options.offline) {
+        snapshot = structuredClone(BUNDLED_JEV_PRICING);
+        source = 'typesafe-snapshot';
+    }
+    else {
+        try {
+            snapshot = await fetchPricing(options.fetch ?? fetch, options.now ?? new Date());
+        }
+        catch (error) {
+            if (!options.allowSnapshot)
+                throw new Error(`${error instanceof Error ? error.message : String(error)} Config unchanged; use --allow-snapshot to permit the dated bundled snapshot.`);
+            snapshot = structuredClone(BUNDLED_JEV_PRICING);
+            source = 'typesafe-snapshot';
+            warning = error instanceof Error ? error.message : String(error);
+        }
+    }
+    // Require an explicit or previously selected version rather than guessing latest.
+    const price = snapshot.models[model];
+    if (!price)
+        throw new Error(`No sourced rates for ${model}. Config unchanged.`);
+    const after = { ...before, jev_input_per_mtok: price.inputPerMillionUsd, jev_output_per_mtok: price.outputPerMillionUsd,
+        source, checked_at: snapshot.checkedAt.slice(0, 10), jev_model: model };
+    const diff = Object.entries(after).filter(([key, value]) => before[key] !== value)
+        .map(([key, value]) => ({ key: `decision.ask.cost.${key}`, before: before[key] ?? null, after: value }));
+    if (!options.dryRun) {
+        config.decision = { ...config.decision, ask: { ...config.decision?.ask, cost: after } };
+        await writeAiwgConfig(options.cwd, config);
+    }
+    return { refreshed: true, written: !options.dryRun, dryRun: !!options.dryRun, current: after, diff,
+        sourceUrl: snapshot.source, warning, snapshotDate: source === 'typesafe-snapshot' ? after.checked_at : null };
+}
+/** API-equivalent cost from complete billable usage. Missing cache billing stays unknown. */
+export function tokenCost(usage, price) {
+    if (!validTokenPrice(price) || !usage || usage.inputTokens === null
+        || (price.outputPerMillionUsd > 0 && usage.outputTokens === null))
+        return null;
+    if (![usage.inputTokens, usage.outputTokens ?? 0].every(n => Number.isSafeInteger(n) && n >= 0))
+        return null;
+    const cached = price.cachedInputPerMillionUsd === undefined ? 0 : usage.cachedInputTokens;
+    if (cached == null || !Number.isSafeInteger(cached) || cached < 0 || cached > usage.inputTokens)
+        return null;
+    return ((usage.inputTokens - cached) * price.inputPerMillionUsd
+        + cached * (price.cachedInputPerMillionUsd ?? price.inputPerMillionUsd)
+        + (usage.outputTokens ?? 0) * price.outputPerMillionUsd) / 1_000_000;
+}
+//# sourceMappingURL=pricing.js.map

package/dist/src/decision/qualification/gate-evidence.js

@@ -4,6 +4,8 @@ import { matchEvidenceDigest } from '../../gates/stats/index.js';
 import { CalibrationRegistry, calibrationArtifactDigest } from '../calibration/registry.js';
 import { validateCaseInventory } from './manifest.js';
 import { verifyQualificationSplits } from './quality.js';
+import { DECISION_STAGED_LOAD_RESULT_VERSIONS, verifyDecisionStagedLoadRecord } from './load.js';
+import { validateReviewEvaluation } from '../review/validate.js';
 const range = (prefix, from, to) => Array.from({ length: to - from + 1 }, (_, index) => `${prefix}${String(from + index).padStart(2, '0')}`);
 export const DECISION_GATE_SUITES = {
     'contract-suite-complete': { gate: 'G0', caseIds: ['C36'], evidenceIds: [
@@ -32,7 +34,7 @@ export const DECISION_GATE_SUITES = {
 export const GATE_ARTIFACT_SCHEMAS = {
     'immutable-splits': 'decision-binary-benchmark-plan/v2',
     'calibration-qualified': 'decision-calibration-artifact/v1',
-    'load-manifest-qualified': 'decision-load-result/v1',
+    'load-manifest-qualified': 'decision-load-result/v2',
     'review-decision-recorded': 'decision-qualification-review/v1',
 };
 export const GATE_ARTIFACT_FLAGS = Object.keys(GATE_ARTIFACT_SCHEMAS);
@@ -124,33 +126,30 @@ function validCalibration(value, context) {
         && artifact.metrics.calibrationError <= artifact.profile.maximumCalibrationError
         && artifact.metrics.selectiveRisk <= artifact.profile.maximumSelectiveRisk;
 }
-function validLoadResult(value) {
-    if (!record(value) || value.schemaVersion !== GATE_ARTIFACT_SCHEMAS['load-manifest-qualified'])
+function validLoadResult(value, context) {
+    if (!record(value) || !DECISION_STAGED_LOAD_RESULT_VERSIONS.includes(String(value.schemaVersion)))
         return false;
-    const result = value;
-    if (!record(result.manifest) || result.manifest.schema !== 'decision-load-manifest/v1' || !record(result.manifest.bounds)
-        || !record(result.observations) || !validDate(result.recordedAt) || result.mode !== result.manifest.mode)
+    // Legacy records remain readable, but only completed live v3 evidence bound to
+    // this exact clean source revision can qualify the performance gate.
+    if (context.manifest.dirty !== false || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(context.manifest.sourceCommit))
         return false;
-    let digest;
     try {
-        digest = loadManifestDigest(result.manifest);
+        return verifyDecisionStagedLoadRecord(value, context.manifest.sourceCommit);
     }
     catch {
         return false;
     }
-    const bounds = Object.entries(result.manifest.bounds);
-    return digest === result.manifestDigest && bounds.length > 0
-        && Object.keys(result.observations).length === bounds.length
-        && bounds.every(([name, limit]) => {
-            const observed = result.observations[name];
-            return Number.isFinite(limit) && limit >= 0 && typeof observed === 'number' && Number.isFinite(observed)
-                && observed >= 0 && observed <= limit;
-        });
 }
 function validReview(value, context) {
     if (!record(value) || value.schemaVersion !== GATE_ARTIFACT_SCHEMAS['review-decision-recorded'])
         return false;
     const review = value;
+    try {
+        validateReviewEvaluation(review.evaluation);
+    }
+    catch {
+        return false;
+    }
     return review.runId === context.manifest.runId && review.sourceCommit === context.manifest.sourceCommit
         && typeof review.reviewer === 'string' && review.reviewer.trim().length > 0 && review.decision === 'approve'
         && validDate(review.recordedAt) && review.outcomesDigest === qualificationOutcomesDigest(context.manifest);
@@ -160,7 +159,7 @@ export function validateGateArtifact(flag, value, context) {
     switch (flag) {
         case 'immutable-splits': return validSplitPlan(value);
         case 'calibration-qualified': return validCalibration(value, context);
-        case 'load-manifest-qualified': return validLoadResult(value);
+        case 'load-manifest-qualified': return validLoadResult(value, context);
         case 'review-decision-recorded': return validReview(value, context);
         default: return false;
     }
@@ -178,9 +177,15 @@ export function deriveGateEvidence(manifest, proof = {}) {
         const ref = manifest.gateArtifacts?.[flag];
         const versionOk = flag === 'immutable-splits'
             ? ref !== undefined && IMMUTABLE_SPLIT_VERSIONS.includes(ref.schemaVersion)
-            : ref !== undefined && ref.schemaVersion === GATE_ARTIFACT_SCHEMAS[flag];
+            : flag === 'load-manifest-qualified'
+                ? ref !== undefined && DECISION_STAGED_LOAD_RESULT_VERSIONS.includes(ref.schemaVersion)
+                : ref !== undefined && ref.schemaVersion === GATE_ARTIFACT_SCHEMAS[flag];
         flags[flag] = versionOk && ref !== undefined
             && typeof ref.artifact === 'string' && ref.artifact.length > 0 && sha256Pattern.test(ref.digest);
+        if (flag === 'load-manifest-qualified') {
+            flags[flag] = flags[flag] === true && proof.loadArtifactVerified === true && manifest.dirty === false
+                && /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(manifest.sourceCommit);
+        }
     }
     return flags;
 }