sneakoscope 4.8.7 → 5.3.0

package/dist/core/ppt.js

@@ -9,6 +9,7 @@ import { buildPptStyleTokens, selectPptDesignReference } from './ppt/style-token
 export { PPT_DESIGN_REFERENCE_PROFILES, buildPptStyleTokens, selectPptDesignReference } from './ppt/style-tokens.js';
 import { buildPptHtml } from './ppt/html.js';
 export { buildPptHtml } from './ppt/html.js';
+import { imageDimensions, sha256File } from './wiki-image/image-hash.js';
 export const PPT_REQUIRED_GATE_FIELDS = Object.freeze([
     'clarification_contract_sealed',
     'audience_strategy_sealed',
@@ -385,12 +386,66 @@ async function existingGeneratedImageAssets(dir, existing = {}) {
         const target = path.join(dir, asset.output_path);
         try {
             const stat = await fsp.stat(target);
-            checked.push({ ...asset, byte_size: stat.size });
+            const sha = await sha256File(target);
+            const dims = await imageDimensions(target).catch(() => null);
+            const evidenceBlockers = pptImageAssetEvidenceBlockers(asset, { sha });
+            checked.push({
+                ...asset,
+                byte_size: stat.size,
+                output_sha256: asset.output_sha256 || sha,
+                evidence_class: asset.evidence_class || null,
+                output_source: asset.output_source || null,
+                dimensions: dims ? { width: dims.width, height: dims.height, format: dims.format } : asset.dimensions || null,
+                evidence_blockers: evidenceBlockers,
+                evidence_verified: evidenceBlockers.length === 0
+            });
         }
         catch { }
     }
     return checked;
 }
+function pptImageAssetEvidenceBlockers(asset = {}, evidence = {}) {
+    const blockers = [];
+    const evidenceClass = String(asset.evidence_class || '');
+    const outputSource = String(asset.output_source || '');
+    const outputSha = String(asset.output_sha256 || '');
+    if (evidenceClass !== 'codex_app_imagegen')
+        blockers.push(evidenceClass ? `ppt_image_asset_evidence_class_not_codex_app:${evidenceClass}` : 'ppt_image_asset_evidence_class_missing');
+    if (!['manual_attach', 'auto_discovered_generated_images'].includes(outputSource))
+        blockers.push(`ppt_image_asset_output_source_invalid:${outputSource || 'missing'}`);
+    if (!outputSha)
+        blockers.push('ppt_image_asset_output_sha256_missing');
+    else if (evidence.sha && outputSha !== evidence.sha)
+        blockers.push('ppt_image_asset_output_sha256_mismatch');
+    return [...new Set(blockers)];
+}
+function buildPptImagegenEvidence(imageAssetLedger = {}) {
+    const assets = Array.isArray(imageAssetLedger.assets) ? imageAssetLedger.assets : [];
+    const required = imageAssetLedger.required === true;
+    const requiredAssets = assets.filter((asset) => asset.status === 'generated' || required);
+    const blockers = [
+        ...(imageAssetLedger.blockers || []),
+        ...assets.flatMap((asset) => asset.evidence_blockers || [])
+    ].map(String);
+    return {
+        schema: 'sks.ppt-imagegen-evidence.v1',
+        required,
+        required_count: imageAssetLedger.required_count || 0,
+        generated_count: imageAssetLedger.generated_count || 0,
+        generated_image_evidence: !required || (imageAssetLedger.generated_count || 0) >= (imageAssetLedger.required_count || 0),
+        assets: requiredAssets.map((asset) => ({
+            id: asset.id || null,
+            output_path: asset.output_path || null,
+            output_source: asset.output_source || null,
+            output_sha256: asset.output_sha256 || null,
+            evidence_class: asset.evidence_class || null,
+            evidence_verified: asset.evidence_verified === true,
+            blockers: asset.evidence_blockers || []
+        })),
+        blockers: [...new Set(blockers)],
+        passed: !required || ((imageAssetLedger.passed === true) && blockers.length === 0)
+    };
+}
 export async function buildPptImageAssetLedger(dir, contract = {}, storyboard = buildPptStoryboard(contract), styleTokens = buildPptStyleTokens(contract), existing = null) {
     const required = imageAssetRequired(contract);
     const plannedAssets = planPptImageAssets(contract, storyboard, styleTokens);
@@ -400,12 +455,15 @@ export async function buildPptImageAssetLedger(dir, contract = {}, storyboard =
     const imagegenDisabled = /^(0|false|no)$/i.test(String(process.env.SKS_PPT_IMAGEGEN ?? 'auto'));
     const blockers = [];
     const generated = [...reused];
+    const evidenceBlockers = generated.flatMap((asset) => asset.evidence_blockers || []);
     if (pending.length > 0 && required && imagegenDisabled) {
         blockers.push('imagegen_disabled_by_SKS_PPT_IMAGEGEN');
     }
     else if (pending.length > 0 && required) {
         blockers.push('missing_codex_app_imagegen_gpt_image_2_asset_evidence');
     }
+    if (required)
+        blockers.push(...evidenceBlockers);
     const assets = [
         ...generated,
         ...pending
@@ -443,6 +501,13 @@ export async function buildPptImageAssetLedger(dir, contract = {}, storyboard =
         failed_count: 0,
         blockers,
         assets,
+        imagegen_evidence: buildPptImagegenEvidence({
+            required,
+            required_count: requiredCount,
+            generated_count: generatedCount,
+            blockers,
+            assets
+        }),
         passed,
         notes: [
             required
@@ -943,6 +1008,7 @@ export function defaultPptGate(contract = {}) {
         style_tokens_created: false,
         image_asset_ledger_created: false,
         image_asset_policy_satisfied: false,
+        imagegen_evidence: { schema: 'sks.ppt-imagegen-evidence.v1', required: false, passed: true, blockers: [] },
         review_policy_created: false,
         review_ledger_created: false,
         bounded_iteration_complete: false,
@@ -1040,9 +1106,10 @@ export async function writePptBuildArtifacts(dir, contract = null) {
         parallel_report: async () => writeJsonAtomic(path.join(dir, PPT_PARALLEL_REPORT_ARTIFACT), parallelReport)
     });
     const baseGate = defaultPptGate(sealed);
+    const imagegenEvidence = buildPptImagegenEvidence(imageAssetLedger);
     const gate = {
         ...baseGate,
-        passed: report.passed && imageAssetLedger.passed && reviewLedger.passed && iterationReport.passed && cleanupReport.source_html_preserved && cleanupReport.temp_cleanup_completed && parallelReport.passed,
+        passed: report.passed && imageAssetLedger.passed && imagegenEvidence.passed && reviewLedger.passed && iterationReport.passed && cleanupReport.source_html_preserved && cleanupReport.temp_cleanup_completed && parallelReport.passed,
         audience_strategy_sealed: baseGate.audience_strategy_sealed,
         source_ledger_created: true,
         fact_ledger_created: true,
@@ -1051,6 +1118,7 @@ export async function writePptBuildArtifacts(dir, contract = null) {
         style_tokens_created: true,
         image_asset_ledger_created: true,
         image_asset_policy_satisfied: imageAssetLedger.passed,
+        imagegen_evidence: imagegenEvidence,
         review_policy_created: true,
         review_ledger_created: true,
         bounded_iteration_complete: iterationReport.passed,

package/dist/core/proof/auto-finalize.js

@@ -4,6 +4,7 @@ import { finalizeRouteWithProof } from './route-finalizer.js';
 import { routeRequiresAgentIntake } from '../agents/agent-plan.js';
 import { readAgentGateStatus } from '../agents/agent-gate.js';
 import { DEFAULT_AGENT_COUNT } from '../agents/agent-schema.js';
+import { evaluateGate } from '../stop-gate/gate-evaluator.js';
 const AGENT_ARTIFACTS = [
     'agents/agent-proof-evidence.json',
     'agents/agent-sessions.json',
@@ -18,10 +19,13 @@ export async function maybeFinalizeRoute(root, { missionId, route, gateFile = nu
         return { ok: false, skipped: true, reason: 'mission_id_or_route_missing' };
     }
     const missionDir = path.join(root, '.sneakoscope', 'missions', missionId);
-    const gateObject = gate || (gateFile && await exists(path.join(missionDir, gateFile))
+    const diskGateObject = gateFile && await exists(path.join(missionDir, gateFile))
         ? await readJson(path.join(missionDir, gateFile), null)
-        : null);
-    const passed = gateObject?.passed === true || gateObject?.ok === true || gateObject?.status === 'pass';
+        : null;
+    const gateObject = diskGateObject || gate || null;
+    const gateVerdict = gateFile ? await evaluateGate(root, missionId, gateFile) : null;
+    const callerGateMismatch = Boolean(gate && diskGateObject && stableJson(gate) !== stableJson(diskGateObject));
+    const passed = gateVerdict ? gateVerdict.pass && !callerGateMismatch : gateObject?.passed === true || gateObject?.ok === true || gateObject?.status === 'pass';
     const mission = await readJson(path.join(missionDir, 'mission.json'), {});
     const prompt = mission.prompt || '';
     const agentRequired = agents !== false && routeRequiresAgentIntake(route, { task: prompt, noAgents: agents === false });
@@ -30,8 +34,18 @@ export async function maybeFinalizeRoute(root, { missionId, route, gateFile = nu
     const agentGate = agentRequired ? await readAgentGateStatus(root, missionId) : null;
     const agentArtifacts = agentGate ? await existingAgentArtifacts(root, missionId) : [];
     const agentBlockers = agentRequired && agentGate?.ok !== true ? ['agent_gate_not_passed'] : [];
-    const effectiveAgentBlockers = mock ? [] : agentBlockers;
-    const finalStatus = statusHint || (blockers.length || effectiveAgentBlockers.length ? 'blocked' : (passed ? (mock ? 'verified_partial' : 'verified') : (mock ? 'verified_partial' : 'blocked')));
+    const gateBlockers = gateVerdict && !gateVerdict.pass
+        ? [`route_gate_${gateVerdict.verdict}`, ...gateVerdict.reasons.map((item) => `route_gate_${item}`)]
+        : [];
+    if (callerGateMismatch)
+        gateBlockers.push('route_gate_caller_disk_mismatch');
+    const computedStatus = computeAutoFinalizeStatus({
+        mock,
+        passed,
+        blockers: [...blockers, ...agentBlockers, ...gateBlockers]
+    });
+    const statusResolution = applyStatusHint(computedStatus, statusHint);
+    const finalStatus = statusResolution.status;
     const proof = await finalizeRouteWithProof(root, {
         missionId,
         route,
@@ -48,14 +62,18 @@ export async function maybeFinalizeRoute(root, { missionId, route, gateFile = nu
             ...(agentGate?.proof?.fake_backend_disclaimer ? [agentGate.proof.fake_backend_disclaimer] : []),
             ...(mock && agentBlockers.length ? [`Mock agent intake does not satisfy full production gate: ${agentBlockers.join(', ')}`] : []),
             ...(mock ? ['Route was finalized from an explicit mock/fixture command path.'] : []),
+            ...(gateVerdict?.verdict === 'mock_only' ? ['Route gate is mock fixture evidence and cannot satisfy a real completion gate.'] : []),
+            ...(statusResolution.rejected ? [`statusHint rejected: requested ${statusResolution.rejected.requested}, computed ${statusResolution.rejected.computed}.`] : []),
             ...(!passed && !mock ? ['Route gate did not pass' + (reason ? ': ' + reason : '') + '.'] : [])
         ],
         blockers: [
             ...blockers,
-            ...effectiveAgentBlockers,
-            ...(!passed && !mock ? ['route_gate_not_passed'] : [])
+            ...agentBlockers,
+            ...gateBlockers,
+            ...(!passed && !mock && !gateBlockers.length ? ['route_gate_not_passed'] : [])
         ],
         statusHint: finalStatus,
+        statusHintRejected: statusResolution.rejected,
         mock,
         fixClaim,
         requireRelation,
@@ -65,7 +83,7 @@ export async function maybeFinalizeRoute(root, { missionId, route, gateFile = nu
         failureAnalysis,
         lightweightEvidence
     });
-    return { ...proof, auto_finalized: true, gate_passed: passed, status_hint: finalStatus };
+    return { ...proof, auto_finalized: true, gate_passed: passed, gate_verdict: gateVerdict, status_hint: finalStatus, status_hint_rejected: statusResolution.rejected };
 }
 async function existingAgentArtifacts(root, missionId) {
     const dir = path.join(root, '.sneakoscope', 'missions', missionId);
@@ -94,8 +112,9 @@ async function ensureMockAgentEvidence(root, missionId, route, prompt) {
     if (!(await exists(path.join(dir, 'agent-proof-evidence.json')))) {
         await writeJsonAtomic(path.join(dir, 'agent-proof-evidence.json'), {
             schema: 'sks.agent-proof-evidence.v1',
-            ok: true,
-            status: 'passed',
+            ok: false,
+            status: 'mock_fixture',
+            execution_class: 'mock_fixture',
             mission_id: missionId,
             route,
             backend: 'fake',
@@ -109,8 +128,48 @@ async function ensureMockAgentEvidence(root, missionId, route, prompt) {
             consensus_ok: true,
             janitor_report: 'agents/agent-janitor-report.json',
             janitor_ok: true,
-            blockers: []
+            blockers: ['mock_fixture_cannot_satisfy_real_agent_gate']
         });
     }
 }
+const STATUS_RANK = {
+    blocked: 0,
+    failed: 0,
+    not_verified: 0,
+    mock_only: 1,
+    verified_partial: 2,
+    verified: 3
+};
+function computeAutoFinalizeStatus({ mock, passed, blockers }) {
+    if (mock)
+        return 'mock_only';
+    if (blockers.length > 0)
+        return 'blocked';
+    return passed ? 'verified' : 'blocked';
+}
+function applyStatusHint(computed, requested) {
+    if (!requested)
+        return { status: computed, rejected: null };
+    const requestedRank = STATUS_RANK[requested];
+    const computedRank = STATUS_RANK[computed];
+    if (requestedRank === undefined || computedRank === undefined) {
+        return { status: computed, rejected: { requested, computed, reason: 'unknown_status_hint' } };
+    }
+    if (computed === 'mock_only' && requested !== 'mock_only') {
+        return { status: computed, rejected: { requested, computed, reason: 'mock_fixture_status_cap' } };
+    }
+    if (requestedRank > computedRank) {
+        return { status: computed, rejected: { requested, computed, reason: 'status_hint_upgrade_rejected' } };
+    }
+    return { status: requested, rejected: null };
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
 //# sourceMappingURL=auto-finalize.js.map

package/dist/core/proof/proof-schema.js

@@ -3,6 +3,7 @@ export const COMPLETION_PROOF_SCHEMA = 'sks.completion-proof.v1';
 export const COMPLETION_PROOF_STATUSES = Object.freeze([
     'verified',
     'verified_partial',
+    'mock_only',
     'blocked',
     'not_verified',
     'failed'
@@ -12,6 +13,7 @@ export function emptyCompletionProof(overrides = {}) {
         schema: COMPLETION_PROOF_SCHEMA,
         version: PACKAGE_VERSION,
         generated_at: nowIso(),
+        execution_class: null,
         mission_id: null,
         route: null,
         status: 'not_verified',

package/dist/core/proof/route-adapter.js

@@ -5,7 +5,7 @@ import { normalizeProofRoute, routeRequiresImageVoxelAnchors } from './route-pro
 import { linkProofClaimsToEvidence, proofEvidenceSummary } from '../evidence/evidence-proof-linker.js';
 import { writeTrustArtifactsForProof } from '../trust-kernel/trust-report.js';
 import { enforceRetention } from '../retention.js';
-export async function writeRouteCompletionProof(root, { missionId = null, route = null, status = 'verified_partial', gate = null, summary = {}, artifacts = [], evidence = {}, claims = [], unverified = [], blockers = [], failureAnalysis = null, nextHumanActions = [], lightweightEvidence = false } = {}) {
+export async function writeRouteCompletionProof(root, { missionId = null, route = null, status = 'verified_partial', gate = null, summary = {}, artifacts = [], evidence = {}, claims = [], unverified = [], blockers = [], failureAnalysis = null, nextHumanActions = [], lightweightEvidence = false, executionClass = null, statusHintRejected = null } = {}) {
     const collected = lightweightEvidence ? { files: [] } : await collectProofEvidence(root);
     const normalizedRoute = normalizeProofRoute(route);
     const mergedEvidence = {
@@ -21,6 +21,7 @@ export async function writeRouteCompletionProof(root, { missionId = null, route
         unverified
     });
     const written = await writeCompletionProof(root, {
+        execution_class: executionClass,
         mission_id: missionId,
         route: normalizedRoute,
         status: normalizedStatus,
@@ -36,6 +37,7 @@ export async function writeRouteCompletionProof(root, { missionId = null, route
         claims,
         unverified,
         blockers,
+        ...(statusHintRejected ? { status_hint_rejected: statusHintRejected } : {}),
         failure_analysis: normalizeFailureAnalysis(failureAnalysis || evidence.failure_analysis || evidence.root_cause_analysis),
         next_human_actions: nextHumanActions
     }, {
@@ -88,6 +90,8 @@ function normalizeFailureAnalysis(value) {
     };
 }
 function normalizeRouteProofStatus(status, { route, evidence, blockers, unverified }) {
+    if (status === 'mock_only')
+        return 'mock_only';
     if (blockers?.length)
         return status === 'failed' ? 'failed' : 'blocked';
     if (status === 'verified' && unverified?.length)

package/dist/core/proof/route-finalizer.js

@@ -7,7 +7,7 @@ import { wrongnessProofEvidence } from '../triwiki-wrongness/wrongness-proof-lin
 import { computerUseStatusReport } from '../computer-use-status.js';
 import { readComputerUseLiveEvidence } from '../computer-use-live-evidence.js';
 import { leanChangeEvidenceFromReport, scanCodeStructure } from '../code-structure.js';
-export async function finalizeRouteWithProof(root, { missionId, route, gateFile = null, gate = null, artifacts = [], visualEvidence = null, dbEvidence = null, madSksEvidence = null, testEvidence = null, commandEvidence = null, claims = [], unverified = [], blockers = [], statusHint = 'verified_partial', strict = false, mock = false, fixClaim = false, requireRelation = false, visualClaim = undefined, agents = undefined, allowActiveWrongnessPartial = false, failureAnalysis = null, lightweightEvidence = false } = {}) {
+export async function finalizeRouteWithProof(root, { missionId, route, gateFile = null, gate = null, artifacts = [], visualEvidence = null, dbEvidence = null, madSksEvidence = null, testEvidence = null, commandEvidence = null, claims = [], unverified = [], blockers = [], statusHint = 'verified_partial', strict = false, mock = false, fixClaim = false, requireRelation = false, visualClaim = undefined, agents = undefined, allowActiveWrongnessPartial = false, failureAnalysis = null, lightweightEvidence = false, statusHintRejected = null } = {}) {
     const policy = routeFinalizerPolicy(route, { strict, fixClaim, requireRelation, visualClaim });
     const localBlockers = [...blockers];
     const providedVisualEvidence = visualEvidence;
@@ -68,10 +68,11 @@ export async function finalizeRouteWithProof(root, { missionId, route, gateFile
         || !computerUseLive?.evidence
         || computerUseLive.evidence.mode !== 'live_capture_success'
         || computerUseLive.evidence.image_voxel?.linked !== true));
-    const status = localBlockers.length
-        ? (strict ? 'blocked' : statusHint === 'verified' ? 'verified_partial' : statusHint)
-        : visualComputerUseDowngrade ? 'verified_partial'
-            : statusHint;
+    const status = mock ? 'mock_only'
+        : localBlockers.length
+            ? (strict ? 'blocked' : statusHint === 'verified' ? 'verified_partial' : statusHint)
+            : visualComputerUseDowngrade ? 'verified_partial'
+                : statusHint;
     const finalUnverified = [
         ...unverified,
         ...(imageEvidence?.mock ? ['Image voxel evidence is mock fixture evidence and does not claim a real visual run.'] : []),
@@ -138,6 +139,8 @@ export async function finalizeRouteWithProof(root, { missionId, route, gateFile
         blockers: localBlockers,
         failureAnalysis: resolvedFailureAnalysis,
         lightweightEvidence,
+        executionClass: mock ? 'mock_fixture' : 'real',
+        statusHintRejected,
         summary: {
             files_changed: collected.files?.length || 0,
             commands_run: evidence.commands?.length || 0,

package/dist/core/proof/selftest-proof-fixtures.js

@@ -26,20 +26,33 @@ export async function writeSelftestRouteProof(root, { missionId, route = '$Team'
     return writeRouteCompletionProof(root, {
         missionId,
         route,
-        status: 'verified_partial',
-        gate: { passed: true, source: gateSource || defaults.gateSource },
+        status: 'mock_only',
+        executionClass: 'mock_fixture',
+        gate: {
+            passed: false,
+            ok: false,
+            execution_class: 'mock_fixture',
+            source: gateSource || defaults.gateSource,
+            blockers: ['selftest_fixture_cannot_claim_real_route_completion']
+        },
         summary: { selftest: true, tests_passed: 1, manual_review_required: true },
         artifacts: artifacts || defaults.artifacts,
         evidence: {
-            route_gate: { passed: true },
-            commands: [{ cmd: 'sks selftest --mock', status: 'verified_partial' }]
+            route_gate: {
+                passed: false,
+                ok: false,
+                execution_class: 'mock_fixture',
+                blockers: ['selftest_fixture_cannot_claim_real_route_completion']
+            },
+            commands: [{ cmd: 'sks selftest --mock', status: 'mock_only' }]
         },
         claims: [{
                 id: `selftest-${kind.replaceAll('_', '-')}-proof`,
                 text: CLAIM_TEXT[kind] || CLAIM_TEXT.team_gate,
                 status: 'verified_partial'
             }],
-        unverified: unverified || defaults.unverified
+        unverified: unverified || defaults.unverified,
+        blockers: ['selftest_fixture_cannot_claim_real_route_completion']
     });
 }
 //# sourceMappingURL=selftest-proof-fixtures.js.map

package/dist/core/proof/validation.js

@@ -10,6 +10,8 @@ export function validateCompletionProof(proof = {}) {
         issues.push('schema');
     if (!COMPLETION_PROOF_STATUSES.includes(String(record.status)))
         issues.push('status');
+    if (!['real', 'mock_fixture'].includes(String(record.execution_class)))
+        issues.push('execution_class');
     if (!record.summary || typeof record.summary !== 'object')
         issues.push('summary');
     if (!record.evidence || typeof record.evidence !== 'object')

package/dist/core/provider/model-router.js

@@ -0,0 +1,53 @@
+const CHAINS = {
+    quick: [
+        { model: 'gpt-5.4-mini', reasoning: 'low', serviceTier: 'fast' },
+        { model: 'gpt-5.5', reasoning: 'low', serviceTier: 'fast' }
+    ],
+    standard: [
+        { model: 'gpt-5.5', reasoning: 'medium', serviceTier: 'fast' }
+    ],
+    agentic: [
+        { model: 'gpt-5.3-codex', reasoning: 'high', serviceTier: 'fast' },
+        { model: 'gpt-5.5', reasoning: 'high', serviceTier: 'fast' }
+    ],
+    ultrabrain: [
+        { model: 'gpt-5.5', reasoning: 'xhigh', serviceTier: 'standard' }
+    ],
+    verify: [
+        { model: 'gpt-5.4-mini', reasoning: 'medium', serviceTier: 'fast' }
+    ],
+    review: [
+        { model: 'gpt-5.5', reasoning: 'high', serviceTier: 'fast' }
+    ]
+};
+export async function routeModel(category, opts = {}) {
+    const chain = CHAINS[category] || CHAINS.standard;
+    const degraded = new Set((opts.lbHealth?.degraded_models || []).map((model) => String(model)));
+    for (const choice of chain) {
+        if (degraded.has(choice.model))
+            continue;
+        if (opts.lbHealth?.quota_low && choice.reasoning === 'xhigh')
+            return { ...choice, reasoning: 'high' };
+        return choice;
+    }
+    return chain[chain.length - 1] ?? CHAINS.standard[0];
+}
+export function categoryForWorkerRole(role) {
+    const text = String(role || '').toLowerCase();
+    if (/verif|test|qa/.test(text))
+        return 'verify';
+    if (/review|critic|judge/.test(text))
+        return 'review';
+    if (/research|explore|read|scout/.test(text))
+        return 'quick';
+    if (/plan|architect|strategy/.test(text))
+        return 'ultrabrain';
+    return 'agentic';
+}
+export function modelRouteReason(category, choice, opts = {}) {
+    if (opts.explicit)
+        return `${category}->${choice.model} (explicit env override)`;
+    const suffix = opts.quotaLow ? 'quota discipline' : opts.degraded?.length ? 'lb degraded fallback' : 'quota discipline';
+    return `${category}->${choice.model} (${suffix})`;
+}
+//# sourceMappingURL=model-router.js.map

package/dist/core/release/release-gate-node.js

@@ -16,6 +16,7 @@ export const RELEASE_GATE_RESOURCE_CLASSES = [
     'global-config',
     'publish',
     'fs-read',
+    'fs-write',
     'timing-sensitive'
 ];
 export function validateReleaseGateManifest(input) {
@@ -47,6 +48,8 @@ export function validateReleaseGateManifest(input) {
             errors.push(`gate_side_effect_invalid:${gate?.id || 'unknown'}`);
         if (!Number.isFinite(Number(gate?.timeout_ms)) || Number(gate.timeout_ms) <= 0)
             errors.push(`gate_timeout_missing:${gate?.id || 'unknown'}`);
+        if (gate?.output_contract !== undefined && gate.output_contract !== 'sks.gate-result.v1')
+            errors.push(`gate_output_contract_invalid:${gate?.id || 'unknown'}`);
         if (!gate?.cache || typeof gate.cache.enabled !== 'boolean' || !Array.isArray(gate.cache.inputs))
             errors.push(`gate_cache_missing:${gate?.id || 'unknown'}`);
         if (!gate?.isolation || gate.isolation.report_dir !== 'per-gate')

package/dist/core/release/release-gate-resource-governor.js

@@ -19,6 +19,7 @@ export function defaultReleaseGateBudget() {
         'global-config': 1,
         publish: 1,
         'fs-read': Math.min(96, cores * 10),
+        'fs-write': Math.min(12, Math.max(1, cores)),
         'timing-sensitive': 1
     };
     for (const key of Object.keys(base)) {

package/dist/core/routes/constants.js

@@ -9,7 +9,7 @@ export const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = 'from-chat-img-checklist.md';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = 'from-chat-img-temp-triwiki.json';
 export const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = 'from-chat-img-qa-loop.json';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|computer-use|goal|fast-mode|research|seo-geo-optimizer|db|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|insane-search|ultra-search|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust';
+export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|computer-use|goal|fast-mode|review|ui|research|seo-geo-optimizer|db|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|insane-search|ultra-search|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|memory|wrongness|code-structure|proof-field|skill-dream|rust';
 export const RECOMMENDED_MCP_SERVERS = [
     {
         id: 'context7',