@aiwg/cli 2026.9.21 → 2026.10.0

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

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './contract.js';
+export * from './collector.js';
+export * from './journal.js';
+export * from './generators.js';
+export * from './generator-registry.js';
+export * from './study-generators.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,346 @@
+import { lstat, mkdir, open, readdir, readFile, realpath, rename } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { heldoutDigest, HeldoutError, heldoutRequest, heldoutReservationMicros, heldoutReservationTokens, validateHeldoutAttempt, validateHeldoutBundle, checkHeldoutSchema, HELDOUT_CAP_USD, HELDOUT_PORTFOLIO_CAP_USD } from './contract.js';
+export const heldoutRunsRoot = (root) => join(root, 'research', 'qualification', 'heldout', 'runs');
+const baselineRoot = (root) => join(root, 'research', 'qualification', 'heldout', 'baselines');
+const counterRoot = (root) => dirname(heldoutRunsRoot(root));
+const chargeKey = (charge) => `${charge.study}/${charge.runId}/${charge.rowId}/${charge.requestId}/${charge.ordinal}`;
+const repair = () => new HeldoutError('spend-counter-operator-repair-required');
+const baselineDigests = (baselines) => Object.fromEntries([...baselines].map(([scope, baseline]) => [scope, heldoutDigest(baseline)]));
+async function counterHead(root, event, baselines) {
+    const dir = counterRoot(root), temporary = join(dir, 'spend-head.next.json');
+    const head = { schemaVersion: 'decision-heldout-spend-head/v2', sequence: event.sequence, digest: event.digest,
+        baselineDigests: baselineDigests(baselines) };
+    checkHeldoutSchema('SpendHead', head);
+    await writeHeldoutFile(temporary, head);
+    await rename(temporary, join(dir, 'spend-head.json'));
+    const directory = await open(dir, 'r');
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}
+/** The independent head binds baselines and detects valid-prefix truncation after all run files disappear. */
+async function readCounter(root, baselines) {
+    const dir = counterRoot(root), path = join(dir, 'spend-counter.jsonl');
+    const names = await readdir(dir);
+    if (!names.includes('spend-counter.jsonl') && !baselines.size && !names.includes('spend-head.json')
+        && !names.includes('spend-head.next.json'))
+        return { events: [], studies: new Map(), blocked: false };
+    try {
+        if (names.includes('spend-head.next.json'))
+            throw repair();
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 32_000_000)
+            throw repair();
+        const bytes = await readFile(path, 'utf8');
+        if (!bytes.endsWith('\n'))
+            throw repair();
+        const events = [], studies = new Map(), latest = new Map();
+        let total = 0;
+        for (const line of bytes.slice(0, -1).split('\n')) {
+            const event = JSON.parse(line);
+            checkHeldoutSchema('SpendEvent', event);
+            const { digest, ...payload } = event;
+            if (event.sequence !== events.length + 1 || event.previous !== (events.at(-1)?.digest ?? null)
+                || digest !== heldoutDigest(payload) || (events.length === 0) !== (event.charge === null))
+                throw repair();
+            const charge = event.charge;
+            if (charge) {
+                const key = chargeKey(charge), prior = latest.get(key);
+                if (charge.accountedUsdMicros === null ? prior || charge.disposition !== null
+                    : !prior || prior.accountedUsdMicros !== null || charge.disposition === null
+                        || charge.reservedTokens !== prior.reservedTokens || charge.reservedUsdMicros !== prior.reservedUsdMicros || charge.accountedUsdMicros < charge.reservedUsdMicros)
+                    throw repair();
+                const delta = charge.accountedUsdMicros === null ? charge.reservedUsdMicros : charge.accountedUsdMicros - charge.reservedUsdMicros;
+                total += delta;
+                studies.set(charge.study, (studies.get(charge.study) ?? 0) + delta);
+                latest.set(key, charge);
+            }
+            if (event.totalUsdMicros !== total || !Number.isSafeInteger(total))
+                throw repair();
+            events.push(event);
+        }
+        const head = await readHeldoutFile(join(dir, 'spend-head.json'));
+        checkHeldoutSchema('SpendHead', head);
+        if (head.sequence !== events.length || head.digest !== events.at(-1)?.digest
+            || heldoutDigest(head.baselineDigests) !== heldoutDigest(baselineDigests(baselines))
+            || [...baselines.values()].some(b => b.counterGenesisDigest !== events[0].digest))
+            throw repair();
+        if (!baselines.has('portfolio') || [...studies.keys()].some(study => !baselines.has(study)))
+            throw repair();
+        return { events, studies, blocked: [...latest.values()].some(c => c.disposition === null || c.disposition === 'stop') };
+    }
+    catch {
+        throw repair();
+    }
+}
+/** Caller holds the global dispatch lock. Never rewrite or refund a counter entry. */
+export async function appendHeldoutSpend(root, attempt) {
+    const baselines = await readBaselines(root), counter = await readCounter(root, baselines);
+    const charge = { study: attempt.study, runId: attempt.runId, rowId: attempt.rowId, requestId: attempt.requestId,
+        ordinal: attempt.ordinal, reservedUsdMicros: attempt.reservedUsdMicros, reservedTokens: attempt.reservedTokens,
+        accountedUsdMicros: attempt.result?.accountedUsdMicros ?? null, disposition: attempt.result?.disposition ?? null };
+    validateHeldoutAttempt(attempt);
+    const prior = [...counter.events].reverse().find(event => event.charge && chargeKey(event.charge) === chargeKey(charge))?.charge;
+    if (attempt.result ? !prior || prior.accountedUsdMicros !== null || prior.reservedUsdMicros !== charge.reservedUsdMicros || prior.reservedTokens !== charge.reservedTokens
+        || attempt.result.accountedUsdMicros < attempt.reservedUsdMicros : prior)
+        throw repair();
+    const delta = attempt.result ? attempt.result.accountedUsdMicros - attempt.reservedUsdMicros : attempt.reservedUsdMicros;
+    const payload = { schemaVersion: 'decision-heldout-spend-event/v1', sequence: counter.events.length + 1,
+        previous: counter.events.at(-1).digest, charge, totalUsdMicros: counter.events.at(-1).totalUsdMicros + delta };
+    const event = { ...payload, digest: heldoutDigest(payload) };
+    checkHeldoutSchema('SpendEvent', event);
+    const file = await open(join(counterRoot(root), 'spend-counter.jsonl'), 'a');
+    try {
+        await file.writeFile(JSON.stringify(event) + '\n');
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+    await counterHead(root, event, baselines);
+}
+async function readBaselines(root) {
+    await heldoutDirectory(baselineRoot(root));
+    const baselines = new Map();
+    for (const name of await readdir(baselineRoot(root))) {
+        const baseline = await readHeldoutFile(join(baselineRoot(root), name));
+        checkHeldoutSchema('Baseline', baseline);
+        if (name !== `${baseline.scope}.json`)
+            throw new HeldoutError('baseline-path');
+        baselines.set(baseline.scope, baseline);
+    }
+    return baselines;
+}
+function checkBaselineApproval(baselines, approval) {
+    for (const [scope, usd] of [[approval.study, approval.priorStudySpendUsd], ['portfolio', approval.priorPortfolioSpendUsd]]) {
+        if (baselines.has(scope) && baselines.get(scope).usdMicros !== Math.ceil(usd * 1_000_000))
+            throw new HeldoutError('baseline-changed');
+    }
+    const study = baselines.get(approval.study);
+    if (study && heldoutDigest(study.budget) !== heldoutDigest(approval.budget))
+        throw new HeldoutError('budget-changed');
+}
+/** Called under the global dispatch lock, after checking existing journals. Floors and study budgets are recorded once. */
+export async function reconcileHeldoutBaseline(root, approval) {
+    const baselines = await readBaselines(root);
+    const counter = await readCounter(root, baselines);
+    checkBaselineApproval(baselines, approval);
+    let head = counter.events.at(-1);
+    if (!head) {
+        const payload = { schemaVersion: 'decision-heldout-spend-event/v1', sequence: 1, previous: null, charge: null, totalUsdMicros: 0 };
+        head = { ...payload, digest: heldoutDigest(payload) };
+        await writeHeldoutFile(join(counterRoot(root), 'spend-counter.jsonl'), head);
+    }
+    const genesis = counter.events[0]?.digest ?? head.digest;
+    let changed = false;
+    for (const [scope, usd] of [[approval.study, approval.priorStudySpendUsd], ['portfolio', approval.priorPortfolioSpendUsd]]) {
+        const usdMicros = Math.ceil(usd * 1_000_000), baseline = baselines.get(scope);
+        if (!baseline) {
+            const recorded = { schemaVersion: 'decision-heldout-baseline/v1', scope, usdMicros,
+                approvalDigest: heldoutDigest(approval), counterGenesisDigest: genesis, budget: scope === 'portfolio' ? null : approval.budget };
+            await writeHeldoutFile(join(baselineRoot(root), `${scope}.json`), recorded);
+            baselines.set(scope, recorded);
+            changed = true;
+        }
+    }
+    // Publish only after every baseline is durable. A partial update fails closed on the next read.
+    if (changed)
+        await counterHead(root, head, baselines);
+    const recorded = await readBaselines(root);
+    return { study: heldoutDigest(recorded.get(approval.study)), portfolio: heldoutDigest(recorded.get('portfolio')) };
+}
+/** Reject symlinked journal ancestors as well as leaves: spend cannot be redirected to another root. */
+export async function heldoutDirectory(path) {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+    if (await realpath(path) !== resolve(path))
+        throw new HeldoutError('artifact-symlink');
+}
+export async function writeHeldoutFile(path, value) {
+    const file = await open(path, 'wx', 0o600);
+    try {
+        await file.writeFile(JSON.stringify(value) + '\n');
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+    const directory = await open(dirname(path), 'r');
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}
+export async function readHeldoutFile(path) {
+    const stat = await lstat(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 32_000_000)
+        throw new HeldoutError('artifact-file');
+    return JSON.parse(await readFile(path, 'utf8'));
+}
+export async function readHeldoutJournal(run) {
+    if (await realpath(run) !== resolve(run))
+        throw new HeldoutError('artifact-symlink');
+    const entries = (await readdir(run)).filter(name => /^\d{8}\.json$/.test(name)).sort();
+    const events = [];
+    const pending = new Map();
+    const seen = new Set();
+    for (const name of entries) {
+        const event = await readHeldoutFile(join(run, name));
+        checkHeldoutSchema('Event', event);
+        const { digest, ...payload } = event;
+        if (Object.keys(event).sort().join(',') !== 'attempt,digest,previous,schemaVersion,sequence'
+            || event.sequence !== events.length + 1 || name !== `${String(event.sequence).padStart(8, '0')}.json`
+            || event.previous !== (events.at(-1)?.digest ?? null) || digest !== heldoutDigest(payload))
+            throw new HeldoutError('journal-chain');
+        validateHeldoutAttempt(event.attempt);
+        const attempt = event.attempt, key = `${attempt.rowId}/${attempt.requestId}/${attempt.ordinal}`;
+        if (!attempt.result) {
+            if (seen.has(key))
+                throw new HeldoutError('duplicate-reservation');
+            seen.add(key);
+            pending.set(key, attempt);
+        }
+        else {
+            const reservation = pending.get(key);
+            if (!reservation || heldoutDigest({ ...attempt, result: null }) !== heldoutDigest(reservation))
+                throw new HeldoutError('unreserved-result');
+            pending.delete(key);
+            const trace = await readHeldoutFile(join(run, `trace-${event.sequence - 1}.json`));
+            if (heldoutDigest(trace) !== attempt.result.traceDigest)
+                throw new HeldoutError('trace-digest');
+        }
+        events.push(event);
+    }
+    return events;
+}
+export async function appendHeldoutEvent(run, events, attempt) {
+    validateHeldoutAttempt(attempt);
+    const payload = { schemaVersion: 'decision-heldout-event/v1', sequence: events.length + 1, previous: events.at(-1)?.digest ?? null, attempt: structuredClone(attempt) };
+    const event = { ...payload, digest: heldoutDigest(payload) };
+    await writeHeldoutFile(join(run, `${String(event.sequence).padStart(8, '0')}.json`), event);
+    events.push(event);
+}
+export async function heldoutEvidenceDigest(run, events) {
+    return heldoutDigest({ frozenDigest: heldoutDigest(await readHeldoutFile(join(run, 'frozen.json'))),
+        journalDigest: events.at(-1)?.digest ?? heldoutDigest([]) });
+}
+/** Count reservations, including crashes and failed requests; successful small usage never refunds spend. */
+export async function scanHeldoutSpend(root, study, approval) {
+    const runs = heldoutRunsRoot(root);
+    await heldoutDirectory(runs);
+    const baselines = await readBaselines(root);
+    if (approval) {
+        if (approval.study !== study)
+            throw new HeldoutError('baseline-study');
+        checkBaselineApproval(baselines, approval);
+    }
+    const counter = await readCounter(root, baselines);
+    const result = { studyUsdMicros: baselines.get(study)?.usdMicros ?? 0,
+        portfolioUsdMicros: baselines.get('portfolio')?.usdMicros ?? 0, studyCalls: 0, studyReservedTokens: 0, counterBlocked: counter.blocked, attempts: [], journalDigests: [], runs: [] };
+    for (const { charge } of counter.events)
+        if (charge?.study === study && charge.accountedUsdMicros === null) {
+            result.studyCalls++;
+            result.studyReservedTokens += charge.reservedTokens;
+        }
+    for (const name of (await readdir(runs)).sort()) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(name))
+            throw new HeldoutError('run-path');
+        const run = join(runs, name);
+        const frozen = await readHeldoutFile(join(run, 'frozen.json'));
+        checkHeldoutSchema('Frozen', frozen);
+        if (frozen.approval?.runId !== name || !['D17', 'D29'].includes(frozen.approval.study)
+            || frozen.digest !== heldoutDigest(frozen.bundle))
+            throw new HeldoutError('frozen-inputs');
+        validateHeldoutBundle(frozen.bundle, heldoutDigest(frozen.bundle.approval));
+        const approval = frozen.bundle.approval;
+        if (baselines.get(approval.study)?.usdMicros !== Math.ceil(approval.priorStudySpendUsd * 1_000_000)
+            || baselines.get('portfolio')?.usdMicros !== Math.ceil(approval.priorPortfolioSpendUsd * 1_000_000))
+            throw new HeldoutError('baseline-mismatch');
+        if (frozen.baselineDigests.study !== heldoutDigest(baselines.get(approval.study))
+            || frozen.baselineDigests.portfolio !== heldoutDigest(baselines.get('portfolio')))
+            throw new HeldoutError('baseline-mismatch');
+        if (frozen.bundle.approval.runId !== name || frozen.bundle.approval.study !== frozen.approval.study)
+            throw new HeldoutError('frozen-run');
+        for (const prior of frozen.priorRuns) {
+            if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(prior.runId) || prior.runId === name)
+                throw new HeldoutError('prior-run');
+            const path = join(runs, prior.runId);
+            if (await heldoutEvidenceDigest(path, await readHeldoutJournal(path)) !== prior.evidenceDigest)
+                throw new HeldoutError('prior-evidence');
+        }
+        const events = await readHeldoutJournal(run);
+        await validateHeldoutJournal(frozen.bundle, events);
+        if ((await readdir(run)).includes('summary.json')) {
+            const summary = await readHeldoutFile(join(run, 'summary.json'));
+            checkHeldoutSchema('Summary', summary);
+            if (summary.evidenceDigest !== await heldoutEvidenceDigest(run, events))
+                throw new HeldoutError('truncated-journal');
+        }
+        result.runs.push({ runId: name, evidenceDigest: await heldoutEvidenceDigest(run, events), corpusDigest: frozen.bundle.approval.corpusDigest, study: frozen.approval.study, source: frozen.source });
+        const latest = new Map();
+        for (const { attempt } of events) {
+            if (attempt.runId !== name || attempt.study !== frozen.approval.study)
+                throw new HeldoutError('journal-run');
+            const key = `${attempt.rowId}/${attempt.requestId}/${attempt.ordinal}`;
+            if (!attempt.result) {
+                result.portfolioUsdMicros += attempt.reservedUsdMicros;
+                if (attempt.study === study)
+                    result.studyUsdMicros += attempt.reservedUsdMicros;
+            }
+            else {
+                if (attempt.result.accountedUsdMicros < attempt.reservedUsdMicros)
+                    throw new HeldoutError('reservation-refund');
+                const extra = attempt.result.accountedUsdMicros - attempt.reservedUsdMicros;
+                result.portfolioUsdMicros += extra;
+                if (attempt.study === study)
+                    result.studyUsdMicros += extra;
+            }
+            latest.set(key, attempt);
+        }
+        result.attempts.push(...latest.values());
+        if (events.length)
+            result.journalDigests.push(events.at(-1).digest);
+    }
+    result.studyUsdMicros = Math.max(result.studyUsdMicros, (baselines.get(study)?.usdMicros ?? 0) + (counter.studies.get(study) ?? 0));
+    result.portfolioUsdMicros = Math.max(result.portfolioUsdMicros, (baselines.get('portfolio')?.usdMicros ?? 0) + (counter.events.at(-1)?.totalUsdMicros ?? 0));
+    // A first-run preview includes its proposed baseline without writing it or reusing a max floor.
+    if (approval && !baselines.has(study))
+        result.studyUsdMicros += Math.ceil(approval.priorStudySpendUsd * 1_000_000);
+    if (approval && !baselines.has('portfolio'))
+        result.portfolioUsdMicros += Math.ceil(approval.priorPortfolioSpendUsd * 1_000_000);
+    return result;
+}
+/** Replay enforces the same membership, phase and reservation pins as dispatch. */
+export async function validateHeldoutJournal(bundle, events) {
+    for (const { attempt } of events) {
+        if (attempt.runId !== bundle.approval.runId || attempt.study !== bundle.approval.study)
+            throw new HeldoutError('journal-run');
+        const approved = bundle.approval;
+        const row = bundle.corpus.rows.find(row => row.id === attempt.rowId);
+        const request = row?.requests.find(request => request.id === attempt.requestId);
+        if (!row || !request)
+            throw new HeldoutError('journal-pins');
+        const planned = await heldoutRequest(bundle.corpus, bundle.preregistration, approved, row, request);
+        if (attempt.corpusDigest !== approved.corpusDigest || attempt.preregistrationDigest !== approved.preregistrationDigest
+            || attempt.approvalDigest !== heldoutDigest(approved) || attempt.requestDigest !== planned.requestDigest
+            || attempt.reservedUsdMicros !== heldoutReservationMicros(approved, planned.estimatedTokens)
+            || attempt.reservedTokens !== heldoutReservationTokens(bundle.preregistration, planned.estimatedTokens))
+            throw new HeldoutError('journal-pins');
+    }
+}
+/** Every mode shares fixed thresholds; admission checks the approval against its durable study baseline. */
+export function heldoutCollectionAllowance(approval, prior) {
+    const studyRemaining = HELDOUT_CAP_USD[approval.study] * 1_000_000 - prior.studyUsdMicros;
+    const portfolioRemaining = HELDOUT_PORTFOLIO_CAP_USD * 1_000_000 - prior.portfolioUsdMicros;
+    const studySpent = prior.studyUsdMicros - Math.ceil(approval.priorStudySpendUsd * 1_000_000);
+    const portfolioSpent = prior.portfolioUsdMicros - Math.ceil(approval.priorPortfolioSpendUsd * 1_000_000);
+    return { calls: Math.floor(approval.budget.calls * 0.8) - prior.studyCalls,
+        tokens: Math.floor(approval.budget.tokens * 0.8) - prior.studyReservedTokens,
+        usdMicros: Math.min(Math.floor(approval.budget.usd * 800_000) - studySpent, Math.floor((studyRemaining + studySpent) * 0.8) - studySpent, Math.floor((portfolioRemaining + portfolioSpent) * 0.8) - portfolioSpent) };
+}
+//# sourceMappingURL=journal.js.map

