sneakoscope 10.2.0 → 10.3.0

package/dist/core/decisions/policy.js

@@ -0,0 +1,393 @@
+import { CHOICE_MIN_CONFIDENCE, CHOICE_MIN_PROBABILITY, CONTEXT_DROP_NOUL_MAX, DISTRIBUTION_SUM_TOLERANCE, KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE, POLICY_REVISION, ROUTING_RISK_NOUL_MIN, UNKNOWN_USAGE, sealedRoutingModel } from './types.js';
+export function compileDecision(bundle, response) {
+    const usage = usageFromWire(response.usage);
+    const decoded = decodeWireResponse(bundle, response);
+    if (!decoded.ok) {
+        return { kind: 'keep_baseline', binding: bundle.binding, reason: decoded.reason, usage };
+    }
+    const effects = [];
+    let fallbackReason = null;
+    const planBinding = Object.entries(bundle.questionBindings).find(([, binding]) => binding.kind === 'plan');
+    if (planBinding) {
+        const compiled = compilePlan(bundle, decoded.response.answers[planBinding[0]]);
+        if (compiled.kind === 'effect')
+            effects.push(compiled.effect);
+        else if (!fallbackReason)
+            fallbackReason = compiled.reason;
+    }
+    const routing = compileRouting(bundle, decoded.response.answers);
+    for (const effect of routing.effects)
+        effects.push(effect);
+    if (routing.reason && !fallbackReason)
+        fallbackReason = routing.reason;
+    const contextEffect = compileContext(bundle, decoded.response.answers);
+    if (contextEffect.kind === 'effect')
+        effects.push(contextEffect.effect);
+    else if (contextEffect.reason && !fallbackReason)
+        fallbackReason = contextEffect.reason;
+    const recoveryBinding = Object.entries(bundle.questionBindings).find(([, binding]) => binding.kind === 'recovery');
+    if (recoveryBinding) {
+        const compiled = compileRecovery(bundle, decoded.response.answers[recoveryBinding[0]]);
+        if (compiled.kind === 'effect')
+            effects.push(compiled.effect);
+        else if (!fallbackReason)
+            fallbackReason = compiled.reason;
+    }
+    if (effects.length === 0) {
+        return {
+            kind: 'keep_baseline',
+            binding: bundle.binding,
+            reason: fallbackReason || 'keep_baseline_selected',
+            usage
+        };
+    }
+    return {
+        kind: 'apply',
+        binding: bundle.binding,
+        resolvedModel: decoded.response.model,
+        effects: effects,
+        usage
+    };
+}
+export function decodeWireResponse(bundle, response) {
+    if (!isRecord(response))
+        return { ok: false, reason: 'invalid_response' };
+    if (hasOwn(response, 'inputTokens') && !hasOwn(response, 'usage')) {
+        return { ok: false, reason: 'invalid_response' };
+    }
+    const model = text(response.model);
+    if (!model)
+        return { ok: false, reason: 'invalid_response' };
+    if (model !== bundle.binding.requestedModel)
+        return { ok: false, reason: 'unknown_model' };
+    const answersRaw = response.answers;
+    if (!isRecord(answersRaw))
+        return { ok: false, reason: 'invalid_response' };
+    const usage = decodeUsage(response.usage);
+    if (!usage)
+        return { ok: false, reason: 'invalid_response' };
+    const answers = {};
+    for (const [id, question] of Object.entries(bundle.request.questions)) {
+        const rawAnswer = answersRaw[id];
+        if (rawAnswer === undefined) {
+            if (isRequiredQuestion(bundle, id))
+                return { ok: false, reason: 'missing_answer' };
+            continue;
+        }
+        const decoded = decodeAnswer(question, rawAnswer);
+        if (!decoded.ok)
+            return { ok: false, reason: decoded.reason };
+        answers[id] = decoded.answer;
+    }
+    const decoded = {
+        model,
+        answers,
+        usage
+    };
+    const id = text(response.id);
+    if (id)
+        decoded.id = id;
+    const provider = text(response.provider);
+    if (provider)
+        decoded.provider = provider;
+    return { ok: true, response: decoded };
+}
+export function usageFromWire(usage) {
+    if (!usage)
+        return { ...UNKNOWN_USAGE };
+    return {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        reportedCost: usage.cost === undefined ? null : usage.cost,
+        evidence: 'provider_response'
+    };
+}
+export function decodeUsage(value) {
+    if (!isRecord(value))
+        return null;
+    if (hasOwn(value, 'inputTokens') && !hasOwn(value, 'input_tokens'))
+        return null;
+    if (hasOwn(value, 'outputTokens') && !hasOwn(value, 'output_tokens'))
+        return null;
+    const inputTokens = value.input_tokens;
+    const outputTokens = value.output_tokens;
+    if (!isFiniteNumber(inputTokens) || inputTokens < 0)
+        return null;
+    if (!isFiniteNumber(outputTokens) || outputTokens < 0)
+        return null;
+    const usage = {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens
+    };
+    if (hasOwn(value, 'cost')) {
+        if (!isFiniteNumber(value.cost) || value.cost < 0)
+            return null;
+        usage.cost = value.cost;
+    }
+    return usage;
+}
+function compilePlan(bundle, answer) {
+    if (!answer)
+        return { kind: 'baseline', reason: 'missing_answer' };
+    if (answer.type !== 'choice')
+        return { kind: 'baseline', reason: 'invalid_response' };
+    if (answer.choice === KEEP_BASELINE_CHOICE)
+        return { kind: 'baseline', reason: 'keep_baseline_selected' };
+    const candidate = bundle.planCandidates.find((row) => row.id === answer.choice);
+    if (!candidate)
+        return { kind: 'baseline', reason: 'invalid_response' };
+    const uncertainty = requiredChoiceUncertainty(answer, planChoiceIds(bundle));
+    if (!uncertainty.ok)
+        return { kind: 'baseline', reason: uncertainty.reason };
+    return { kind: 'effect', effect: { kind: 'select_plan', planId: candidate.id } };
+}
+function compileRouting(bundle, answers) {
+    const effects = [];
+    let reason = null;
+    for (const roleId of routingRoleIds(bundle)) {
+        const compiled = compileRoleRouting(bundle, answers, roleId);
+        if (compiled.kind === 'effect')
+            effects.push(compiled.effect);
+        else if (!reason)
+            reason = compiled.reason;
+    }
+    return { effects, reason };
+}
+function compileRoleRouting(bundle, answers, roleId) {
+    const choiceId = questionIdFor(bundle, 'routing', roleId);
+    const answer = choiceId ? answers[choiceId] : undefined;
+    if (!answer)
+        return { kind: 'baseline', reason: 'missing_answer' };
+    if (answer.type !== 'choice')
+        return { kind: 'baseline', reason: 'invalid_response' };
+    if (answer.choice === KEEP_BASELINE_CHOICE)
+        return { kind: 'baseline', reason: 'keep_baseline_selected' };
+    const selected = sealedRoutingModel(answer.choice);
+    if (!selected)
+        return { kind: 'baseline', reason: 'invalid_response' };
+    const choiceQuestion = choiceId ? bundle.request.questions[choiceId] : undefined;
+    const labels = choiceQuestion?.type === 'choice' ? Object.keys(choiceQuestion.criteria) : [];
+    const uncertainty = requiredChoiceUncertainty(answer, labels);
+    if (!uncertainty.ok)
+        return { kind: 'baseline', reason: uncertainty.reason };
+    const model = escalateRole(bundle, answers, roleId) ? 'gpt-6-astra' : selected.id;
+    return { kind: 'effect', effect: { kind: 'select_routing', roleId, model } };
+}
+function escalateRole(bundle, answers, roleId) {
+    const difficultyId = questionIdFor(bundle, 'routing_difficulty', roleId);
+    const difficulty = difficultyId ? answers[difficultyId] : undefined;
+    const difficultyQuestion = difficultyId ? bundle.request.questions[difficultyId] : undefined;
+    if (difficulty?.type === 'score' && difficultyQuestion?.type === 'score') {
+        const top = difficultyQuestion.criteria.length - 1;
+        if (difficulty.score >= top)
+            return true;
+    }
+    const riskId = questionIdFor(bundle, 'routing_risk', roleId);
+    const risk = riskId ? answers[riskId] : undefined;
+    return risk?.type === 'noul' && risk.noul >= ROUTING_RISK_NOUL_MIN;
+}
+function routingRoleIds(bundle) {
+    const ids = [];
+    for (const binding of Object.values(bundle.questionBindings)) {
+        if (binding.kind === 'routing' && !ids.includes(binding.roleId))
+            ids.push(binding.roleId);
+    }
+    return ids;
+}
+function questionIdFor(bundle, kind, roleId) {
+    const found = Object.entries(bundle.questionBindings).find(([, binding]) => (binding.kind === kind && 'roleId' in binding && binding.roleId === roleId));
+    return found ? found[0] : null;
+}
+function compileContext(bundle, answers) {
+    const optional = bundle.contextCandidates.filter((row) => !row.pinned);
+    if (optional.length === 0)
+        return { kind: 'baseline', reason: null };
+    const keepIds = new Set(bundle.contextCandidates.filter((row) => row.pinned).map((row) => row.id));
+    let sawUsable = false;
+    for (const [questionId, binding] of Object.entries(bundle.questionBindings)) {
+        if (binding.kind !== 'context_keep')
+            continue;
+        const candidate = bundle.contextCandidates.find((row) => row.id === binding.candidateId);
+        if (!candidate || candidate.pinned)
+            continue;
+        const answer = answers[questionId];
+        if (!answer)
+            continue;
+        if (answer.type !== 'noul')
+            return { kind: 'baseline', reason: 'invalid_response' };
+        if (!isFiniteNumber(answer.noul) || answer.noul < 0 || answer.noul > 1) {
+            return { kind: 'baseline', reason: 'invalid_response' };
+        }
+        sawUsable = true;
+        if (canDropOptional(candidate, answer.noul))
+            continue;
+        keepIds.add(candidate.id);
+    }
+    for (const candidate of optional) {
+        if (!Object.values(bundle.questionBindings).some((binding) => (binding.kind === 'context_keep' && binding.candidateId === candidate.id))) {
+            keepIds.add(candidate.id);
+        }
+    }
+    if (!sawUsable)
+        return { kind: 'baseline', reason: null };
+    return { kind: 'effect', effect: { kind: 'select_optional_context', keepIds: [...keepIds] } };
+}
+function compileRecovery(bundle, answer) {
+    if (!answer)
+        return { kind: 'baseline', reason: 'missing_answer' };
+    if (answer.type !== 'choice')
+        return { kind: 'baseline', reason: 'invalid_response' };
+    if (answer.choice === KEEP_BASELINE_CHOICE)
+        return { kind: 'baseline', reason: 'keep_baseline_selected' };
+    if (answer.choice === NEEDS_EVIDENCE_CHOICE)
+        return { kind: 'baseline', reason: 'needs_evidence' };
+    const candidate = bundle.recoveryCandidates.find((row) => row.id === answer.choice && row.authorized);
+    if (!candidate)
+        return { kind: 'baseline', reason: 'invalid_response' };
+    const labels = [
+        ...bundle.recoveryCandidates.map((row) => row.id),
+        KEEP_BASELINE_CHOICE,
+        NEEDS_EVIDENCE_CHOICE
+    ];
+    const uncertainty = requiredChoiceUncertainty(answer, labels);
+    if (!uncertainty.ok)
+        return { kind: 'baseline', reason: uncertainty.reason };
+    return { kind: 'effect', effect: { kind: 'dispatch_recovery', actionId: candidate.id } };
+}
+function canDropOptional(candidate, noul) {
+    return !candidate.pinned
+        && candidate.fresh
+        && candidate.reproducible
+        && Boolean(candidate.excerpt)
+        && noul <= CONTEXT_DROP_NOUL_MAX;
+}
+function requiredChoiceUncertainty(answer, expectedKeys) {
+    if (answer.confidence === undefined || answer.probabilities === undefined) {
+        return { ok: false, reason: 'insufficient_uncertainty' };
+    }
+    if (!isFiniteNumber(answer.confidence) || answer.confidence < 0 || answer.confidence > 1) {
+        return { ok: false, reason: 'invalid_response' };
+    }
+    const distribution = validateDistribution(answer.probabilities, expectedKeys);
+    if (!distribution.ok)
+        return distribution;
+    const selected = answer.probabilities[answer.choice];
+    if (!isFiniteNumber(selected))
+        return { ok: false, reason: 'invalid_response' };
+    if (answer.confidence < CHOICE_MIN_CONFIDENCE || selected < CHOICE_MIN_PROBABILITY) {
+        return { ok: false, reason: 'uncertain' };
+    }
+    return { ok: true };
+}
+export function validateDistribution(probabilities, expectedKeys) {
+    const keys = Object.keys(probabilities);
+    if (keys.length !== expectedKeys.length)
+        return { ok: false, reason: 'invalid_response' };
+    const expected = new Set(expectedKeys);
+    let sum = 0;
+    for (const key of keys) {
+        if (!expected.has(key))
+            return { ok: false, reason: 'invalid_response' };
+        const value = probabilities[key];
+        if (!isFiniteNumber(value) || value < 0 || value > 1)
+            return { ok: false, reason: 'invalid_response' };
+        sum += value;
+    }
+    if (Math.abs(sum - 1) > DISTRIBUTION_SUM_TOLERANCE)
+        return { ok: false, reason: 'invalid_response' };
+    return { ok: true };
+}
+function decodeAnswer(question, raw) {
+    if (!isRecord(raw))
+        return { ok: false, reason: 'invalid_response' };
+    const type = text(raw.type);
+    if (type !== question.type) {
+        if (type === 'choice' || type === 'noul' || type === 'score') {
+            return { ok: false, reason: 'invalid_response' };
+        }
+        return { ok: false, reason: 'invalid_response' };
+    }
+    if (question.type === 'choice') {
+        const choice = text(raw.choice);
+        if (!choice)
+            return { ok: false, reason: 'invalid_response' };
+        const allowed = new Set([...Object.keys(question.criteria), KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE]);
+        if (!allowed.has(choice))
+            return { ok: false, reason: 'invalid_response' };
+        const answer = { type: 'choice', choice };
+        if (hasOwn(raw, 'confidence')) {
+            if (!isFiniteNumber(raw.confidence) || raw.confidence < 0 || raw.confidence > 1) {
+                return { ok: false, reason: 'invalid_response' };
+            }
+            answer.confidence = raw.confidence;
+        }
+        if (hasOwn(raw, 'probabilities')) {
+            if (!isRecord(raw.probabilities))
+                return { ok: false, reason: 'invalid_response' };
+            const probabilities = {};
+            for (const [key, value] of Object.entries(raw.probabilities)) {
+                if (!isFiniteNumber(value) || value < 0 || value > 1)
+                    return { ok: false, reason: 'invalid_response' };
+                probabilities[key] = value;
+            }
+            const expected = Object.keys(question.criteria);
+            const checked = validateDistribution(probabilities, expected);
+            if (!checked.ok)
+                return checked;
+            answer.probabilities = probabilities;
+        }
+        return { ok: true, answer };
+    }
+    if (question.type === 'noul') {
+        if (!isFiniteNumber(raw.noul) || raw.noul < 0 || raw.noul > 1) {
+            return { ok: false, reason: 'invalid_response' };
+        }
+        return { ok: true, answer: { type: 'noul', noul: raw.noul } };
+    }
+    if (!isFiniteNumber(raw.score) || raw.score < 0 || raw.score > question.criteria.length - 1) {
+        return { ok: false, reason: 'invalid_response' };
+    }
+    const answer = { type: 'score', score: raw.score };
+    if (hasOwn(raw, 'confidence')) {
+        if (!isFiniteNumber(raw.confidence) || raw.confidence < 0 || raw.confidence > 1) {
+            return { ok: false, reason: 'invalid_response' };
+        }
+        answer.confidence = raw.confidence;
+    }
+    if (hasOwn(raw, 'probabilities')) {
+        if (!isRecord(raw.probabilities))
+            return { ok: false, reason: 'invalid_response' };
+        const probabilities = {};
+        for (const [key, value] of Object.entries(raw.probabilities)) {
+            if (!isFiniteNumber(value) || value < 0 || value > 1)
+                return { ok: false, reason: 'invalid_response' };
+            probabilities[key] = value;
+        }
+        const expected = question.criteria.map((_, index) => String(index));
+        const checked = validateDistribution(probabilities, expected);
+        if (!checked.ok)
+            return checked;
+        answer.probabilities = probabilities;
+    }
+    return { ok: true, answer };
+}
+function planChoiceIds(bundle) {
+    return [...bundle.planCandidates.map((row) => row.id), KEEP_BASELINE_CHOICE];
+}
+function isRequiredQuestion(bundle, id) {
+    const binding = bundle.questionBindings[id];
+    return binding?.kind === 'plan' || binding?.kind === 'recovery' || binding?.kind === 'context_keep';
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export const COMPILER_POLICY_REVISION = POLICY_REVISION;

package/dist/core/decisions/questions.js

@@ -0,0 +1,215 @@
+import { CONTEXT_RELEVANCE_RUBRIC, DESIGN_DEFAULTS, KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE, QUESTION_REVISION, ROUTING_DIFFICULTY_RUBRIC, SEALED_ROUTING_MODELS } from './types.js';
+import { buildDecisionBinding, redactDecisionText } from './state.js';
+const SAME_BATCH_DEPENDENCY = /\b(selected above|answer above|previous answer|the (plan|action) selected|if the (plan|action) selected)\b/i;
+export const CONTEXT_RELEVANCE_LEVELS = CONTEXT_RELEVANCE_RUBRIC.length;
+export function assertIndependentQuestion(instructions) {
+    if (SAME_BATCH_DEPENDENCY.test(instructions)) {
+        throw new Error('question_depends_on_same_batch_answer');
+    }
+}
+export function validatePlanCoverage(requiredSliceIds, candidate, allowlistedDuplicates = []) {
+    const required = [...requiredSliceIds].sort();
+    const covered = [...candidate.sliceIds].sort();
+    const issues = [];
+    if (required.join('\0') !== covered.join('\0'))
+        issues.push('slice_coverage_mismatch');
+    const seen = new Map();
+    for (const group of candidate.groups) {
+        for (const id of group.sliceIds) {
+            seen.set(id, (seen.get(id) || 0) + 1);
+        }
+    }
+    const grouped = [...seen.keys()].sort();
+    if (grouped.join('\0') !== required.join('\0'))
+        issues.push('group_coverage_mismatch');
+    for (const [id, count] of seen) {
+        if (count > 1 && !allowlistedDuplicates.includes(id))
+            issues.push(`duplicate_slice:${id}`);
+    }
+    return issues;
+}
+export function buildDecisionBundle(input) {
+    const planCandidates = [...(input.planCandidates || [])];
+    const contextCandidates = [...(input.contextCandidates || [])];
+    const recoveryCandidates = [...(input.recoveryCandidates || [])];
+    const routingCandidates = [...(input.routingCandidates || [])];
+    const questions = {};
+    const questionBindings = {};
+    const recoverySlot = recoveryCandidates.length > 0 ? 1 : 0;
+    if (planCandidates.length > 1) {
+        const instructions = redactDecisionText(`Choose an already valid plan in state.plans for the supplied task and slices. Prefer preserving quality and low elapsed time; do not remove required work. Select ${KEEP_BASELINE_CHOICE} when the supplied evidence does not distinguish the plans. Required slice IDs: ${(input.requiredSliceIds || []).join(', ') || 'none'}.`);
+        assertIndependentQuestion(instructions);
+        questions.plan = {
+            type: 'choice',
+            instructions,
+            criteria: Object.fromEntries([
+                ...planCandidates.map((plan) => [plan.id, plan.summary]),
+                [KEEP_BASELINE_CHOICE, 'Evidence is insufficient to justify changing the baseline.']
+            ])
+        };
+        questionBindings.plan = { kind: 'plan' };
+    }
+    const routedRoles = appendRoutingChoices(routingCandidates, questions, questionBindings, recoverySlot);
+    for (const candidate of contextCandidates.filter((row) => !row.pinned && row.excerpt)) {
+        if (Object.keys(questions).length + 2 > DESIGN_DEFAULTS.maxQuestions - recoverySlot)
+            break;
+        const keepId = `keep_${candidate.id}`;
+        const keepInstructions = redactDecisionText(`Is the original excerpt at context.${candidate.id} (source ${candidate.sourcePath}) needed for any requirement of the stated task? Use the excerpt content; do not infer relevance from the ID.`);
+        assertIndependentQuestion(keepInstructions);
+        questions[keepId] = {
+            type: 'noul',
+            instructions: keepInstructions,
+            criteria: {
+                true: 'The excerpt contains task-relevant requirements or evidence.',
+                false: 'The excerpt contains no information needed for the requested work.'
+            }
+        };
+        questionBindings[keepId] = { kind: 'context_keep', candidateId: candidate.id };
+        const scoreId = `relevance_${candidate.id}`;
+        const scoreInstructions = redactDecisionText(`Rate the usefulness of context.${candidate.id}.excerpt from ${candidate.sourcePath} for the concrete objective, using the same task-specific rubric used for other optional evidence.`);
+        assertIndependentQuestion(scoreInstructions);
+        questions[scoreId] = {
+            type: 'score',
+            instructions: scoreInstructions,
+            criteria: [...CONTEXT_RELEVANCE_RUBRIC]
+        };
+        questionBindings[scoreId] = {
+            kind: 'context_relevance',
+            candidateId: candidate.id,
+            levelCount: CONTEXT_RELEVANCE_LEVELS
+        };
+    }
+    appendRoutingSpeculation(routedRoles, questions, questionBindings, recoverySlot);
+    if (recoveryCandidates.length > 0 && Object.keys(questions).length < DESIGN_DEFAULTS.maxQuestions) {
+        const instructions = redactDecisionText(`Choose one already authorized recovery handler for the observed diagnostic. ${input.recoveryDiagnostic || ''} Select ${KEEP_BASELINE_CHOICE} to keep the current handler path, or ${NEEDS_EVIDENCE_CHOICE} when more evidence is required. Do not invent a command or path.`);
+        assertIndependentQuestion(instructions);
+        questions.recovery = {
+            type: 'choice',
+            instructions,
+            criteria: Object.fromEntries([
+                ...recoveryCandidates.map((row) => [row.id, row.summary]),
+                [KEEP_BASELINE_CHOICE, 'Keep the current deterministic recovery path.'],
+                [NEEDS_EVIDENCE_CHOICE, 'More evidence is required before any handler runs.']
+            ])
+        };
+        questionBindings.recovery = { kind: 'recovery' };
+    }
+    const state = {
+        task: { goal: redactDecisionText(input.goal, 1_200) },
+        facts: {
+            all_required_slices_must_be_preserved: true,
+            ...(input.facts || {})
+        },
+        slices: (input.requiredSliceIds || []).map((id) => ({ id })),
+        plans: Object.fromEntries(planCandidates.map((plan) => [plan.id, {
+                worker_count: plan.workerCount,
+                groups: plan.groups.map((group) => ({
+                    id: group.id,
+                    slice_ids: group.sliceIds,
+                    role: group.role,
+                    effort: group.effort
+                })),
+                all_required_work_preserved: true,
+                required_verification_ids: plan.requiredVerificationIds
+            }])),
+        context: Object.fromEntries(contextCandidates.map((row) => [row.id, {
+                source: row.sourcePath,
+                excerpt: row.excerpt,
+                fresh: row.fresh,
+                pinned: row.pinned,
+                reproducible: row.reproducible
+            }])),
+        recovery: {
+            diagnostic: redactDecisionText(input.recoveryDiagnostic || '', 800),
+            handlers: recoveryCandidates
+        },
+        routing: {
+            models: Object.fromEntries(SEALED_ROUTING_MODELS.map((row) => [row.id, {
+                    effort: row.effort,
+                    summary: row.summary
+                }])),
+            roles: Object.fromEntries(routedRoles.map((role) => [role.id, {
+                    summary: redactDecisionText(role.summary, 240)
+                }]))
+        }
+    };
+    const request = {
+        model: DESIGN_DEFAULTS.model,
+        state,
+        questions,
+        provider: { zdr: true, data_collection: 'deny', allow_fallbacks: false }
+    };
+    return {
+        binding: buildDecisionBinding({
+            projectId: input.projectId,
+            workflowRunId: input.workflowRunId,
+            workflowRevision: input.workflowRevision,
+            sourceDigest: input.sourceDigest,
+            graphDigest: input.graphDigest,
+            candidates: { planCandidates, contextCandidates, recoveryCandidates, routingCandidates: routedRoles },
+            questions,
+            requestedModel: DESIGN_DEFAULTS.model
+        }),
+        request,
+        planCandidates,
+        contextCandidates,
+        recoveryCandidates,
+        routingCandidates: routedRoles,
+        baselinePlanId: input.baselinePlanId ?? planCandidates[0]?.id ?? null,
+        questionBindings
+    };
+}
+function questionRoom(questions, recoverySlot) {
+    return DESIGN_DEFAULTS.maxQuestions - recoverySlot - Object.keys(questions).length;
+}
+function appendRoutingChoices(roles, questions, bindings, recoverySlot) {
+    const included = [];
+    for (const role of roles) {
+        if (questionRoom(questions, recoverySlot) < 1)
+            break;
+        const id = `route_${role.id}`;
+        const instructions = redactDecisionText(`Choose the sealed model for routing.roles.${role.id} using state.task and that role summary. Prefer the fastest sealed model that can do the work. Use gpt-6-astra for judgment, ambiguity, or high-stakes work. Select ${KEEP_BASELINE_CHOICE} when the work is not distinguished. Do not invent a model.`);
+        assertIndependentQuestion(instructions);
+        questions[id] = {
+            type: 'choice',
+            instructions,
+            criteria: {
+                ...Object.fromEntries(SEALED_ROUTING_MODELS.map((row) => [row.id, row.summary])),
+                [KEEP_BASELINE_CHOICE]: 'The role work is not distinguished enough to leave the baseline model.'
+            }
+        };
+        bindings[id] = { kind: 'routing', roleId: role.id };
+        included.push(role);
+    }
+    return included;
+}
+function appendRoutingSpeculation(roles, questions, bindings, recoverySlot) {
+    for (const role of roles) {
+        if (questionRoom(questions, recoverySlot) < 1)
+            break;
+        const difficultyId = `difficulty_${role.id}`;
+        const difficultyInstructions = redactDecisionText(`Rate the difficulty of routing.roles.${role.id} for state.task. Use only that role summary and the task.`);
+        assertIndependentQuestion(difficultyInstructions);
+        questions[difficultyId] = {
+            type: 'score',
+            instructions: difficultyInstructions,
+            criteria: [...ROUTING_DIFFICULTY_RUBRIC]
+        };
+        bindings[difficultyId] = { kind: 'routing_difficulty', roleId: role.id };
+        if (questionRoom(questions, recoverySlot) < 1)
+            break;
+        const riskId = `risk_${role.id}`;
+        const riskInstructions = redactDecisionText(`Does routing.roles.${role.id} need gpt-6-astra because the work is high-stakes, ambiguous, or unsafe on a faster sealed model?`);
+        assertIndependentQuestion(riskInstructions);
+        questions[riskId] = {
+            type: 'noul',
+            instructions: riskInstructions,
+            criteria: {
+                true: 'The work needs the most capable sealed model.',
+                false: 'A faster sealed model can do this work.'
+            }
+        };
+        bindings[riskId] = { kind: 'routing_risk', roleId: role.id };
+    }
+}
+export { QUESTION_REVISION };

package/dist/core/decisions/receipt.js

@@ -0,0 +1,41 @@
+import { randomId } from '../fsx.js';
+import { redactDecisionValue } from './openrouter.js';
+import { RECEIPT_SCHEMA, UNKNOWN_USAGE } from './types.js';
+export function usageReceiptFromCompiled(compiled) {
+    return { ...compiled.usage };
+}
+export function unknownUsageReceipt() {
+    return { ...UNKNOWN_USAGE };
+}
+export function cacheHitUsage(historical) {
+    return {
+        inputTokens: historical.inputTokens,
+        outputTokens: historical.outputTokens,
+        reportedCost: historical.reportedCost,
+        evidence: historical.evidence
+    };
+}
+export function buildDecisionReceipt(input) {
+    const usage = input.cacheHit
+        ? {
+            inputTokens: input.compiled.usage.inputTokens,
+            outputTokens: input.compiled.usage.outputTokens,
+            reportedCost: null,
+            evidence: input.compiled.usage.evidence
+        }
+        : { ...input.compiled.usage };
+    const receipt = {
+        schema: RECEIPT_SCHEMA,
+        decisionId: `jev-${randomId(12)}`,
+        binding: input.binding,
+        resolvedModel: input.resolvedModel ?? (input.compiled.kind === 'apply' ? input.compiled.resolvedModel : null),
+        responseId: input.responseId ?? null,
+        result: input.result,
+        reason: input.reason,
+        usage,
+        elapsedMs: Math.max(0, Math.trunc(input.elapsedMs)),
+        cacheHit: input.cacheHit === true,
+        consumptionEvidence: input.consumptionEvidence ?? null
+    };
+    return redactDecisionValue(receipt, input.env);
+}