sneakoscope 4.8.7 → 5.3.0

package/dist/core/commands/gc-command.js

@@ -1,7 +1,27 @@
-import { dirSize, formatBytes, packageRoot, sksRoot } from '../fsx.js';
+import { dirSize, formatBytes, packageRoot, projectRoot, sksRoot } from '../fsx.js';
 import { enforceRetention, storageReport } from '../retention.js';
 import { flag } from './command-utils.js';
-export async function memoryCommand(_sub, args = []) {
+import { projectTriwikiToAgentsMd } from '../triwiki/agents-md-projector.js';
+import { compileMistakeRules } from '../verification/mistake-rule-compiler.js';
+export async function memoryCommand(sub, args = []) {
+    const action = String(sub || '').toLowerCase();
+    if (['build', 'project', 'agents', 'agents-md'].includes(action)) {
+        const root = await projectRoot();
+        const [result, rules] = await Promise.all([
+            projectTriwikiToAgentsMd(root, { maxLocalFiles: Number(readOption(args, '--max-local-files', 8)) }),
+            compileMistakeRules(root).catch((err) => ({ compiled: [], skipped: [`compile_failed:${err instanceof Error ? err.message : String(err)}`] }))
+        ]);
+        const output = { ...result, mistake_rules: rules };
+        if (flag(args, '--json'))
+            return console.log(JSON.stringify(output, null, 2));
+        console.log(`SKS memory build: ${result.ok ? 'ok' : result.reason}`);
+        for (const file of result.written)
+            console.log(`- ${file}`);
+        console.log(`- mistake rules compiled: ${rules.compiled.length}, skipped: ${rules.skipped.length}`);
+        if (!result.ok)
+            process.exitCode = 1;
+        return output;
+    }
     return gcCommand(args || []);
 }
 export async function gcCommand(args = []) {
@@ -16,6 +36,13 @@ export async function gcCommand(args = []) {
     for (const a of res.actions.slice(0, 20))
         console.log(`- ${a.action} ${a.path || a.mission || ''} ${a.bytes ? formatBytes(a.bytes) : ''}`);
 }
+function readOption(args = [], name, fallback = null) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return args[index + 1];
+    const prefixed = args.find((arg) => String(arg).startsWith(`${name}=`));
+    return prefixed ? String(prefixed).slice(name.length + 1) : fallback;
+}
 export async function statsCommand(args = []) {
     const root = await sksRoot();
     const report = await storageReport(root);

package/dist/core/commands/goal-command.js

@@ -6,6 +6,7 @@ import { GOAL_BRIDGE_ARTIFACT, GOAL_WORKFLOW_ARTIFACT, updateGoalWorkflow, write
 import { flag, promptOf, resolveMissionId } from './command-utils.js';
 import { compileGoalToLoopPlan } from '../loops/goal-to-loop-compat.js';
 import { runLoopPlan } from '../loops/loop-runtime.js';
+import { evaluateLocalGate } from './route-success-helpers.js';
 export async function goalCommand(sub, args = []) {
     const known = new Set(['create', 'pause', 'resume', 'clear', 'status', 'help', '--help', '-h']);
     const action = known.has(sub) ? sub : 'create';
@@ -39,10 +40,16 @@ async function goalCreate(args) {
     const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
     const plan = await compileGoalToLoopPlan({ root, missionId: id, goalText: prompt, legacyGoalOptions: { native_goal: workflow.native_goal } });
     const result = await runLoopPlan({ root, plan, parallelism: 'balanced' });
-    await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: result.ok ? 'GOAL_LOOP_COMPLETED' : 'GOAL_LOOP_BLOCKED', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'loop-graph-proof.json' }, { replace: true });
+    const gate = await evaluateLocalGate({ root, missionId: id, gateFile: 'loop-graph-proof.json' });
+    const ok = result.ok === true && gate.ok === true;
+    await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: ok ? 'GOAL_LOOP_COMPLETED' : 'GOAL_LOOP_BLOCKED', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'loop-graph-proof.json', stop_gate_blockers: gate.blockers }, { replace: true });
+    if (!ok)
+        process.exitCode = 1;
     if (flag(args, '--json'))
-        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok: result.ok, mission_id: id, workflow, loop_plan: plan, loop_result: result }, null, 2));
+        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok, mission_id: id, workflow, loop_plan: plan, loop_result: result, gate }, null, 2));
     console.log(`Goal compiled to Loop Graph: ${id}`);