package/dist/src/decision/heldout/study-generators.js

@@ -0,0 +1,64 @@
+import { readFileSync } from 'node:fs';
+import { sha256 } from '../compile-cache/identity.js';
+import { generateRegisteredHeldoutRow, registeredHeldoutGeneratorDigest, registeredHeldoutGeneratorFiles, reproducibleRegisteredHeldoutRow } from './generator-registry.js';
+import { d17MfGenerateCase } from '../ensemble-study/multifact.js';
+/**
+ * Outer held-out generator registry for study generators added after D29 v8 (#2850).
+ *
+ * `generators.ts` and `generator-registry.ts` are themselves hashed into the D29 v1-v8 generator pins, so editing either
+ * would move committed corpus pins. New study generators register here instead: this module answers for its own ids and
+ * delegates every other id to the existing registries unchanged. Each id hashes only its own sources. Source-controlled
+ * only: corpus data cannot register code or supply a module path.
+ */
+export const D17_MULTIFACT_GENERATOR_ID = 'd17-multifact/v1';
+// The generator and the hash it imports for draws and record digests.
+const D17_MULTIFACT_SOURCES = ['src/decision/ensemble-study/multifact.ts', 'src/decision/compile-cache/identity.ts'];
+export function generateStudyHeldoutRow(generatorId, seed) {
+    if (generatorId !== D17_MULTIFACT_GENERATOR_ID)
+        return generateRegisteredHeldoutRow(generatorId, seed);
+    const output = d17MfGenerateCase(seed).row;
+    return { ...output, provenance: { generatorId, seed, outputDigest: sha256(output) } };
+}
+export function reproducibleStudyHeldoutRow(row) {
+    if (row?.provenance?.generatorId !== D17_MULTIFACT_GENERATOR_ID)
+        return reproducibleRegisteredHeldoutRow(row);
+    const { provenance, ...output } = row;
+    try {
+        const regenerated = d17MfGenerateCase(provenance.seed).row;
+        return sha256(regenerated) === provenance.outputDigest && sha256(output) === provenance.outputDigest;
+    }
+    catch {
+        return false;
+    }
+}
+export function studyHeldoutGeneratorFiles(generatorId) {
+    return generatorId === D17_MULTIFACT_GENERATOR_ID ? [...D17_MULTIFACT_SOURCES] : registeredHeldoutGeneratorFiles(generatorId);
+}
+export function studyHeldoutGeneratorDigest(generatorId) {
+    if (generatorId !== D17_MULTIFACT_GENERATOR_ID)
+        return registeredHeldoutGeneratorDigest(generatorId);
+    const sources = {};
+    for (const file of D17_MULTIFACT_SOURCES)
+        sources[file] = readFileSync(new URL(`../../../${file}`, import.meta.url), 'utf8');
+    return sha256(sources);
+}
+/**
+ * D17-MF collector-boundary policy, keyed on the generator id the way D29's paid-generator rule is (#2850). It is enforced
+ * by `validateHeldoutBundle` and the collector, so a hand-built bundle cannot skip the CLI's checks.
+ *
+ * - Public seeds: committed or review seeds regenerate gold from source. A private seed must also carry at least 24
+ *   lowercase hex characters of fresh randomness, so memorable or committed near-variants are refused too.
+ * - Calibration window: the probe is scored only through the registered D17 member calibrator, which expires at its
+ *   `effectiveAt` (2026-10-02T10:02:34.263Z) plus the D17 profile's 30 days. No session may dispatch past it.
+ */
+export const D17_MULTIFACT_CALIBRATION_NOT_AFTER = '2026-11-01T10:02:34.263Z';
+export const D17_MULTIFACT_PUBLIC_SEEDS = Object.freeze(['d17mf-offline', 'd17mf-public-demo', 'd17mf-smoke',
+    'd17mf-7f3a9c2e1b', 'review-throwaway-a1', 'review-throwaway-b2']);
+export function d17MultifactPublicSeed(seed) {
+    return typeof seed !== 'string' || D17_MULTIFACT_PUBLIC_SEEDS.includes(seed)
+        || /^(review-|d17mf-(offline|public|smoke|sweep|demo))/.test(seed) || !/[0-9a-f]{24}/.test(seed);
+}
+export function usesD17MultifactGenerator(rows) {
+    return Array.isArray(rows) && rows.some(row => row?.provenance?.generatorId === D17_MULTIFACT_GENERATOR_ID);
+}
+//# sourceMappingURL=study-generators.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/decision/host-policy.js

