sneakoscope 4.8.6 → 5.1.2

package/dist/core/pipeline-internals/runtime-gates.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { appendJsonl, exists, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 import { containsUserQuestion, noQuestionContinuationReason } from '../no-question-guard.js';
-import { missionDir } from '../mission.js';
+import { missionDir, setCurrent } from '../mission.js';
 import { evaluateResearchGate } from '../research.js';
 import { evaluateQaGate } from '../qa-loop.js';
 import { PPT_REQUIRED_GATE_FIELDS } from '../ppt.js';
@@ -18,6 +18,7 @@ import { SSOT_GUARD_ARTIFACT, validateSsotGuardArtifact } from '../safety/ssot-g
 import { validateTeamRuntimeArtifacts } from '../team-dag.js';
 import { checkStopGate } from '../stop-gate/stop-gate-check.js';
 import { clarificationStopReason, context7Evidence, hasContext7DocsEvidence, hasSubagentEvidence, subagentEvidence, } from './runtime-core.js';
+import { projectTriwikiToAgentsMd } from '../triwiki/agents-md-projector.js';
 const REFLECTION_ARTIFACT = 'reflection.md';
 const REFLECTION_GATE = 'reflection-gate.json';
 const REFLECTION_MEMORY_PATH = '.sneakoscope/memory/q2_facts/post-route-reflection.md';
@@ -32,14 +33,14 @@ function reflectionRequiredForState(state = {}) {
         return true;
     return reflectionRequiredForRoute(state.route || state.mode || state.route_command);
 }
-async function reflectionGateStatus(root, state = {}) {
+async function reflectionGateStatus(root, state = {}, jsonCache) {
     if (!reflectionRequiredForState(state))
         return { ok: true, missing: [] };
     const id = state?.mission_id;
     if (!id)
         return { ok: false, missing: ['mission_id'] };
     const dir = missionDir(root, id);
-    const gate = await readJson(path.join(dir, REFLECTION_GATE), null);
+    const gate = await readJsonCached(jsonCache, path.join(dir, REFLECTION_GATE), null);
     if (!gate)
         return { ok: false, missing: [REFLECTION_GATE] };
     const hasArtifact = gate.reflection_artifact === true && await exists(path.join(dir, REFLECTION_ARTIFACT));
@@ -62,7 +63,16 @@ async function reflectionGateStatus(root, state = {}) {
     if (gate.wiki_validated !== true)
         missing.push('wiki_validated');
     missing.push(...await staleReflectionReasons(root, state, gate));
-    return { ok: missing.length === 0, missing };
+    const ok = missing.length === 0;
+    if (ok && state.reflection_invalidation_required === true) {
+        await setCurrent(root, {
+            reflection_invalidation_required: false,
+            reflection_invalidated_at: null,
+            reflection_invalidation_reason: null,
+            reflection_revalidated_at: nowIso()
+        }, { sessionKey: state._session_key });
+    }
+    return { ok, missing };
 }
 async function staleReflectionReasons(root, state = {}, gate = {}) {
     const created = Date.parse(gate.created_at || gate.updated_at || '');
@@ -73,6 +83,9 @@ async function staleReflectionReasons(root, state = {}, gate = {}) {
         return [];
     if (state.reflection_invalidation_required !== true)
         return [];
+    const invalidatedAt = Date.parse(String(state.reflection_invalidated_at || ''));
+    if (Number.isFinite(invalidatedAt) && created >= invalidatedAt)
+        return [];
     return ['reflection_invalidation_required'];
 }
 function reflectionStopReason(state = {}, status = {}) {
@@ -160,6 +173,7 @@ export async function projectGateStatus(root, state = {}) {
 }
 export async function evaluateStop(root, state, payload, opts = {}) {
     const last = extractLastMessage(payload);
+    const jsonCache = new Map();
     if (clarificationGatePending(state)) {
         if (await hasVisibleClarificationQuestionBlock(root, state, last))
             return { continue: true };
@@ -170,28 +184,56 @@ export async function evaluateStop(root, state, payload, opts = {}) {
             missing: ['explicit_user_answers', 'pipeline_answer']
         };
     }
-    if (state?.context7_required && !(await hasContext7DocsEvidence(root, state))) {
+    const route = routeFromState(state);
+    const stopGate = String(state?.stop_gate || '');
+    const completionProofRequired = state.proof_required === true || routeRequiresCompletionProof(route);
+    const reflectionRequired = reflectionRequiredForState(state);
+    if (!opts.noQuestion && (stopGate === 'none' || stopGate === 'honest_mode') && !state?.context7_required && !state?.subagents_required && !completionProofRequired && !reflectionRequired) {
+        return null;
+    }
+    const agentIntakeRequired = state?.mission_id && routeRequiresAgentIntake(route, { task: state.prompt, force: state.forceAgents === true, noAgents: state.agents_required === false });
+    const context7Promise = state?.context7_required ? hasContext7DocsEvidence(root, state) : Promise.resolve(true);
+    const subagentPromise = state?.subagents_required ? hasSubagentEvidence(root, state) : Promise.resolve(true);
+    const completionProofPromise = agentIntakeRequired
+        ? exists(path.join(missionDir(root, state.mission_id), 'completion-proof.json'))
+        : Promise.resolve(true);
+    const agentGatePromise = agentIntakeRequired ? readAgentGateStatus(root, state.mission_id) : Promise.resolve({ ok: true, missing: [] });
+    const mistakeRecallPromise = mistakeRecallGateStatus(root, state);
+    const [context7Ok, subagentOk, completionProofExists, agentGate, mistakeRecall] = await Promise.all([
+        context7Promise,
+        subagentPromise,
+        completionProofPromise,
+        agentGatePromise,
+        mistakeRecallPromise
+    ]);
+    if (state?.context7_required && !context7Ok) {
         return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} requires Context7 evidence before completion. Use Context7 resolve-library-id, then query-docs (or legacy get-library-docs), so SKS can record context7-evidence.jsonl.`, { gate: 'context7-evidence' });
     }
-    if (state?.subagents_required && !(await hasSubagentEvidence(root, state))) {
+    if (state?.subagents_required && !subagentOk) {
         return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} requires native multi-session evidence before completion. Run worker/reviewer native sessions for disjoint code-changing work, or record explicit evidence that native sessions were unavailable or unsafe to split.`, { gate: 'native-session-evidence' });
     }
-    if (state?.mission_id && !(await exists(path.join(missionDir(root, state.mission_id), 'completion-proof.json'))) && routeRequiresAgentIntake(routeFromState(state), { task: state.prompt, force: state.forceAgents === true, noAgents: state.agents_required === false })) {
-        const agentGate = await readAgentGateStatus(root, state.mission_id);
+    if (agentIntakeRequired && !completionProofExists) {
         if (!agentGate.ok) {
             return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route cannot continue to implementation/finalization: native agent intake gate is missing or blocked. Run: sks agent run latest --mock --json`, { gate: AGENT_INTAKE_STAGE_ID, missing: agentGate.missing || ['agents/agent-proof-evidence.json'] });
         }
     }
-    const mistakeRecall = await mistakeRecallGateStatus(root, state);
     if (!mistakeRecall.ok) {
         return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} found relevant TriWiki mistake memory that is not bound to the decision contract. Re-run pipeline answer or seal the contract so ${MISTAKE_RECALL_ARTIFACT} is consumed before finishing.`, { gate: MISTAKE_RECALL_ARTIFACT, missing: mistakeRecall.missing });
     }
     if (opts.noQuestion) {
         if (containsUserQuestion(last))
             return complianceBlock(root, state, noQuestionContinuationReason(), { gate: 'no-question' });
-        const gate = await passedActiveGate(root, state);
+        const gate = await passedActiveGate(root, state, jsonCache);
+        if (gate.hard_blocked) {
+            return {
+                continue: true,
+                action: 'hard_blocked',
+                gate: gate.file || HARD_BLOCKER_ARTIFACT,
+                systemMessage: `SKS ${state.route_command || state.mode || 'route'} route hard-blocked: ${gate.reason || 'hard blocker recorded'}`
+            };
+        }
         if (gate.ok) {
-            const reflection = await reflectionGateStatus(root, state);
+            const reflection = await reflectionGateStatus(root, state, jsonCache);
             if (!reflection.ok)
                 await appendHonestModeNote(root, state, `reflection stale: ${(reflection.missing || []).join(', ')}`);
             return { continue: true };
@@ -210,13 +252,14 @@ export async function evaluateStop(root, state, payload, opts = {}) {
                 route: state.route || state.mode,
                 missionId: state.mission_id,
                 explicitGatePath: typeof state.stop_gate_abs_path === 'string' && state.stop_gate_abs_path ? state.stop_gate_abs_path : undefined,
+                allowLatestFallback: opts.allowLatestFallback !== true ? false : true,
             });
             if (stopCheck.action === 'allow_stop') {
                 if (narutoFamily)
                     return { continue: true, systemMessage: `SKS: canonical stop-gate passed at ${stopCheck.gate_path}` };
             }
             else if (stopCheck.action === 'hard_blocked') {
-                return { decision: 'block', reason: stopCheck.feedback, action: 'hard_blocked', gate: stopCheck.gate_path };
+                return { continue: true, systemMessage: stopCheck.feedback, action: 'hard_blocked', gate: stopCheck.gate_path };
             }
             else {
                 const missing = stopCheck.diagnostics.missing_fields?.length ? ` Missing gate fields: ${stopCheck.diagnostics.missing_fields.join(', ')}.` : '';
@@ -225,7 +268,15 @@ export async function evaluateStop(root, state, payload, opts = {}) {
             }
         }
         else {
-            const gate = await passedActiveGate(root, state);
+            const gate = await passedActiveGate(root, state, jsonCache);
+            if (gate.hard_blocked) {
+                return {
+                    continue: true,
+                    action: 'hard_blocked',
+                    gate: gate.file || HARD_BLOCKER_ARTIFACT,
+                    systemMessage: `SKS ${state.route_command || state.mode || 'route'} route hard-blocked: ${gate.reason || 'hard blocker recorded'}`
+                };
+            }
             if (!gate.ok) {
                 const missing = gate.missing?.length ? ` Missing gate fields: ${gate.missing.join(', ')}.` : '';
                 return complianceBlock(root, state, `SKS ${state.route_command || state.mode} route cannot stop yet. Pass ${gate.file || state.stop_gate} or record a hard blocker with evidence before finishing.${missing}`, { gate: gate.file || state.stop_gate, missing: gate.missing });
@@ -236,11 +287,37 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     if (!proofGate.ok) {
         return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route cannot finalize without a valid Completion Proof. Missing or invalid proof issues: ${proofGate.issues.join(', ')}.`, { gate: 'completion-proof', missing: proofGate.issues });
     }
-    const reflection = await reflectionGateStatus(root, state);
+    const reflection = await reflectionGateStatus(root, state, jsonCache);
     if (!reflection.ok)
         return complianceBlock(root, state, reflectionStopReason(state, reflection), { gate: 'reflection', missing: reflection.missing });
+    fireAndForgetProjectMemory(root, state);
     return null;
 }
+function fireAndForgetProjectMemory(root, state = {}) {
+    if (!state?.mission_id)
+        return;
+    void projectTriwikiToAgentsMd(String(root)).then((report) => {
+        const id = state.mission_id;
+        if (!id)
+            return null;
+        return appendJsonl(path.join(missionDir(root, id), 'events.jsonl'), {
+            ts: nowIso(),
+            type: 'triwiki.agents_md_projected',
+            ok: report.ok,
+            reason: report.reason,
+            written: report.written
+        });
+    }).catch((err) => {
+        const id = state.mission_id;
+        if (!id)
+            return null;
+        return appendJsonl(path.join(missionDir(root, id), 'events.jsonl'), {
+            ts: nowIso(),
+            type: 'triwiki.agents_md_project_failed',
+            error: err?.message || String(err)
+        }).catch(() => undefined);
+    });
+}
 async function routeProofGateStatus(root, state = {}) {
     const route = routeFromState(state);
     const required = state.proof_required === true || routeRequiresCompletionProof(route);
@@ -266,6 +343,7 @@ async function complianceBlock(root, state = {}, reason = '', detail = {}) {
     if (!state?.mission_id)
         return { decision: 'block', reason };
     const dir = missionDir(root, state.mission_id);
+    await markReflectionInvalidatedForGateFailure(root, state, detail);
     const guardPath = path.join(dir, COMPLIANCE_LOOP_GUARD_ARTIFACT);
     const normalized = normalizeComplianceReason(reason);
     const previous = await readJson(guardPath, {});
@@ -305,7 +383,20 @@ async function complianceBlock(root, state = {}, reason = '', detail = {}) {
         ]
     });
     await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'pipeline.compliance_loop_guard.tripped', gate: record.gate, repeat_count: count, limit });
-    return { decision: 'escalate', reason, gate: detail.gate || state.stop_gate || null, repeat_count: count, message: '동일 사유가 반복됩니다. 사용자 개입이 필요합니다.' };
+    return { decision: 'escalate', reason, gate: detail.gate || state.stop_gate || null, repeat_count: count, message: '동일 사유가 반복됩니다. 사용자 개입이 필요합니다.', systemMessage: '동일 사유가 반복됩니다. 사용자 개입이 필요합니다.' };
+}
+async function markReflectionInvalidatedForGateFailure(root, state = {}, detail = {}) {
+    const gate = String(detail.gate || state.stop_gate || '');
+    if (!reflectionRequiredForState(state))
+        return;
+    if (!gate || /^(reflection|context7-evidence|native-session-evidence|no-question|clarification)$/i.test(gate))
+        return;
+    await setCurrent(root, {
+        mission_id: state.mission_id,
+        reflection_invalidation_required: true,
+        reflection_invalidated_at: nowIso(),
+        reflection_invalidation_reason: `gate_failed:${gate}`
+    }, { sessionKey: state._session_key });
 }
 function complianceLoopLimit(gate = '') {
     const gateKey = String(gate || '').toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
@@ -322,18 +413,26 @@ function normalizeComplianceReason(reason = '') {
         .trim()
         .slice(0, 1200);
 }
-async function passedActiveGate(root, state) {
+function readJsonCached(cache, file, fallback) {
+    if (!cache)
+        return readJson(file, fallback);
+    const key = path.resolve(file);
+    if (!cache.has(key))
+        cache.set(key, readJson(file, fallback));
+    return cache.get(key);
+}
+async function passedActiveGate(root, state, jsonCache) {
     const id = state?.mission_id;
     if (!id)
         return { ok: false, file: null };
-    const hardBlocker = await passedHardBlocker(root, state);
+    const hardBlocker = await passedHardBlocker(root, state, jsonCache);
     if (hardBlocker.ok)
         return hardBlocker;
     const files = gateFilesForState(state);
     for (const file of files) {
         const p = path.join(missionDir(root, id), file);
-        if (await exists(p)) {
-            const gate = await readJson(p, {});
+        const gate = await readJsonCached(jsonCache, p, null);
+        if (gate) {
             const missing = [
                 ...missingRequiredGateFields(file, state, gate),
                 ...await missingRequiredGateArtifacts(root, file, state, gate)
@@ -347,16 +446,28 @@ async function passedActiveGate(root, state) {
     }
     return { ok: false, file: files[0] || null };
 }
-async function passedHardBlocker(root, state) {
+async function passedHardBlocker(root, state, jsonCache) {
     if (!state?.mission_id)
         return { ok: false };
     const file = 'hard-blocker.json';
-    const blocker = await readJson(path.join(missionDir(root, state.mission_id), file), null);
+    const blocker = await readJsonCached(jsonCache, path.join(missionDir(root, state.mission_id), file), null);
     if (!blocker)
         return { ok: false };
-    if (String(blocker.status || '') === 'hard_blocked')
-        return { ok: false, file, missing: ['hard_blocked'] };
-    return { ok: blocker.passed === true && String(blocker.reason || '').trim() && Array.isArray(blocker.evidence) && blocker.evidence.length > 0, file };
+    const hasReason = String(blocker.reason || '').trim().length > 0;
+    const hasEvidence = Array.isArray(blocker.evidence) && blocker.evidence.length > 0;
+    if (String(blocker.status || '') === 'hard_blocked') {
+        const missing = [];
+        if (blocker.passed === true)
+            missing.push('passed_false');
+        if (!hasReason)
+            missing.push('reason');
+        if (!hasEvidence)
+            missing.push('evidence');
+        return missing.length
+            ? { ok: false, file, missing }
+            : { ok: true, file, hard_blocked: true, reason: String(blocker.reason || '').trim() };
+    }
+    return { ok: blocker.passed === true && hasReason && hasEvidence, file };
 }
 async function appendHonestModeNote(root, state = {}, message) {
     if (!state?.mission_id)
@@ -396,6 +507,8 @@ function missingRequiredGateFields(file, state, gate = {}) {
             'final_arbiter_accepted',
             'session_cleanup'
         ];
+        if (fromChatImgCoverageRequired(state, gate))
+            required.push('from_chat_img_request_coverage');
         return required.filter((key) => gate[key] !== true);
     }
     if (file === 'qa-gate.json' || mode === 'QALOOP') {
@@ -686,6 +799,9 @@ async function missingNarutoArtifacts(root, state = {}, gate = {}) {
     }
     if (gate.native_agent_proof === true && !(await exists(path.join(dir, 'agents', 'agent-proof-evidence.json'))))
         missing.push('agents/agent-proof-evidence.json');
+    if (fromChatImgCoverageRequired(state, gate) && gate.from_chat_img_request_coverage === true) {
+        missing.push(...await missingFromChatImgCoverageArtifacts(root, state));
+    }
     return missing;
 }
 function extractLastMessage(payload) {

package/dist/core/ppt-review/index.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { addImageRelation, ingestImage } from '../wiki-image/image-voxel-ledger.js';
 import { exportSlidesToImages, PPT_DECK_INVENTORY_ARTIFACT, PPT_SLIDE_EXPORT_LEDGER_ARTIFACT } from './slide-exporter.js';
-import { buildSlideImagegenRequestArtifact, buildSlideImagegenResponseArtifact, generateSlideCalloutReviews, PPT_SLIDE_CALLOUT_LEDGER_ARTIFACT, PPT_SLIDE_IMAGEGEN_REQUEST_ARTIFACT, PPT_SLIDE_IMAGEGEN_RESPONSE_ARTIFACT } from './slide-imagegen-review.js';
+import { buildSlideImagegenRequestArtifact, buildSlideImagegenResponseArtifact, buildSlideImagegenEvidence, generateSlideCalloutReviews, PPT_SLIDE_CALLOUT_LEDGER_ARTIFACT, PPT_SLIDE_IMAGEGEN_REQUEST_ARTIFACT, PPT_SLIDE_IMAGEGEN_RESPONSE_ARTIFACT } from './slide-imagegen-review.js';
 import { extractSlideIssues, PPT_DECK_ISSUE_LEDGER_ARTIFACT, PPT_SLIDE_EXTRACTION_REPORT_ARTIFACT, PPT_SLIDE_ISSUE_LEDGER_ARTIFACT } from './slide-issue-extraction.js';
 import { writePptFixTaskPlan, PPT_FIX_TASK_PLAN_ARTIFACT } from './ppt-fix-task-planner.js';
 import { writePptPatchHandoff, PPT_PATCH_HANDOFF_ARTIFACT, PPT_PATCH_RESULT_ARTIFACT } from './ppt-patch-handoff.js';
@@ -117,6 +117,9 @@ function buildPptImagegenReviewGate(parts = {}) {
     const p0p1 = Number(parts.deckIssueLedger.p0_p1_count || parts.deckIssueLedger.p0_p1_open_count || 0);
     const patchRequested = parts.fixRequested || p0p1 > 0 || parts.patchHandoff.result?.re_export_required === true;
     const changedSlidesRechecked = !patchRequested || parts.recheckReport.status === 'complete' || parts.mock === true;
+    const imagegenEvidence = buildSlideImagegenEvidence(parts.calloutLedger);
+    if (imagegenEvidence.required && imagegenEvidence.passed !== true)
+        blockers.push(...imagegenEvidence.blockers);
     const gate = {
         schema: 'sks.ppt-imagegen-review-gate.v1',
         created_at: nowIso(),
@@ -129,6 +132,7 @@ function buildPptImagegenReviewGate(parts = {}) {
         patch_requested: patchRequested,
         changed_slides_rechecked: changedSlidesRechecked,
         image_voxel_relations_created: parts.imageVoxelRelationsCreated === true,
+        imagegen_evidence: imagegenEvidence,
         wrongness_checked: true,
         honest_mode_complete: true,
         mock_fixture: parts.mock === true,
@@ -144,6 +148,7 @@ function buildPptImagegenReviewGate(parts = {}) {
         && gate.p0_p1_zero_after_fix
         && gate.changed_slides_rechecked
         && gate.image_voxel_relations_created
+        && gate.imagegen_evidence.passed === true
         && gate.blockers.length === 0;
     return gate;
 }

package/dist/core/ppt-review/slide-imagegen-review.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
-import { nowIso } from '../fsx.js';
+import { nowIso, readJson } from '../fsx.js';
 import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_IMAGEGEN_REQUIRED_POLICY } from '../routes.js';
 import { sha256File, imageDimensions } from '../wiki-image/image-hash.js';
 import { generateGptImage2CalloutReview } from '../image-ux-review/imagegen-adapter.js';
@@ -45,6 +45,9 @@ export async function generateSlideCalloutReviews({ root, dir, slideExportLedger
                 ...metadata,
                 status: 'generated',
                 source: 'mock_fixture',
+                evidence_class: 'mock_fixture',
+                output_source: 'mock_fixture',
+                output_sha256: metadata.sha256,
                 callout_extraction_status: 'succeeded',
                 callouts: [{
                         callout_id: 'callout-1',
@@ -62,8 +65,15 @@ export async function generateSlideCalloutReviews({ root, dir, slideExportLedger
     else if (generatedSlideImage && slides.length > 0) {
         const slide = slides[0];
         const generatedPath = await stageGeneratedSlideReview(root, dir, path.resolve(root, generatedSlideImage), path.basename(generatedSlideImage));
+        const metadata = await generatedSlideMetadata(root, generatedPath, slide, {
+            mock: false,
+            realGenerated: true,
+            providerSurface: 'codex_app_imagegen',
+            evidenceClass: 'codex_app_imagegen',
+            outputSource: 'manual_attach'
+        });
         generatedReviewImages.push({
-            ...await generatedSlideMetadata(root, generatedPath, slide, { mock: false, realGenerated: true }),
+            ...metadata,
             status: 'attached_generated_review',
             source: 'user_attached_generated_slide_review',
             callout_extraction_status: 'pending',
@@ -85,15 +95,23 @@ export async function generateSlideCalloutReviews({ root, dir, slideExportLedger
                 blockers.push(generated.blocker || 'ppt_imagegen_callouts_missing');
                 continue;
             }
-            const fakeGenerated = generated.provider === 'fake_imagegen_adapter';
+            const response = generated.response_artifact ? await readJson(generated.response_artifact, null).catch(() => null) : null;
+            const evidenceClass = String(response?.evidence_class || '');
+            const fakeGenerated = evidenceClass === 'mock_fixture' || generated.provider === 'fake_imagegen_adapter';
+            const codexGenerated = evidenceClass === 'codex_app_imagegen';
+            if (!codexGenerated)
+                blockers.push(evidenceClass === 'non_codex_api_fallback' ? 'ppt_imagegen_non_codex_api_fallback_not_full_evidence' : fakeGenerated ? 'ppt_imagegen_mock_fixture_not_full_evidence' : 'ppt_imagegen_evidence_class_missing');
             generatedReviewImages.push({
                 ...await generatedSlideMetadata(root, generated.generated_image_path, slide, {
                     mock: fakeGenerated,
-                    realGenerated: !fakeGenerated,
-                    providerSurface: generated.provider || 'gpt-image-2'
+                    realGenerated: codexGenerated,
+                    providerSurface: generated.provider || 'gpt-image-2',
+                    evidenceClass,
+                    outputSource: response?.output_source || null,
+                    outputSha256: response?.output_sha256 || response?.output_image_sha256 || null
                 }),
                 status: 'generated',
-                source: fakeGenerated ? 'mock_fixture' : 'real_gpt_image_2_callout',
+                source: fakeGenerated ? 'mock_fixture' : codexGenerated ? 'real_gpt_image_2_callout' : 'non_codex_api_fallback',
                 callout_extraction_status: fakeGenerated ? 'succeeded' : 'pending',
                 callouts: fakeGenerated ? [{
                         callout_id: 'fake-slide-callout-1',
@@ -159,9 +177,51 @@ export function buildSlideImagegenResponseArtifact(calloutLedger = {}) {
         schema: 'sks.ppt-slide-imagegen-response.v1',
         created_at: nowIso(),
         generated_review_images: calloutLedger.generated_review_images || [],
+        imagegen_evidence: buildSlideImagegenEvidence(calloutLedger),
         blockers: calloutLedger.blockers || []
     };
 }
+export function buildSlideImagegenEvidence(calloutLedger = {}) {
+    const images = Array.isArray(calloutLedger.generated_review_images) ? calloutLedger.generated_review_images : [];
+    const requiredCount = Number(calloutLedger.required_count || images.length || 0);
+    const blockers = [];
+    for (const image of images) {
+        const evidenceClass = String(image.evidence_class || '');
+        const outputSource = String(image.output_source || '');
+        const outputSha = String(image.output_sha256 || '');
+        if (evidenceClass !== 'codex_app_imagegen')
+            blockers.push(evidenceClass ? `ppt_slide_imagegen_evidence_class_not_codex_app:${evidenceClass}` : 'ppt_slide_imagegen_evidence_class_missing');
+        if (!['manual_attach', 'auto_discovered_generated_images'].includes(outputSource))
+            blockers.push(`ppt_slide_imagegen_output_source_invalid:${outputSource || 'missing'}`);
+        if (!outputSha)
+            blockers.push('ppt_slide_imagegen_output_sha256_missing');
+        else if (image.sha256 && image.sha256 !== outputSha)
+            blockers.push('ppt_slide_imagegen_output_sha256_mismatch');
+        if (image.real_generated !== true)
+            blockers.push('ppt_slide_imagegen_not_real_codex_app_output');
+    }
+    if (requiredCount > 0 && images.length < requiredCount)
+        blockers.push('ppt_slide_imagegen_required_outputs_missing');
+    return {
+        schema: 'sks.ppt-slide-imagegen-evidence.v1',
+        required: requiredCount > 0,
+        required_count: requiredCount,
+        generated_count: images.length,
+        codex_app_generated_count: images.filter((image) => image.evidence_class === 'codex_app_imagegen' && image.real_generated === true).length,
+        images: images.map((image) => ({
+            image_path: image.image_path || image.path || null,
+            output_source: image.output_source || null,
+            output_sha256: image.output_sha256 || null,
+            sha256: image.sha256 || null,
+            evidence_class: image.evidence_class || null,
+            real_generated: image.real_generated === true,
+            mock: image.mock === true,
+            response_artifact: image.imagegen_response_artifact || null
+        })),
+        blockers: [...new Set(blockers)],
+        passed: requiredCount > 0 && images.length >= requiredCount && blockers.length === 0
+    };
+}
 async function stageGeneratedSlideReview(root, dir, source, preferredName) {
     const dest = path.join(dir, 'generated-slide-reviews', preferredName);
     await fsp.mkdir(path.dirname(dest), { recursive: true });
@@ -170,21 +230,26 @@ async function stageGeneratedSlideReview(root, dir, source, preferredName) {
     return path.relative(root, dest).split(path.sep).join('/');
 }
 async function generatedSlideMetadata(root, relPath, slide, opts = {}) {
-    const absolute = path.resolve(root, relPath);
+    const absolute = path.isAbsolute(relPath) ? relPath : path.resolve(root, relPath);
     const dims = await imageDimensions(absolute);
+    const normalizedPath = path.relative(root, absolute).split(path.sep).join('/');
+    const sha = await sha256File(absolute);
     return {
         id: opts.mock ? `ppt-generated-review-fixture-${slide.slide_index || 1}` : `ppt-generated-review-${slide.slide_index || 1}`,
         generated_review_image_id: opts.mock ? `ppt-generated-review-fixture-${slide.slide_index || 1}` : `ppt-generated-review-${slide.slide_index || 1}`,
         slide_id: slide.slide_id,
         slide_index: slide.slide_index,
         source_slide_image_path: slide.image_path,
-        image_path: relPath,
-        sha256: await sha256File(absolute),
+        image_path: normalizedPath,
+        sha256: sha,
+        output_sha256: opts.outputSha256 || sha,
+        output_source: opts.outputSource || (opts.mock ? 'mock_fixture' : 'manual_attach'),
+        evidence_class: opts.evidenceClass || (opts.mock ? 'mock_fixture' : opts.realGenerated ? 'codex_app_imagegen' : 'non_codex_api_fallback'),
         width: dims.width,
         height: dims.height,
         format: dims.format,
         provider_surface: opts.mock ? 'mock_fixture' : (opts.providerSurface || 'Codex App $imagegen'),
-        real_generated: opts.realGenerated === true,
+        real_generated: opts.realGenerated === true && (opts.evidenceClass || (opts.mock ? 'mock_fixture' : 'codex_app_imagegen')) === 'codex_app_imagegen',
         mock: opts.mock === true,
         local_only: true
     };

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,