+    if (!ok)
+        console.log(`Gate blocked: ${gate.blockers.join(', ') || 'loop_result_not_ok'}`);
     console.log('Use `sks loop status latest` to inspect.');
     console.log(`Artifact: ${path.relative(root, path.join(dir, GOAL_WORKFLOW_ARTIFACT))}`);
     console.log(`Bridge: ${path.relative(root, path.join(dir, GOAL_BRIDGE_ARTIFACT))}`);

package/dist/core/commands/gx-command.js

@@ -1,9 +1,10 @@
 import path from 'node:path';
-import { sksRoot, writeJsonAtomic } from '../fsx.js';
+import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { createMission } from '../mission.js';
 import { driftCartridge, renderCartridge, snapshotCartridge, validateCartridge } from '../gx-renderer.js';
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { flag, positionalArgs, readFlagValue } from './command-utils.js';
+import { context7EvidenceStatus } from './route-success-helpers.js';
 export async function gxCommand(sub, args = []) {
     const root = await sksRoot();
     const name = cartridgeName(args);
@@ -36,8 +37,38 @@ export async function gxCommand(sub, args = []) {
         if (name === 'fixture' && flag(args, '--mock'))
             return gxValidateFixture(root, args);
         const validation = await validateCartridge(dir);
-        console.log(JSON.stringify(validation, null, 2));
-        process.exitCode = validation.ok ? 0 : 2;
+        const vgraph = await readJson(path.join(dir, 'vgraph.json'), null);
+        const context7 = await context7EvidenceStatus(root);
+        const schemaBlockers = validateGxVGraph(vgraph);
+        const blockers = [
+            ...(Array.isArray(validation.issues) ? validation.issues : []),
+            ...schemaBlockers,
+            ...(context7.ok ? [] : [context7.blocker])
+        ].filter(Boolean);
+        const result = {
+            ...validation,
+            ok: validation.ok === true && blockers.length === 0,
+            status: validation.ok === true && blockers.length === 0 ? 'pass' : 'blocked',
+            context7_policy: context7.policy,
+            context7_evidence: context7.evidence,
+            vgraph_schema_valid: schemaBlockers.length === 0,
+            blockers
+        };
+        const gate = {
+            schema: 'sks.gx-gate.v1',
+            schema_version: 1,
+            passed: result.ok,
+            ok: result.ok,
+            status: result.ok ? 'pass' : 'blocked',
+            gx_validation: 'gx-validation.json',
+            context7_policy: context7.policy,
+            vgraph_schema_valid: schemaBlockers.length === 0,
+            blockers
+        };
+        await writeJsonAtomic(path.join(dir, 'gx-validation.json'), result);
+        await writeJsonAtomic(path.join(dir, 'gx-gate.json'), gate);
+        console.log(JSON.stringify(result, null, 2));
+        process.exitCode = result.ok ? 0 : 2;
         return;
     }
     if (sub === 'drift') {
@@ -56,12 +87,53 @@ export async function gxCommand(sub, args = []) {
 }
 async function gxValidateFixture(root, args) {
     const { id, dir } = await createMission(root, { mode: 'gx', prompt: 'GX validate fixture' });
-    const validation = { schema: 'sks.gx-validation.v1', ok: true, status: 'pass', fixture: true, cartridge: 'fixture' };
+    const validation = {
+        schema: 'sks.gx-validation.v1',
+        ok: false,
+        status: 'blocked',
+        execution_class: 'mock_fixture',
+        fixture: true,
+        cartridge: 'fixture',
+        blockers: ['gx_fixture_mode_cannot_claim_real']
+    };
     await writeJsonAtomic(path.join(dir, 'gx-validation.json'), validation);
-    const gate = { schema_version: 1, passed: true, ok: true, gx_validation: 'gx-validation.json', visual_claim: true };
+    const gate = {
+        schema: 'sks.gx-gate.v1',
+        schema_version: 1,
+        passed: false,
+        ok: false,
+        status: 'blocked',
+        execution_class: 'mock_fixture',
+        gx_validation: 'gx-validation.json',
+        visual_claim: false,
+        blockers: ['gx_fixture_mode_cannot_claim_real']
+    };
     await writeJsonAtomic(path.join(dir, 'gx-gate.json'), gate);
-    const proof = await maybeFinalizeRoute(root, { missionId: id, route: '$GX', gateFile: 'gx-gate.json', gate, mock: true, visual: true, artifacts: ['gx-validation.json', 'image-voxel-ledger.json', 'completion-proof.json'], claims: [{ id: 'gx-validate-fixture', status: 'verified_partial' }], command: { cmd: 'sks gx validate fixture --mock', status: 0 } });
-    console.log(JSON.stringify({ schema: 'sks.gx-validate-fixture.v1', ok: proof.ok, mission_id: id, validation, proof: proof.validation }, null, 2));
+    const proof = await maybeFinalizeRoute(root, { missionId: id, route: '$GX', gateFile: 'gx-gate.json', gate, mock: true, visual: true, statusHint: 'blocked', blockers: gate.blockers, artifacts: ['gx-validation.json', 'image-voxel-ledger.json', 'completion-proof.json'], claims: [{ id: 'gx-validate-fixture', status: 'blocked' }], command: { cmd: 'sks gx validate fixture --mock', status: 1 } });
+    const result = { schema: 'sks.gx-validate-fixture.v1', ok: false, mission_id: id, validation, gate, proof: proof.validation };
+    console.log(JSON.stringify(result, null, 2));
+    process.exitCode = 1;
+}
+function validateGxVGraph(vgraph) {
+    const blockers = [];
+    if (!vgraph || typeof vgraph !== 'object')
+        return ['vgraph_missing_or_invalid_json'];
+    if (!String(vgraph.id || vgraph.name || '').trim())
+        blockers.push('vgraph_id_missing');
+    if (!Array.isArray(vgraph.nodes) || vgraph.nodes.length === 0)
+        blockers.push('vgraph_nodes_missing');
+    if (!Array.isArray(vgraph.edges))
+        blockers.push('vgraph_edges_missing');
+    const ids = new Set((Array.isArray(vgraph.nodes) ? vgraph.nodes : []).map((node) => String(node?.id || '').trim()).filter(Boolean));
+    if (ids.size !== (Array.isArray(vgraph.nodes) ? vgraph.nodes.length : 0))
+        blockers.push('vgraph_node_ids_missing_or_duplicate');
+    for (const edge of Array.isArray(vgraph.edges) ? vgraph.edges : []) {
+        const from = String(edge?.from || edge?.source || '').trim();
+        const to = String(edge?.to || edge?.target || '').trim();
+        if (!from || !to || !ids.has(from) || !ids.has(to))
+            blockers.push('vgraph_edge_endpoint_invalid');
+    }
+    return [...new Set(blockers)];
 }
 function cartridgeName(args, fallback = 'architecture-atlas') {
     const raw = positionalArgs(args)[0] || fallback;

package/dist/core/commands/image-ux-review-command.js

@@ -12,6 +12,7 @@ import { addImageRelation, ingestImage } from '../wiki-image/image-voxel-ledger.
 import { sha256File, imageDimensions } from '../wiki-image/image-hash.js';
 import { writeRouteCollaborationArtifacts } from '../agents/route-collaboration-ledger.js';
 import { codexChromeExtensionStatus } from '../codex-app.js';
+import { requireCodexImagegen } from '../imagegen/require-imagegen.js';
 const ONE_BY_ONE_PNG_BASE64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMB/axX7V8AAAAASUVORK5CYII=';
 const IMAGE_UX_REVIEW_ARTIFACT_PATHS = {
     policy: IMAGE_UX_REVIEW_POLICY_ARTIFACT,
@@ -107,6 +108,32 @@ async function runImageUxReview(root, command, args = []) {
         console.error('UX Review blocked: screenshot_required');
         return result;
     }
+    if (!flag(args, '--mock') && !generatedImage) {
+        const imagegenRequired = await requireCodexImagegen(root, { autoRepair: true, applyRepair: true });
+        if (!imagegenRequired.ok) {
+            const result = {
+                schema: 'sks.image-ux-review-run.v1',
+                ok: false,
+                status: 'blocked',
+                blocker: 'codex_imagegen_unavailable',
+                imagegen_required: imagegenRequired,
+                gate: {
+                    schema: 'sks.image-ux-review-gate.v2',
+                    passed: false,
+                    status: 'blocked',
+                    blockers: ['codex_imagegen_unavailable'],
+                    generated_image_evidence: false
+                }
+            };
+            process.exitCode = 1;
+            if (flag(args, '--json'))
+                return printJson(result);
+            console.error('UX Review blocked: Codex App imagegen/gpt-image-2 is unavailable.');
+            for (const action of imagegenRequired.blocker?.next_actions || [])
+                console.error(`- ${action}`);
+            return result;
+        }
+    }
     const { id, dir, mission } = await createMission(root, { mode: 'image-ux-review', prompt: promptForRun(command, args) });
     const sourceRel = imagePath ? await stageSourceImage(root, dir, imagePath) : null;
     const contract = {
@@ -148,12 +175,23 @@ async function runImageUxReview(root, command, args = []) {
             }
         });
         if (result.generated_image_path) {
-            const fakeGenerated = result.provider === 'fake_imagegen_adapter';
             if (result.request_artifact)
                 await fsp.copyFile(result.request_artifact, path.join(dir, IMAGE_UX_REVIEW_GPT_IMAGE_2_REQUEST_ARTIFACT)).catch(() => { });
             if (result.response_artifact)
                 await fsp.copyFile(result.response_artifact, path.join(dir, IMAGE_UX_REVIEW_GPT_IMAGE_2_RESPONSE_ARTIFACT)).catch(() => { });
-            await attachGeneratedReviewImage(root, dir, contract, result.generated_image_path, { realGenerated: !fakeGenerated, mock: fakeGenerated, providerSurface: result.provider });
+            const response = await readImagegenResponse(dir);
+            const evidenceClass = String(response?.evidence_class || '');
+            const fakeGenerated = evidenceClass === 'mock_fixture' || result.provider === 'fake_imagegen_adapter';
+            const realGenerated = evidenceClass === 'codex_app_imagegen';
+            await attachGeneratedReviewImage(root, dir, contract, result.generated_image_path, {
+                realGenerated,
+                mock: fakeGenerated,
+                providerSurface: result.provider,
+                evidenceClass,
+                outputSource: response?.output_source || null,
+                outputSha256: response?.output_sha256 || response?.output_image_sha256 || null,
+                responseArtifact: result.response_artifact || null
+            });
             const extraction = await extractRealCallouts({
                 root,
                 generatedImagePath: result.generated_image_path,
@@ -169,6 +207,8 @@ async function runImageUxReview(root, command, args = []) {
         }
     }
     const artifacts = await writeImageUxReviewRouteArtifacts(dir, contract, { root, wrongnessChecked: true, honestModeComplete: true });
+    artifacts.gate = await enforceImageUxRuntimeGate(dir, artifacts.gate, { mock: flag(args, '--mock') });
+    await writeJsonAtomic(path.join(dir, IMAGE_UX_REVIEW_GATE_ARTIFACT), artifacts.gate);
     const proof = await finalizeImageUx(root, id, command, artifacts, { mock: flag(args, '--mock'), cmd: `sks ${command} run` });
     const result = { schema: 'sks.image-ux-review-run.v1', ok: proof.ok && artifacts.gate?.passed === true, status: artifacts.gate?.status || (artifacts.gate?.passed ? 'passed' : 'blocked'), mission_id: id, artifacts, proof: proof.validation };
     if (!result.ok)
@@ -298,6 +338,8 @@ async function rebuildExistingMission(root, command, args = [], opts = {}) {
         recapture: { computerUseAvailable: false },
         honestModeComplete: opts.proofRequested === true
     });
+    artifacts.gate = await enforceImageUxRuntimeGate(dir, artifacts.gate, { mock: flag(args, '--mock') });
+    await writeJsonAtomic(path.join(dir, IMAGE_UX_REVIEW_GATE_ARTIFACT), artifacts.gate);
     const proof = await finalizeImageUx(root, missionId, command, artifacts, { mock: flag(args, '--mock'), cmd: `sks ${command} ${opts.fixRequested ? 'fix' : opts.recaptureRequested ? 'recapture' : 'build'}` });
     const result = { schema: 'sks.image-ux-review-build.v2', ok: proof.ok && artifacts.gate?.passed === true, status: artifacts.gate?.status || (artifacts.gate?.passed ? 'passed' : 'blocked'), mission_id: missionId, artifacts, proof: proof.validation };
     if (!result.ok)
@@ -380,7 +422,7 @@ async function imageUxFixture(root, command, args) {
                 fix_action: 'No-op fixture recheck',
                 target_surface: 'fixture',
                 candidate_files: [],
-                status: 'fixed',
+                status: 'mock',
                 confidence: 0.5,
                 source: 'mock_fixture',
                 extracted_from_generated_image: true,
@@ -392,18 +434,21 @@ async function imageUxFixture(root, command, args) {
                 severity_visible: true,
                 callout_number_visible: true,
                 text_ocr_confidence: 0.5,
-                fix_verification_status: 'recheck_verified',
+                fix_verification_status: 'mock',
                 post_fix_recheck_issue_id: null
             }]
     });
     const artifacts = await writeImageUxReviewRouteArtifacts(dir, contract, { root, imageVoxelRelationsCreated: true, wrongnessChecked: true, honestModeComplete: true });
     const gate = {
         ...artifacts.gate,
-        passed: true,
+        passed: false,
+        ok: false,
+        status: 'blocked',
+        execution_class: 'mock_fixture',
         honest_mode_complete: true,
-        blockers: [],
+        blockers: ['image_ux_fixture_mode_cannot_claim_real'],
         fixture: true,
-        verified_level: 'verified_partial',
+        verified_level: 'unverified_fixture',
         mock_fixture_cannot_claim_real: true
     };
     artifacts.gate = gate;
@@ -417,23 +462,49 @@ async function imageUxFixture(root, command, args) {
         mode: 'IMAGE_UX_REVIEW'
     });
     const proof = await finalizeImageUx(root, id, command, artifacts, { mock: true, requireRelation: flag(args, '--require-relation'), cmd: `sks ${command} fixture --mock` });
-    const result = { schema: 'sks.image-ux-review-fixture.v2', ok: proof.ok && native.ok, mission_id: id, artifacts, native_agent_collaboration: native, proof: proof.validation };
+    const result = { schema: 'sks.image-ux-review-fixture.v2', ok: false, mission_id: id, artifacts, native_agent_collaboration: native, proof: proof.validation };
+    process.exitCode = 1;
     if (flag(args, '--json'))
         return printJson(result);
-    console.log(`Image UX fixture: ${proof.ok ? 'ok' : 'blocked'} ${id}`);
+    console.log(`Image UX fixture: blocked ${id}`);
     return result;
 }
 async function attachGeneratedReviewImage(root, dir, contract, imagePath, opts = {}) {
     const inventory = await readJson(path.join(dir, 'image-ux-screen-inventory.json'), null).catch(() => null);
     const sourceScreen = inventory?.source_screens?.[0] || { id: 'screen-1' };
     const staged = await stageGeneratedImage(root, dir, imagePath, opts.mock ? 'generated-review-fixture.png' : null);
+    const response = await readImagegenResponse(dir);
+    const evidenceClass = opts.evidenceClass || response?.evidence_class || (opts.mock ? 'mock_fixture' : opts.realGenerated ? 'codex_app_imagegen' : null);
+    const outputSource = opts.outputSource || response?.output_source || (opts.mock ? 'mock_fixture' : opts.realGenerated ? 'manual_attach' : null);
+    const outputSha256 = opts.outputSha256 || response?.output_sha256 || response?.output_image_sha256 || null;
     const metadata = await generatedImageMetadata(root, staged, {
         id: opts.mock ? 'generated-review-fixture-1' : undefined,
         source_screen_id: sourceScreen.id || 'screen-1',
         provider_surface: opts.providerSurface || 'Codex App $imagegen',
-        real_generated: opts.realGenerated === true,
+        evidence_class: evidenceClass,
+        output_source: outputSource,
+        output_sha256: outputSha256 || undefined,
+        real_generated: opts.realGenerated === true && evidenceClass === 'codex_app_imagegen',
         mock: opts.mock === true
     });
+    if (!response && opts.realGenerated === true) {
+        await writeJsonAtomic(path.join(dir, IMAGE_UX_REVIEW_GPT_IMAGE_2_RESPONSE_ARTIFACT), {
+            schema: 'sks.image-ux-gpt-image-2-response.v1',
+            created_at: nowIso(),
+            provider: 'codex_app_imagegen',
+            evidence_class: 'codex_app_imagegen',
+            model: 'gpt-image-2',
+            ok: true,
+            status: 'generated',
+            output_image_path: path.resolve(root, metadata.path),
+            output_image_sha256: metadata.sha256,
+            output_sha256: metadata.sha256,
+            output_id: metadata.output_id || null,
+            output_source: 'manual_attach',
+            dimensions: { width: metadata.width, height: metadata.height, format: metadata.format },
+            local_only: true
+        });
+    }
     const ledger = {
         schema: 'sks.image-ux-generated-review-ledger.v2',
         schema_version: 2,
@@ -444,6 +515,7 @@ async function attachGeneratedReviewImage(root, dir, contract, imagePath, opts =
                 ...metadata,
                 source_screen_id: 'screen-1',
                 status: 'generated',
+                imagegen_response_artifact: opts.responseArtifact || (response || opts.realGenerated === true ? IMAGE_UX_REVIEW_GPT_IMAGE_2_RESPONSE_ARTIFACT : null),
                 image_voxel_relation: 'generated_callout_review_of',
                 callout_extraction_status: opts.mock ? 'succeeded' : 'pending',
                 callouts: opts.mock ? [{
@@ -455,7 +527,7 @@ async function attachGeneratedReviewImage(root, dir, contract, imagePath, opts =
                         title: 'Mock fixture callout',
                         detail: 'Mock fixture callout for schema validation.',
                         fix_action: 'Apply targeted UI adjustment, then recapture and re-review.',
-                        status: opts.mock ? 'fixed' : 'open',
+                        status: opts.mock ? 'mock' : 'open',
                         source: opts.mock ? 'mock_fixture' : 'real_gpt_image_2_callout',
                         confidence: opts.mock ? 0.5 : 0.82,
                         extraction_provider: 'mock_fixture',
@@ -466,19 +538,122 @@ async function attachGeneratedReviewImage(root, dir, contract, imagePath, opts =
                         severity_visible: true,
                         callout_number_visible: true,
                         text_ocr_confidence: 0.5,
-                        fix_verification_status: 'recheck_verified',
+                        fix_verification_status: opts.mock ? 'mock' : 'not_rechecked',
                         post_fix_recheck_issue_id: null
                     }] : []
             }],
         generated_count: 1,
         required_count: 1,
         blockers: [],
-        passed: opts.realGenerated === true && opts.mock !== true,
+        passed: metadata.real_generated === true && opts.mock !== true,
         contract_hash: contract.sealed_hash || null
     };
     await writeJsonAtomic(path.join(dir, IMAGE_UX_REVIEW_GENERATED_REVIEW_LEDGER_ARTIFACT), ledger);
     return ledger;
 }
+async function readImagegenResponse(dir) {
+    return readJson(path.join(dir, IMAGE_UX_REVIEW_GPT_IMAGE_2_RESPONSE_ARTIFACT), null).catch(() => null);
+}
+async function enforceImageUxRuntimeGate(dir, gate = {}, opts = {}) {
+    const inventory = await readJson(path.join(dir, IMAGE_UX_REVIEW_SCREEN_INVENTORY_ARTIFACT), null);
+    const issueLedger = await readJson(path.join(dir, IMAGE_UX_REVIEW_ISSUE_LEDGER_ARTIFACT), null);
+    const response = await readJson(path.join(dir, IMAGE_UX_REVIEW_GPT_IMAGE_2_RESPONSE_ARTIFACT), null);
+    const blockers = new Set(Array.isArray(gate?.blockers) ? gate.blockers.map(String) : []);
+    const sourceScreens = Array.isArray(inventory?.source_screens) ? inventory.source_screens : [];
+    if (!opts.mock) {
+        if (sourceScreens.length === 0)
+            blockers.add('no_source_screenshots_for_imagegen_review');
+        for (const screen of sourceScreens) {
+            const width = Number(screen?.width || screen?.original_resolution?.width || 0);
+            const height = Number(screen?.height || screen?.original_resolution?.height || 0);
+            if (screen?.status !== 'captured')
+                blockers.add(`source_screenshot_unreadable:${screen?.id || 'unknown'}`);
+            if (!Number.isFinite(width) || !Number.isFinite(height) || width < 64 || height < 64)
+                blockers.add(`source_screenshot_below_min_resolution:${screen?.id || 'unknown'}`);
+        }
+    }
+    const issues = Array.isArray(issueLedger?.issues) ? issueLedger.issues : [];
+    if (issues.some((issue) => issue?.extraction_provider === 'mock_fixture' || issue?.source === 'mock_fixture'))
+        blockers.add('mock_issue_extraction_cannot_pass_gate');
+    if (opts.mock)
+        blockers.add('image_ux_mock_mode_cannot_claim_real');
+    const responseEvidence = await validateImagegenResponseEvidence(response, dir);
+    for (const blocker of responseEvidence.blockers)
+        blockers.add(blocker);
+    const nextBlockers = [...blockers];
+    const codexGenerated = responseEvidence.ok === true && gate?.gpt_image_2_callout_generated === true;
+    const passed = gate?.passed === true && codexGenerated && nextBlockers.length === 0;
+    return {
+        ...gate,
+        passed,
+        ok: passed,
+        status: passed ? 'passed' : 'blocked',
+        gpt_image_2_callout_generated: codexGenerated,
+        generated_image_evidence: responseEvidence.ok === true,
+        imagegen_response_evidence: responseEvidence,
+        source_screenshot_min_resolution_passed: sourceScreens.length > 0 && sourceScreens.every((screen) => Number(screen?.width || 0) >= 64 && Number(screen?.height || 0) >= 64),
+        issue_ledger_real_extraction: issues.length > 0 && issues.every((issue) => issue?.extraction_provider !== 'mock_fixture' && issue?.source !== 'mock_fixture'),
+        blockers: nextBlockers
+    };
+}
+async function validateImagegenResponseEvidence(response = null, dir = process.cwd()) {
+    const blockers = [];
+    if (!response || typeof response !== 'object') {
+        return { ok: false, blockers: ['imagegen_response_artifact_missing'] };
+    }
+    if (response.schema !== 'sks.image-ux-gpt-image-2-response.v1')
+        blockers.push('imagegen_response_schema_invalid');
+    if (response.ok !== true || response.status !== 'generated')
+        blockers.push(response.blocker || 'imagegen_response_not_generated');
+    const evidenceClass = String(response.evidence_class || '');
+    if (!evidenceClass)
+        blockers.push('imagegen_response_evidence_class_missing');
+    if (evidenceClass === 'mock_fixture')
+        blockers.push('imagegen_response_mock_fixture_not_full_evidence');
+    if (evidenceClass === 'non_codex_api_fallback')
+        blockers.push('imagegen_response_non_codex_api_fallback_not_full_evidence');
+    if (evidenceClass && evidenceClass !== 'codex_app_imagegen')
+        blockers.push(`imagegen_response_evidence_class_not_codex_app:${evidenceClass}`);
+    const source = String(response.output_source || '');
+    if (!['manual_attach', 'auto_discovered_generated_images'].includes(source))
+        blockers.push('imagegen_response_output_source_invalid');
+    const outputPath = String(response.output_image_path || '');
+    const expectedSha = String(response.output_sha256 || response.output_image_sha256 || '');
+    if (!outputPath)
+        blockers.push('imagegen_response_output_path_missing');
+    if (!expectedSha)
+        blockers.push('imagegen_response_output_sha256_missing');
+    if (outputPath) {
+        try {
+            const root = rootFromMissionDir(dir);
+            const absolute = path.isAbsolute(outputPath) ? outputPath : path.resolve(root, outputPath);
+            const actualSha = await sha256File(absolute);
+            if (expectedSha && actualSha !== expectedSha)
+                blockers.push('imagegen_response_output_sha256_mismatch');
+            const dims = await imageDimensions(absolute);
+            if (!Number.isFinite(Number(dims.width)) || !Number.isFinite(Number(dims.height)) || Number(dims.width) <= 0 || Number(dims.height) <= 0) {
+                blockers.push('imagegen_response_output_dimensions_invalid');
+            }
+        }
+        catch {
+            blockers.push('imagegen_response_output_file_unreadable');
+        }
+    }
+    return {
+        ok: blockers.length === 0,
+        provider: response.provider || null,
+        evidence_class: evidenceClass || null,
+        output_source: source || null,
+        output_image_path: outputPath || null,
+        output_sha256: expectedSha || null,
+        blockers: [...new Set(blockers)]
+    };
+}
+function rootFromMissionDir(dir) {
+    const marker = `${path.sep}.sneakoscope${path.sep}missions${path.sep}`;
+    const idx = String(dir).indexOf(marker);
+    return idx >= 0 ? String(dir).slice(0, idx) : process.cwd();
+}
 function nextActionForGate(gate = {}) {
     const blockers = gate?.blockers || [];
     if (blockers.includes('missing_generated_annotated_review_images'))