@@ -0,0 +1,61 @@
+const HOST_POLICY_KEYS = [
+    'batching',
+    'batchReceipts',
+    'context',
+    'scheduler',
+    'compileCache',
+    'resultCache',
+    'providerPrefix',
+];
+const KEY_SET = new Set(HOST_POLICY_KEYS);
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function assertDecisionHostPolicyRefs(value) {
+    if (!isRecord(value))
+        throw new Error('hostPolicies must be an object of named trusted host-policy references');
+    for (const [key, ref] of Object.entries(value)) {
+        if (!KEY_SET.has(key))
+            throw new Error(`Unsupported decision host policy '${key}'. Supported policies: ${HOST_POLICY_KEYS.join(', ')}`);
+        if (typeof ref !== 'string' || !ref.trim())
+            throw new Error(`hostPolicies.${key} must name a trusted host policy`);
+    }
+}
+export function resolveDecisionHostPolicies(refs, registry = {}) {
+    if (refs === undefined)
+        return {};
+    assertDecisionHostPolicyRefs(refs);
+    const resolved = {};
+    for (const [key, ref] of Object.entries(refs)) {
+        const group = hasOwn(registry, key) ? registry[key] : undefined;
+        const policy = group && hasOwn(group, ref) ? group[ref] : undefined;
+        if (!policy)
+            throw new Error(`Unknown trusted decision host policy '${key}:${ref}'`);
+        resolved[key] = policy;
+    }
+    return resolved;
+}
+export function assertNoInlineDecisionHostPolicies(config) {
+    for (const key of HOST_POLICY_KEYS) {
+        if (key in config)
+            throw new Error(`Unsupported inline decision runtime option '${key}'. Use hostPolicies.${key} to select a trusted host policy`);
+    }
+}
+export function assertDecisionEvaluateDispatcherConfig(config) {
+    if (!isRecord(config))
+        throw new Error('decision-evaluate request must be a JSON object');
+    assertNoInlineDecisionHostPolicies(config);
+    const allowed = new Set([
+        'rulesetPath', 'bindingPath', 'definitionPaths', 'inputPath', 'runId', 'invocationId',
+        'receiptDirectory', 'receiptIntegrityKeyRef', 'receiptIntegrityKeyEncoding',
+        'credentials', 'adapterOptions', 'adapterModules', 'projectionPolicyPath', 'hostPolicies',
+    ]);
+    for (const key of Object.keys(config)) {
+        if (!allowed.has(key))
+            throw new Error(`Unsupported decision-evaluate request field '${key}'`);
+    }
+    if ('hostPolicies' in config)
+        assertDecisionHostPolicyRefs(config.hostPolicies);
+}
+//# sourceMappingURL=host-policy.js.map

