sneakoscope 4.8.7 → 5.3.0

package/dist/core/naruto/naruto-active-pool.js

@@ -264,6 +264,7 @@ export function simulateNarutoActivePool(input) {
     let maxObserved = 0;
     let maxObservedWriteLeaseConflicts = 0;
     let conflictItemsEnqueued = 0;
+    const repairWaves = [];
     while (pending.length || active.size) {
         let launched = 0;
         for (;;) {
@@ -293,7 +294,15 @@ export function simulateNarutoActivePool(input) {
             if (shouldFail) {
                 failed.add(generation.work_item_id);
                 conflictItemsEnqueued += 1;
-                const followup = conflictResolutionFollowup(generation.work_item_id, input.graph.work_items.length + conflictItemsEnqueued);
+                const attempt = executed.get(generation.work_item_id) || 1;
+                const followup = conflictResolutionFollowup(generation.work_item_id, input.graph.work_items.length + conflictItemsEnqueued, attempt);
+                repairWaves.push({
+                    failed_work_item_id: generation.work_item_id,
+                    followup_work_item_id: followup.id,
+                    attempt,
+                    requires_hypothesis: true,
+                    tournament_forced: Boolean(followup.tournament && followup.tournament >= 2)
+                });
                 pending.push(followup);
                 byId.set(followup.id, followup);
             }
@@ -325,6 +334,7 @@ export function simulateNarutoActivePool(input) {
         duplicate_execution_count: duplicateExecutionCount,
         conflict_items_enqueued: conflictItemsEnqueued,
         max_observed_write_lease_conflicts: maxObservedWriteLeaseConflicts,
+        repair_waves: repairWaves,
         timeline,
         blockers
     };
@@ -359,12 +369,12 @@ function countActiveWriteLeaseConflicts(active, byId) {
     }
     return [...counts.values()].filter((count) => count > 1).reduce((sum, count) => sum + count - 1, 0);
 }
-function conflictResolutionFollowup(failedId, index) {
+function conflictResolutionFollowup(failedId, index, attempt = 1) {
     const id = `NW-CONFLICT-${String(index).padStart(4, '0')}`;
     return {
         id,
         kind: 'conflict_resolution',
-        title: `Resolve failed work item ${failedId}`,
+        title: `Resolve failed work item ${failedId} with repair-hypothesis.json before patching`,
         target_paths: [],
         readonly_paths: [],
         write_paths: [`.sneakoscope/naruto/conflicts/${id}.json`],
@@ -376,7 +386,8 @@ function conflictResolutionFollowup(failedId, index) {
         conflicts_with: [],
         estimated_cost: { tokens: 4000, latency_ms: 45000, cpu_weight: 1, memory_mb: 256, gpu_weight: 0 },
         lease_requirements: [{ path: `.sneakoscope/naruto/conflicts/${id}.json`, kind: 'write' }],
-        acceptance: { requires_patch_envelope: true, requires_verification: true, requires_gpt_final: true }
+        acceptance: { requires_patch_envelope: true, requires_verification: true, requires_gpt_final: true },
+        ...(attempt >= 3 ? { tournament: 3 } : {})
     };
 }
 //# sourceMappingURL=naruto-active-pool.js.map

package/dist/core/naruto/naruto-real-worker-child.js

@@ -136,7 +136,7 @@ function startDeadmanHeartbeat(input) {
                 schema: 'sks.naruto-actual-worker-heartbeat.v1',
                 ts: nowIso(),
                 item_id: input.intake.item.id,
-                status: 'blocked',
+                status: 'timed_out',
                 elapsed_ms: elapsedMs,
                 progress: null
             }, 2 * 1024 * 1024).catch(() => undefined);
@@ -180,9 +180,19 @@ function buildNarutoWorkerPrompt(item, parentPrompt) {
         writeAllowed
             ? 'If changes are needed, return model-authored patch_envelopes scoped to write paths.'
             : 'This is read-only work. Do not mutate files and return an empty patch_envelopes array.',
+        writeAllowed
+            ? 'Before changing exported signatures, inspect references and include cochanged callers in the same patch; only set cochange_acknowledged with a concrete compatibility reason.'
+            : null,
+        /bug|fix|regression|broken|버그|수정/i.test(String(item?.kind || '') + ' ' + String(item?.title || ''))
+            ? 'Bugfix protocol: first add a regression test, record failed_before and passed_after in regression_proof, then patch the bug.'
+            : null,
+        /repair|conflict|fix/i.test(String(item?.kind || '') + ' ' + String(item?.title || ''))
+            ? 'Repair protocol: write repair_hypothesis before patching, including failure, hypotheses, chosen evidence, and minimal_probe.'
+            : null,
         writeAllowed
             ? null
             : 'For read-only work, inspect requested files/artifacts only; do not run package scripts, build commands, tests, or temp-file-creating checks unless the parent objective explicitly requires them.',
+        'Impact scan, machine feedback, diff-quality, mistake-rule, TDD, and repair-hypothesis gates run before patch queue acceptance.',
         'Include verification checks, rollback notes, blockers, findings, and changed_files.'
     ].filter(Boolean).join('\n');
 }

package/dist/core/naruto/naruto-role-policy.js

@@ -17,6 +17,8 @@ export function narutoRoleAllowsWrite(role) {
 }
 export function mapWorkKindToNarutoRole(kind) {
     switch (kind) {
+        case 'bugfix':
+        case 'feature':
         case 'implementation':
             return 'implementer';
         case 'code_modification':
@@ -34,6 +36,7 @@ export function mapWorkKindToNarutoRole(kind) {
         case 'research':
             return 'researcher';
         case 'documentation':
+        case 'chore':
             return 'modifier';
         case 'conflict_resolution':
             return 'conflict_resolver';

package/dist/core/naruto/naruto-task-hints.js

@@ -38,6 +38,16 @@ export function pathPrefix(pathValue) {
         return parts.slice(0, 3).join('/');
     return parts.slice(0, 2).join('/');
 }
+export function classifyNarutoDeliveryKind(text) {
+    const hay = String(text || '').toLowerCase();
+    if (/(^|\b)(fix|bug|broken|regression|failure|failing|crash|error)(\b|$)|버그|고쳐|수정|회귀/.test(hay))
+        return 'bugfix';
+    if (/(^|\b)(refactor|cleanup|simplify|restructure)(\b|$)|리팩터|정리/.test(hay))
+        return 'refactor';
+    if (/(^|\b)(chore|docs?|config|metadata|version)(\b|$)|문서|설정/.test(hay))
+        return 'chore';
+    return 'feature';
+}
 function normalizePaths(paths) {
     return [...new Set(paths.map((file) => normalizeNarutoPath(String(file || ''))).filter(Boolean))].sort();
 }

package/dist/core/naruto/naruto-work-graph.js

@@ -1,5 +1,6 @@
 import { mapWorkKindToNarutoRole } from './naruto-role-policy.js';
 import { isNarutoWriteKind, normalizeNarutoPath } from './naruto-work-item.js';
+import { classifyNarutoDeliveryKind } from './naruto-task-hints.js';
 const WRITE_CAPABLE_KIND_CYCLE = [
     'implementation',
     'code_modification',
@@ -53,7 +54,11 @@ export function buildNarutoWorkGraph(input = {}) {
     }
     for (let index = 0; index < totalWorkItems; index += 1) {
         const id = `NW-${String(index + 1).padStart(6, '0')}`;
-        const kind = kindCycle[index % kindCycle.length] || 'verification';
+        const baseKind = kindCycle[index % kindCycle.length] || 'verification';
+        const deliveryKind = classifyNarutoDeliveryKind(input.prompt || '');
+        const kind = writeCapable && index === 0 && ['implementation', 'code_modification', 'refactor'].includes(baseKind)
+            ? deliveryKind
+            : baseKind;
         const kindWrites = writeCapable && isNarutoWriteKind(kind);
         const selectedTarget = targetPaths.length ? targetPaths[index % targetPaths.length] || targetPaths[0] || '' : `${basePath}/${id}.json`;
         const writePaths = kindWrites ? [selectedTarget].filter(Boolean) : [];
@@ -95,7 +100,8 @@ export function buildNarutoWorkGraph(input = {}) {
                     required: worktreePolicy.required,
                     allocation_required: worktreePolicy.mode === 'git-worktree'
                 }
-            } : {})
+            } : {}),
+            ...(writePaths.length > 0 && input.tournament && input.tournament >= 2 ? { tournament: Math.min(4, Math.max(2, Math.floor(input.tournament))) } : {})
         });
     }
     const activeWaves = planNarutoWorkWaves(workItems, Math.max(1, normalizePositiveInt(input.maxActiveWorkers, requestedClones)));

package/dist/core/naruto/naruto-work-item.js

@@ -1,7 +1,10 @@
 export const NARUTO_WORK_KINDS = [
+    'bugfix',
+    'feature',
     'implementation',
     'code_modification',
     'refactor',
+    'chore',
     'test_generation',
     'test_execution',
     'verification',
@@ -17,9 +20,12 @@ export const NARUTO_WORK_KINDS = [
     'final_review_input_pack'
 ];
 export const NARUTO_WRITE_WORK_KINDS = new Set([
+    'bugfix',
+    'feature',
     'implementation',
     'code_modification',
     'refactor',
+    'chore',
     'test_generation',
     'documentation',
     'conflict_resolution',

package/dist/core/naruto/solution-tournament.js

@@ -0,0 +1,101 @@
+import { runMachineFeedback } from '../verification/machine-feedback.js';
+import { scanImpact } from '../verification/impact-scan.js';
+export const APPROACHES = [
+    '기존 코드 재사용을 극대화하는 최소 diff 접근',
+    '해당 모듈의 지배적 패턴을 따르는 정석 접근',
+    '근본 원인을 한 단계 위에서 해결하는 구조적 접근',
+    '테스트와 관찰 가능성을 먼저 고정하는 증거 중심 접근'
+];
+export async function runSolutionTournament(input) {
+    const n = Math.min(Math.max(input.n ?? 3, 2), 4);
+    const candidates = await Promise.all(APPROACHES.slice(0, n).map((approach, index) => input.spawnWorker({ ...input.item, id: `${input.item.id}-cand${index + 1}`, approach_directive: approach, isolation: 'worktree' })
+        .then((candidate) => ({ ...candidate, id: candidate.id || `${input.item.id}-cand${index + 1}`, approach }))));
+    await Promise.all(candidates.map(async (candidate) => {
+        candidate.score = await scoreCandidate(input.root, candidate);
+    }));
+    const alive = candidates
+        .filter((candidate) => candidate.score?.machine_ok && candidate.score.impact_breaks === 0)
+        .sort((a, b) => rank(a.score) - rank(b.score));
+    if (alive.length === 0)
+        return { schema: 'sks.solution-tournament.v1', winner: null, reason: 'all_candidates_failed_machine_checks', candidates };
+    if (alive.length === 1)
+        return { schema: 'sks.solution-tournament.v1', winner: alive[0] || null, reason: 'single_survivor', candidates };
+    const verdict = await input.judgeWorker({
+        a: alive[0],
+        b: alive[1],
+        prompt: '두 패치 중 6개월 뒤 유지보수자가 고마워할 쪽을 골라라. 근거는 코드 사실만.'
+    });
+    return {
+        schema: 'sks.solution-tournament.v1',
+        winner: verdict.pick === 'b' ? alive[1] : alive[0],
+        reason: `judge:${verdict.reason_digest}`,
+        candidates
+    };
+}
+export async function scoreCandidate(root, candidate) {
+    const patchText = patchTextFromCandidate(candidate);
+    const changedFiles = changedFilesFromCandidate(candidate);
+    const feedbackRoot = candidate.worktree || root;
+    const [feedback, impact] = await Promise.all([
+        runMachineFeedback(feedbackRoot, changedFiles, { timeoutMs: 60_000 }),
+        scanImpact(feedbackRoot, changedFiles, patchText)
+    ]);
+    const score = {
+        machine_ok: feedback.ok,
+        tests_passed: feedback.tests.ok ? feedback.tests.selected.length : 0,
+        tests_failed: feedback.tests.failed.length,
+        diff_lines: diffLineCount(patchText),
+        new_symbols: newExportCount(patchText),
+        impact_breaks: impact.cochange_required.length,
+        total: 0
+    };
+    score.total = rank(score);
+    return score;
+}
+export function summarizeTournament(result) {
+    return {
+        schema: result.schema,
+        winner_id: result.winner?.id || null,
+        reason: result.reason,
+        candidates: result.candidates.map((candidate) => ({
+            id: candidate.id,
+            approach: candidate.approach,
+            worktree: candidate.worktree,
+            score: candidate.score
+        }))
+    };
+}
+export function rank(s) {
+    return s.tests_failed * 1000 + s.impact_breaks * 500 + s.new_symbols * 20 + s.diff_lines;
+}
+function changedFilesFromCandidate(candidate) {
+    const patch = candidate.patch || {};
+    if (Array.isArray(patch.changed_files))
+        return patch.changed_files.map(String);
+    if (Array.isArray(patch.git_worktree?.changed_files))
+        return patch.git_worktree.changed_files.map(String);
+    if (Array.isArray(patch.operations))
+        return [...new Set(patch.operations.map((operation) => String(operation.path || '')).filter(Boolean))];
+    if (Array.isArray(patch.patch_envelopes))
+        return [...new Set(patch.patch_envelopes.flatMap((envelope) => changedFilesFromCandidate({ ...candidate, patch: envelope })))];
+    return [];
+}
+function patchTextFromCandidate(candidate) {
+    const patch = candidate.patch || {};
+    if (typeof patch.diff === 'string')
+        return patch.diff;
+    if (typeof patch.patch_text === 'string')
+        return patch.patch_text;
+    if (Array.isArray(patch.operations))
+        return patch.operations.map((operation) => operation.diff || operation.content || operation.replace || '').join('\n');
+    if (Array.isArray(patch.patch_envelopes))
+        return patch.patch_envelopes.map((envelope) => patchTextFromCandidate({ ...candidate, patch: envelope })).join('\n');
+    return '';
+}
+function diffLineCount(patchText) {
+    return String(patchText || '').split(/\r?\n/).filter((line) => /^[+-]/.test(line) && !/^(---|\+\+\+)/.test(line)).length;
+}
+function newExportCount(patchText) {
+    return String(patchText || '').split(/\r?\n/).filter((line) => /^\+\s*export\s+(?:async\s+)?(?:function|const|class|interface|type)\s+\w+/.test(line)).length;
+}
+//# sourceMappingURL=solution-tournament.js.map

package/dist/core/permission-gates.js

@@ -86,6 +86,36 @@ export function madSksCatastrophicDbReasons(cls = {}) {
         blocked.push('dangerous_project_or_branch_management');
     return [...new Set(blocked)];
 }
+export function madSksCatastrophicSqlLiteralRequirements(cls = {}) {
+    const reasons = madSksCatastrophicDbReasons(cls);
+    const requirements = {
+        drop_database: /\bdrop\s+database\b/i,
+        drop_schema: /\bdrop\s+schema\b/i,
+        drop_table: /\bdrop\s+table\b/i,
+        truncate: /\btruncate\b/i,
+        delete_without_where: /\bdelete\s+from\b(?![\s\S]*\bwhere\b)/i,
+        update_without_where: /\bupdate\b[\s\S]*\bset\b(?![\s\S]*\bwhere\b)/i
+    };
+    return reasons
+        .flatMap((reason) => {
+        const pattern = requirements[reason];
+        return pattern ? [{ reason, pattern }] : [];
+    });
+}
+export function madSksCatastrophicSqlExplicitlyRequested({ classification, userIntent, sql } = {}) {
+    const requirements = madSksCatastrophicSqlLiteralRequirements(classification || {});
+    if (!requirements.length)
+        return { required: false, ok: true, missing: [] };
+    // The SQL text can be generated by the agent. Only the user's literal request
+    // or CLI statement counts as explicit catastrophic authorization.
+    const haystack = String(userIntent || '');
+    const missing = requirements.filter((entry) => !entry.pattern.test(haystack)).map((entry) => entry.reason);
+    return {
+        required: true,
+        ok: missing.length === 0,
+        missing
+    };
+}
 export function evaluatePermission({ action, scope, profile, classification, active = false, env = process.env } = {}) {
     const selectedProfile = normalizePermissionProfile(profile, env);
     const actionId = String(action || scope || '').trim();

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

@@ -870,6 +870,13 @@ async function materializeAutoSealedMadSks(dir, id, route, routeContext = {}, co
         normal_db_writes_allowed: true,
         live_server_writes_allowed: true,
         migration_apply_allowed: true,
+        sql_plane: {
+            requested: false,
+            capability_id: null,
+            operation_classes: [],
+            read_back_passed: false,
+            profile_closed: false
+        },
         catastrophic_safety_guard_active: true,
         permission_profile: permissionGateSummary(),
         contract_hash: contract.sealed_hash || null
@@ -962,7 +969,7 @@ async function prepareDb(root, route, task, required, opts = {}) {
     return routeContext(route, id, task, required, 'Run sks db policy/scan/check as needed, keep DB operations read-only, record safe MCP policy, and pass db-review.json.');
 }
 async function prepareMadDb(root, route, task, required, opts = {}) {
-    const prepared = await prepareMadDbMission({ root, task, verifyTools: false, sessionKey: opts.sessionKey });
+    const prepared = await prepareMadDbMission({ root, task, verifyTools: false, sessionKey: opts.sessionKey, route: 'MadSKS', routeCommand: '$MAD-SKS' });
     const dir = missionDir(root, prepared.mission_id);
     const pipelinePlan = await writePipelinePlan(dir, {
         missionId: prepared.mission_id,
@@ -978,7 +985,7 @@ async function prepareMadDb(root, route, task, required, opts = {}) {
         cycle_id: prepared.cycle_id,
         blockers: prepared.blockers
     });
-    await setCurrent(root, routeState(prepared.mission_id, route, prepared.ok ? 'MADDB_SQL_PLANE_CAPABILITY_ACTIVE' : 'MADDB_BLOCKED', required, {
+    await setCurrent(root, routeState(prepared.mission_id, route, prepared.ok ? 'MADSKS_SQL_PLANE_CAPABILITY_ACTIVE' : 'MADSKS_SQL_PLANE_BLOCKED', required, {
         prompt: task,
         questions_allowed: false,
         implementation_allowed: prepared.ok,
@@ -990,7 +997,8 @@ async function prepareMadDb(root, route, task, required, opts = {}) {
         mad_db_profile_sha256: prepared.capability.transport.profile_sha256,
         mad_db_capability_mission_id: prepared.mission_id,
         mad_db_capability_file: 'mad-db-capability.json',
-        stop_gate: 'mad-db-gate.json',
+        mad_sks_gate_file: 'mad-sks-gate.json',
+        stop_gate: 'mad-sks-gate.json',
         pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
         pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
     }), { sessionKey: opts.sessionKey });

package/dist/core/pipeline-internals/runtime-gates.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';
@@ -289,8 +290,34 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     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);

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
     };