package/dist/src/decision/index.js

@@ -27,14 +27,19 @@ export * from './admission.js';
 export * from './batch-receipts/index.js';
 export * from './context-plan.js';
 export * from './context-qualification.js';
+export * from './context-pruning.js';
 export * from './calibration/index.js';
 export * from './projection.js';
+export * from './preprocessed-evidence.js';
 export * from './lifecycle.js';
 export * from './file-lifecycle-store.js';
 export * from './receipts.js';
 export * from './portable-secrets.js';
 export * from './evaluate.js';
+export * from './host-policy.js';
 export * from './export.js';
+export * from './feature-export.js';
+export * from './sdlc-screening.js';
 export * from './adapters/jev.js';
 export * from './adapters/llm-subagent.js';
 export * from './review/index.js';
@@ -44,4 +49,10 @@ export * from './patterns/index.js';
 export * from './compile-cache/index.js';
 export * from './result-cache/index.js';
 export * from './ensemble/index.js';
+export * from './sensitivity/index.js';
+export * from './issue-triage/index.js';
+export * from './routing/index.js';
+export * from './interop.js';
+export { collectHeldoutStudy, scoreHeldoutStudy } from './heldout/collector.js';
+export { heldoutDigest, heldoutExecutionDigest, planHeldoutCollection, validateHeldoutBundle, heldoutRowsInScope } from './heldout/contract.js';
 //# sourceMappingURL=index.js.map

package/dist/src/decision/interop-profile.v1.json

@@ -0,0 +1,112 @@
+{
+  "apiVersion": "decision-interop.aiwg.io/v1",
+  "kind": "DecisionInteropProfile",
+  "metadata": {
+    "id": "aiwg-decision-dmn-opa-interop",
+    "version": "1.0.0",
+    "description": "AIWG deterministic decision interoperability profile for a safe DMN 1.6 subset and OPA decision-log exchange"
+  },
+  "spec": {
+    "dmn": {
+      "version": "1.6",
+      "namespace": "https://www.omg.org/spec/DMN/20240513/MODEL/",
+      "supportedElements": [
+        "definitions",
+        "decision",
+        "informationRequirement",
+        "requiredDecision",
+        "decisionTable",
+        "input",
+        "inputExpression",
+        "output",
+        "rule",
+        "inputEntry",
+        "outputEntry",
+        "text"
+      ],
+      "hitPolicies": [
+        "UNIQUE",
+        "ANY",
+        "FIRST",
+        "RULE ORDER",
+        "COLLECT"
+      ],
+      "collectAggregations": [
+        "LIST",
+        "SUM",
+        "MIN",
+        "MAX",
+        "COUNT"
+      ],
+      "comparisons": [
+        "dash",
+        "literal",
+        "eq",
+        "ne",
+        "lt",
+        "lte",
+        "gt",
+        "gte"
+      ],
+      "extensions": [
+        "aiwg:order",
+        "aiwg:defer-on-conflict"
+      ],
+      "exclusions": [
+        "arbitrary FEEL expressions",
+        "literalExpression execution",
+        "scripts",
+        "businessKnowledgeModel",
+        "imports",
+        "remote references",
+        "XInclude",
+        "DTD",
+        "external entities",
+        "missing dependency pins"
+      ],
+      "dependencyProfile": {
+        "mode": "local-acyclic-external-evidence",
+        "pinAuthority": "caller-supplied ArtifactPin values only; XML never establishes trusted AIWG decision authority",
+        "unsupported": [
+          "cycles",
+          "executable dependency decisions",
+          "remote hrefs",
+          "missing external decision pins"
+        ],
+        "nativeMapping": "required decisions become decision-source predicates and normalized ruleset evaluations"
+      }
+    },
+    "opa": {
+      "input": "default-deny structured JSON evidence projection with explicit reviewed JSON-pointer allowlist",
+      "result": "deterministic policy output only",
+      "bundlePins": [
+        "name",
+        "revision",
+        "digest"
+      ],
+      "decisionLogFields": [
+        "decision_id",
+        "trace_id",
+        "span_id",
+        "bundles.<name>.revision",
+        "metrics",
+        "revisionLineage"
+      ],
+      "defaultRedaction": [
+        "raw",
+        "body",
+        "secret",
+        "token",
+        "credential",
+        "private",
+        "locator",
+        "state",
+        "authorization",
+        "password",
+        "key"
+      ],
+      "enforcement": "separate PEP/action contract; OPA/DMN decisions do not authorize AIWG actions"
+    },
+    "activation": "dry-run imports only; review/publish path required for activation"
+  }
+}