sneakoscope 7.1.0 → 7.3.0

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

@@ -5,8 +5,10 @@ import { createMission, getOrCreateSessionMission, missionDir, sessionStateKey,
 import { buildQuestionSchemaForRoute, buildRequestIntake, REQUEST_INTAKE_ARTIFACT, writeQuestions } from '../questions.js';
 import { sealContract } from '../decision-contract.js';
 import { scanDbSafety } from '../db-safety.js';
+import { createDbAccessReviewSeed, createDbReviewSeed, DB_ACCESS_CANDIDATES_ARTIFACT, DB_ACCESS_REVIEW_ARTIFACT, DB_MANUAL_MIGRATION_ARTIFACT, DB_REVIEW_ARTIFACT, scanDbAccessCandidates } from '../db-review.js';
+import { createEngineeringSanityReviewSeed, ENGINEERING_SANITY_CODE_STRUCTURE_REPORT, ENGINEERING_SANITY_REVIEW_ARTIFACT } from '../engineering-sanity-review.js';
 import { createAndWriteWorkOrderLedgerForPrompt } from '../work-order-ledger.js';
-import { writeCodeStructureReport } from '../code-structure.js';
+import { resolveChangedScopeBase, writeCodeStructureReport } from '../code-structure.js';
 import { writeMemorySweepReport } from '../memory-governor.js';
 import { writeMistakeMemoryReport } from '../mistake-memory.js';
 import { MISTAKE_RECALL_ARTIFACT, mistakeRecallGateStatus } from '../mistake-recall.js';
@@ -25,8 +27,8 @@ import { prepareMadSksSqlPlaneMission } from '../mad-sks/sql-plane/coordinator.j
 import { MAD_SKS_SQL_PLANE_CAPABILITY_FILE, madSksSqlPlaneRelativePath } from '../mad-sks/sql-plane/paths.js';
 import { OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID } from '../agents/agent-schema.js';
 import { normalizeOfficialSubagentPolicy, officialSubagentPipelineStage } from '../agents/agent-plan.js';
-import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_EVIDENCE_SOURCE, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, chatCaptureIntakeText, context7RequirementText, dollarCommand, evidenceMentionsForbiddenBrowserAutomation, explicitManagedSkillNames, hasFromChatImgSignal, hasMadSksSignal, imageUxReviewPipelinePolicyText, managedSkillNamesForPrompt, pptPipelineAllowlistPolicyText, reflectionRequiredForRoute, reasoningInstruction, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, stripDollarCommand, stripMadSksSignal, stripVisibleDecisionAnswerBlocks, subagentExecutionPolicyText, stackCurrentDocsPolicyText, triwikiContextTracking } from '../routes.js';
-import { coreEngineeringDirectiveReferenceText } from '../lean-engineering-policy.js';
+import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_EVIDENCE_SOURCE, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, chatCaptureIntakeText, context7RequirementText, dollarCommand, evidenceMentionsForbiddenBrowserAutomation, explicitManagedSkillNames, hasFromChatImgSignal, hasMadSksSignal, imageUxReviewPipelinePolicyText, looksLikeCodeChangingWork, managedSkillNamesForPrompt, pptPipelineAllowlistPolicyText, reflectionRequiredForRoute, reasoningInstruction, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, stripDollarCommand, stripMadSksSignal, stripVisibleDecisionAnswerBlocks, subagentExecutionPolicyText, stackCurrentDocsPolicyText, triwikiContextTracking } from '../routes.js';
+import { coreEngineeringDirectiveReferenceText, engineeringSanityPolicyText } from '../lean-engineering-policy.js';
 import { classifyTaskProfile, gateProfileForTask } from '../runtime/task-profile.js';
 import { chooseVerificationBudget } from '../runtime/verification-budget.js';
 import { NARUTO_PARENT_MODEL } from '../subagents/model-policy.js';
@@ -77,6 +79,7 @@ const STAGE_BLOCKING_GATE = Object.freeze({
     parent_integration: 'ownership',
     route_materialization: 'ownership',
     work_order_coverage: 'ownership',
+    engineering_sanity_check: 'verification',
     listed_verification: 'verification',
     triwiki_validate_before_final: 'verification',
     completion_proof: 'verification',
@@ -121,7 +124,7 @@ export function buildPipelinePlan(input = {}) {
         changedFiles: Array.isArray(input.changedFiles) ? input.changedFiles : []
     });
     const stages = buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, lane, Boolean(input.required), officialSubagentPolicy);
-    const verification = planVerification(route, proof, verificationBudget);
+    const verification = planVerification(route, task, proof, verificationBudget);
     const skipped = stages.filter((stage) => stage.status === 'skipped').map((stage) => stage.id);
     const kept = stages.filter((stage) => stage.status !== 'skipped' && stage.status !== 'not_applicable').map((stage) => stage.id);
     const routeEconomy = routeEconomyPlan(proof);
@@ -175,6 +178,7 @@ export function buildPipelinePlan(input = {}) {
         kept_stages: kept,
         verification_budget: verificationBudget,
         verification,
+        engineering_sanity_review: null,
         invariants,
         proof_field: proof,
         ssot_guard: buildSsotGuard({ route: route?.id || 'SKS', mode: route?.mode || 'SKS', task }),
@@ -204,9 +208,42 @@ export async function writePipelinePlan(dir, input = {}) {
     }
     const requestIntake = input.requestIntake || await writeRequestIntakeArtifact(dir, input);
     const plan = buildPipelinePlan({ ...input, taskProfile, requestIntake });
+    const root = input.root || rootFromMissionDir(dir);
+    if (planStagesEngineeringSanityReview(plan)) {
+        plan.engineering_sanity_review = {
+            artifact: ENGINEERING_SANITY_REVIEW_ARTIFACT,
+            code_structure_report: ENGINEERING_SANITY_CODE_STRUCTURE_REPORT,
+            changed_scope_base: resolveChangedScopeBase(root)
+        };
+    }
     await writeJsonAtomic(path.join(dir, PIPELINE_PLAN_ARTIFACT), plan);
+    if (plan.engineering_sanity_review) {
+        const report = await writeCodeStructureReport(root, dir, {
+            missionId: input.missionId || null,
+            changedSince: plan.engineering_sanity_review.changed_scope_base,
+            includeOk: true
+        });
+        const reportText = await readText(path.join(dir, ENGINEERING_SANITY_CODE_STRUCTURE_REPORT), '');
+        const reviewFile = path.join(dir, ENGINEERING_SANITY_REVIEW_ARTIFACT);
+        if (!(await exists(reviewFile))) {
+            await writeJsonAtomic(reviewFile, createEngineeringSanityReviewSeed(plan.route?.command || plan.route?.id || null, report, reportText));
+        }
+    }
     return plan;
 }
+function planStagesEngineeringSanityReview(plan) {
+    return Array.isArray(plan?.stages) && plan.stages.some((stage) => (String(stage?.id || '') === 'engineering_sanity_check'
+        && !['skipped', 'not_applicable'].includes(String(stage?.status || ''))));
+}
+export function pipelinePlanState(plan) {
+    const sanity = plan?.engineering_sanity_review || null;
+    return {
+        pipeline_plan_ready: validatePipelinePlan(plan).ok,
+        pipeline_plan_path: PIPELINE_PLAN_ARTIFACT,
+        engineering_sanity_required: Boolean(sanity),
+        engineering_sanity_scope_base: sanity?.changed_scope_base || null
+    };
+}
 export async function writeRequestIntakeArtifact(dir, input = {}) {
     const file = path.join(dir, REQUEST_INTAKE_ARTIFACT);
     if (!input.requestIntake && !input.forceRequestIntakeRewrite) {
@@ -488,6 +525,8 @@ function buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, l
     if ((gateProfile === 'scoped' || gateProfile === 'full') && !LIGHTWEIGHT_ROUTES.has(route?.id)) {
         ids.push('triwiki_use_first', 'triwiki_validate_before_final', 'mistake_recall', 'work_order_coverage');
     }
+    if (routeNeedsEngineeringSanityReview(route, task))
+        ids.push('engineering_sanity_check');
     if (routeRequiresSubagents(route, task, taskProfile))
         ids.push('subagent_plan', 'official_subagent_execution', 'parent_integration');
     if (specializedRoute)
@@ -505,6 +544,22 @@ function buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, l
         const metadata = { blocking, blocking_gate: blocking ? blockingGate : null };
         if (id === OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID)
             return { ...officialSubagentPipelineStage(officialSubagentPolicy), status: 'required', reason: officialSubagentPolicy.reason, ...metadata };
+        if (id === 'engineering_sanity_check') {
+            return {
+                id,
+                status: 'keep',
+                reason: 'required_for_code_and_database_quality',
+                checks: [
+                    'trace actual callers and preserve basic SOLID responsibility and dependency boundaries',
+                    'inspect loops, collections, resolvers, and serializers for N+1 or repeated I/O',
+                    'prove render, recursion, event, retry, and polling loops are bounded and cancellable',
+                    'reject disabled checks, swallowed errors, placeholder success, and verification bypasses',
+                    'for DB work, verify the existing canonical adapter and connection/pool lifecycle before changes',
+                    'for sensitive or multi-step DB work, verify transaction rollback, error propagation, idempotency, and post-commit invariants'
+                ],
+                ...metadata
+            };
+        }
         if (id === 'ambiguity_gate' && ambiguity?.required === false)
             return { id, status: 'not_applicable', reason: 'ambiguity_gate_not_required_for_entrypoint', ...metadata };
         if (id === 'ambiguity_gate' && ambiguity?.passed)
@@ -512,7 +567,7 @@ function buildPipelineStages(route, task, taskProfile, gateProfile, ambiguity, l
         return { id, status: 'keep', reason: lane.fast_lane_allowed ? 'task_profile_minimal_lane' : 'required_by_task_and_route_profile', ...metadata };
     });
 }
-function planVerification(route, proof, budget) {
+function planVerification(route, task, proof, budget) {
     if (budget === 'none')
         return [];
     const out = new Set(proof.verification || []);
@@ -530,12 +585,20 @@ function planVerification(route, proof, budget) {
     }
     if (route?.id === 'Naruto')
         out.add('validate official subagent evidence and the parent integration summary');
+    if (routeNeedsEngineeringSanityReview(route, task)) {
+        out.add('complete the engineering sanity review for SOLID boundaries, N+1/repeated I/O, bounded loops, and verification bypasses');
+    }
+    if (route?.id === 'DB' || route?.id === 'MadSKS') {
+        out.add('verify existing canonical DB access, pool lifecycle, and transaction integrity for sensitive or multi-step mutations');
+    }
     if (reflectionRequiredForRoute(route))
         out.add('sks wiki validate .sneakoscope/wiki/context-pack.json');
     return [...out];
 }
 function pipelineInvariants(input) {
     const out = ['no_unrequested_fallback_code'];
+    if (input.stages.some((stage) => stage.id === 'engineering_sanity_check'))
+        out.push('engineering_sanity_check');
     if (input.verificationBudget !== 'none')
         out.push('listed_verification');
     if (input.stages.some((stage) => stage.id === 'ssot_guard' && stage.status !== 'not_applicable'))
@@ -586,6 +649,7 @@ export function promptPipelineContext(prompt, route = null) {
         reasoningInstruction(reasoning),
         responseLanguageInstruction(cleanPrompt),
         coreEngineeringDirectiveReferenceText(),
+        engineeringSanityPolicyText(),
         'Load only the selected route skills and route-specific instructions; do not inject unrelated route policy.',
         'Codex native /goal is the only persisted goal owner. Goal persistence must not replace or skip the selected route gates.',
         `When a mission exists, read ${REQUEST_INTAKE_ARTIFACT} as a structured projection of the current request. Preserve the literal request and current code as authority; never let generic intake heuristics replace an explicit requirement.`,
@@ -622,6 +686,7 @@ export function dfixQuickContext(prompt, route = routePrompt(prompt)) {
     return [
         `DFix ultralight pipeline active. Route: ${routeLabel} (Direct Fix: tiny copy/config/docs/labels/spacing/translation/simple mechanical edits).`,
         responseLanguageInstruction(task),
+        engineeringSanityPolicyText(),
         'Bypass: do not enter the general SKS prompt pipeline, mission creation, ambiguity gate, TriWiki refresh, Context7 routing, native-session orchestration, Goal, Research, eval, or broad planning.',
         `Task: ${task}`,
         'Task list:',
@@ -702,6 +767,20 @@ export async function prepareRoute(root, prompt, state = {}, opts = {}) {
         return finish(await prepareImageUxReview(root, route, task, required, { sessionKey }));
     if (route.id === 'MadSKS')
         return finish(await prepareMadSksSqlPlane(root, route, task, required, { sessionKey }));
+    if (route.id === 'DB' && madSksAuthorization) {
+        const madRouteBase = routePrompt('$MAD-SKS');
+        if (!madRouteBase)
+            throw new Error('mad_sks_route_missing');
+        const madRoute = {
+            ...madRouteBase,
+            requiredSkills: Array.from(new Set([
+                ...(route.requiredSkills || []),
+                ...(madRouteBase.requiredSkills || [])
+            ]))
+        };
+        const prepared = await prepareMadSksSqlPlane(root, madRoute, task, routeNeedsContext7(madRoute, cleanPrompt), { sessionKey });
+        return withSkillDreamContext(prepared, dreamContext);
+    }
     if (QUESTION_GATE_ROUTES.has(route.id))
         return finish(await prepareClarificationGate(root, route, task, required, { madSksAuthorization, sessionKey }));
     if (route.id === 'Naruto' && subagentsRequired)
@@ -857,8 +936,7 @@ async function prepareImageUxReview(root, route, task, required, opts = {}) {
         stop_gate: route.stopGate,
         image_ux_review_gate_ready: true,
         image_ux_review_policy_ready: true,
-        pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
-        pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
+        ...pipelinePlanState(pipelinePlan)
     }), { sessionKey: opts.sessionKey });
     return routeContext(route, id, task, required, `Capture or attach source UI screenshots, run Codex App $imagegen/gpt-image-2 to generate annotated review images, extract those generated images into ${IMAGE_UX_REVIEW_ISSUE_LEDGER_ARTIFACT}, then update ${IMAGE_UX_REVIEW_GATE_ARTIFACT}. ${CODEX_IMAGEGEN_REQUIRED_POLICY} Initial gate blockers: ${(artifacts.gate.blockers || []).join(', ') || 'none'}.`);
 }
@@ -962,8 +1040,7 @@ async function prepareClarificationGate(root, route, task, required, opts = {})
             clarification_passed: result.ok,
             ambiguity_gate_required: true,
             ambiguity_gate_passed: result.ok,
-            pipeline_plan_ready: validatePipelinePlan(plan).ok,
-            pipeline_plan_path: PIPELINE_PLAN_ARTIFACT,
+            ...pipelinePlanState(plan),
             original_stop_gate: route.stopGate,
             stop_gate: route.stopGate,
             ...(materialized.state || {})
@@ -1108,7 +1185,7 @@ async function prepareResearch(root, route, task, required, opts = {}) {
     const { id, dir } = await createMission(root, { mode: 'research', prompt: task, sessionKey: opts.sessionKey });
     const researchPlan = await writeResearchPlan(dir, task, {});
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'direct_route' } });
-    await setCurrent(root, routeState(id, route, 'RESEARCH_PREPARED', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }), { sessionKey: opts.sessionKey });
+    await setCurrent(root, routeState(id, route, 'RESEARCH_PREPARED', required, { prompt: task, ...pipelinePlanState(pipelinePlan) }), { sessionKey: opts.sessionKey });
     return routeContext(route, id, task, required, `Run sks research run latest as a real long-running source-gathering pass, never an automatic mock fallback; do not modify repository source code. Run layered Super Search first and allow only correlated verified-content rows to support real claims. Then run exactly three independent official research_reviewer threads on GPT-5.6 Sol Max. Any objection requires a mission-local research_synthesizer revision and a fresh three-thread review cycle; do not launch a custom scheduler or debate pool. Keep subagent-plan.json, subagent-events.jsonl, subagent-parent-summary.json, and subagent-evidence.json current, write research-report.md and ${researchPaperArtifactForPlan(researchPlan)}, and pass the adversarial convergence, Honest Mode, and research-gate.json checks.`);
 }
 async function prepareAutoResearch(root, route, task, required, opts = {}) {
@@ -1117,21 +1194,35 @@ async function prepareAutoResearch(root, route, task, required, opts = {}) {
     await writeJsonAtomic(path.join(dir, 'experiment-ledger.json'), { schema_version: 1, entries: [] });
     await writeJsonAtomic(path.join(dir, 'autoresearch-gate.json'), { passed: false, experiment_ledger_present: true, metric_present: false, keep_or_discard_decision: false, falsification_present: false, honest_conclusion: false, context7_evidence: false });
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'direct_route' } });
-    await setCurrent(root, routeState(id, route, 'AUTORESEARCH_EXPERIMENT_LOOP', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }), { sessionKey: opts.sessionKey });
+    await setCurrent(root, routeState(id, route, 'AUTORESEARCH_EXPERIMENT_LOOP', required, { prompt: task, ...pipelinePlanState(pipelinePlan) }), { sessionKey: opts.sessionKey });
     return routeContext(route, id, task, required, 'Run the smallest useful experiment loop, update experiment-ledger.json, falsify the result, and pass autoresearch-gate.json.');
 }
 async function prepareDb(root, route, task, required, opts = {}) {
     const { id, dir } = await createMission(root, { mode: 'db', prompt: task, sessionKey: opts.sessionKey });
-    const scan = await scanDbSafety(root).catch((err) => ({ ok: false, findings: [{ id: 'db_scan_failed', severity: 'high', reason: err.message }] }));
+    const [scan, accessCandidates] = await Promise.all([
+        scanDbSafety(root, { includeMigrations: true }).catch((err) => ({ ok: false, findings: [{ id: 'db_scan_failed', severity: 'high', reason: err.message }] })),
+        scanDbAccessCandidates(root)
+    ]);
     await writeJsonAtomic(path.join(dir, 'db-safety-scan.json'), scan);
-    await writeJsonAtomic(path.join(dir, 'db-review.json'), { passed: false, scan_ok: scan.ok, destructive_operation_zero: true, safe_mcp_policy: false, context7_evidence: false, notes: [] });
+    await writeJsonAtomic(path.join(dir, DB_ACCESS_CANDIDATES_ARTIFACT), accessCandidates);
+    await writeJsonAtomic(path.join(dir, DB_REVIEW_ARTIFACT), createDbReviewSeed(scan.ok));
+    await writeJsonAtomic(path.join(dir, DB_ACCESS_REVIEW_ARTIFACT), createDbAccessReviewSeed(accessCandidates));
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'direct_route' } });
-    await setCurrent(root, routeState(id, route, 'DB_REVIEW_REQUIRED', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }), { sessionKey: opts.sessionKey });
-    return routeContext(route, id, task, required, 'Inspect the automatically materialized db-safety-scan.json, keep database operations read-only, record safe MCP and current-docs evidence, and pass db-review.json. Explicitly authorized SQL-plane work uses sks mad-sks.');
+    await setCurrent(root, routeState(id, route, 'DB_REVIEW_REQUIRED', required, {
+        prompt: task,
+        db_access_review_required: true,
+        ...pipelinePlanState(pipelinePlan)
+    }), { sessionKey: opts.sessionKey });
+    return routeContext(route, id, task, required, `Inspect the real DB entry points and callers first, then complete ${DB_ACCESS_REVIEW_ARTIFACT} for canonical adapter/query-helper reuse, pool ownership/acquire/release/shutdown/exhaustion, N+1/repeated I/O, and sensitive transaction integrity. Outside MAD-SKS, do not mutate any database: when a migration is required, finish with exactly one mission-local ${DB_MANUAL_MIGRATION_ARTIFACT} containing active forward SQL and a complete rollback section that remains commented out, record its SHA-256 and manual-apply notice in ${DB_REVIEW_ARTIFACT}, and tell the user to apply it directly. Only an active capability-v2 MAD-SKS SQL-plane may execute through MCP, with independent read-back and final read-only restoration.`);
 }
 async function prepareMadSksSqlPlane(root, route, task, required, opts = {}) {
     const prepared = await prepareMadSksSqlPlaneMission({ root, task, verifyTools: false, sessionKey: opts.sessionKey, route: 'MadSKS', routeCommand: '$MAD-SKS' });
     const dir = missionDir(root, prepared.mission_id);
+    const accessCandidates = await scanDbAccessCandidates(root);
+    await writeJsonAtomic(path.join(dir, DB_ACCESS_CANDIDATES_ARTIFACT), accessCandidates);
+    if (!(await exists(path.join(dir, DB_ACCESS_REVIEW_ARTIFACT)))) {
+        await writeJsonAtomic(path.join(dir, DB_ACCESS_REVIEW_ARTIFACT), createDbAccessReviewSeed(accessCandidates));
+    }
     const pipelinePlan = await writePipelinePlan(dir, {
         missionId: prepared.mission_id,
         route,
@@ -1159,24 +1250,24 @@ async function prepareMadSksSqlPlane(root, route, task, required, opts = {}) {
         mad_sks_sql_plane_capability_mission_id: prepared.mission_id,
         mad_sks_sql_plane_capability_file: madSksSqlPlaneRelativePath(MAD_SKS_SQL_PLANE_CAPABILITY_FILE),
         mad_sks_gate_file: 'mad-sks-gate.json',
+        db_access_review_required: true,
         stop_gate: 'mad-sks-gate.json',
-        pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
-        pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
+        ...pipelinePlanState(pipelinePlan)
     }), { sessionKey: opts.sessionKey });
-    return routeContext(route, prepared.mission_id, task, required, `MAD-SKS SQL-plane mission/capability/profile were created atomically for cycle ${prepared.cycle_id}. Verify Supabase MCP tool inventory exposes execute_sql and apply_migration before claiming ready; after execution require read-back proof, finally close the profile/capability and prove read-only restoration.`);
+    return routeContext(route, prepared.mission_id, task, required, `MAD-SKS SQL-plane mission/capability/profile were created atomically for cycle ${prepared.cycle_id}. Inspect the existing canonical DB access and complete ${DB_ACCESS_REVIEW_ARTIFACT} before mutation. Then verify Supabase MCP tool inventory exposes execute_sql and apply_migration, execute the requested SQL immediately through the bound MCP SQL-plane rather than generating a manual migration file, independently read back the postconditions, and finally close the profile/capability and prove normal read-only restoration.`);
 }
 async function prepareGx(root, route, task, required, opts = {}) {
     const { id, dir } = await createMission(root, { mode: 'gx', prompt: task, sessionKey: opts.sessionKey });
     await writeJsonAtomic(path.join(dir, 'gx-gate.json'), { passed: false, vgraph_beta_render: false, validation: false, drift_snapshot: false, context7_evidence: false });
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'direct_route' } });
-    await setCurrent(root, routeState(id, route, 'GX_VALIDATE_REQUIRED', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }), { sessionKey: opts.sessionKey });
+    await setCurrent(root, routeState(id, route, 'GX_VALIDATE_REQUIRED', required, { prompt: task, ...pipelinePlanState(pipelinePlan) }), { sessionKey: opts.sessionKey });
     return routeContext(route, id, task, required, 'Run sks gx init/render/validate/drift/snapshot, then pass gx-gate.json.');
 }
 async function prepareLightRoute(root, route, task, required, opts = {}) {
     const { id, dir } = await createMission(root, { mode: route.id.toLowerCase(), prompt: task, sessionKey: opts.sessionKey });
     await writeJsonAtomic(path.join(dir, 'route-context.json'), { route: route.id, command: route.command, task, required_skills: route.requiredSkills, context7_required: required, context_tracking: triwikiContextTracking(), stop_gate: 'honest_mode' });
     const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'light_route' } });
-    await setCurrent(root, routeState(id, route, 'ROUTE_CONTEXT_READY', required, { prompt: task, stop_gate: 'none', pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }), { sessionKey: opts.sessionKey });
+    await setCurrent(root, routeState(id, route, 'ROUTE_CONTEXT_READY', required, { prompt: task, stop_gate: 'none', ...pipelinePlanState(pipelinePlan) }), { sessionKey: opts.sessionKey });
     return routeContext(route, id, task, required, 'Load the route skill context, execute the smallest matching action, and finish with Honest Mode.');
 }
 async function materializeOfficialSubagentOverlay(root, prepared, route, task, opts = {}) {
@@ -1339,8 +1430,7 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
         parent_model_match: parentModelMatch,
         from_chat_img_required: fromChatImgRequired,
         naruto_gate_file: NARUTO_GATE_FILENAME,
-        pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
-        pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
+        ...pipelinePlanState(pipelinePlan)
     }), { sessionKey: opts.sessionKey });
     return routeContext(route, id, cleanTask, required, `Use the delegation context below in the current Codex parent session. First replace parent_required with a defensible independent/disjoint decomposition, then spawn and wait for every requested agent thread. Record official events and integrate the parent summary before passing ${NARUTO_GATE_FILENAME}.\n\n${delegationPrompt}`);
 }
@@ -1355,7 +1445,15 @@ function requestedSubagentsFromTask(task) {
 function routeState(id, route, phase, context7Required, extra = {}) {
     const reasoning = routeReasoning(route, extra.prompt || '');
     const subagentsRequired = routeRequiresSubagents(route, extra.prompt || '');
-    return { mission_id: id, route: route.id, route_command: route.command, mode: route.mode, phase, context7_required: context7Required, context7_verified: false, subagents_required: subagentsRequired, subagents_verified: !subagentsRequired, native_sessions_required: false, native_sessions_verified: false, reflection_required: reflectionRequiredForRoute(route), visible_progress_required: true, context_tracking: 'triwiki', required_skills: route.requiredSkills, stop_gate: route.stopGate, reasoning_effort: reasoning.effort, reasoning_profile: reasoning.profile, reasoning_temporary: true, goal_continuation: ambientGoalContinuation(), ...extra };
+    return { mission_id: id, route: route.id, route_command: route.command, mode: route.mode, phase, context7_required: context7Required, context7_verified: false, subagents_required: subagentsRequired, subagents_verified: !subagentsRequired, native_sessions_required: false, native_sessions_verified: false, reflection_required: reflectionRequiredForRoute(route), engineering_sanity_required: false, engineering_sanity_scope_base: null, visible_progress_required: true, context_tracking: 'triwiki', required_skills: route.requiredSkills, stop_gate: route.stopGate, reasoning_effort: reasoning.effort, reasoning_profile: reasoning.profile, reasoning_temporary: true, goal_continuation: ambientGoalContinuation(), ...extra };
+}
+function routeNeedsEngineeringSanityReview(route, task) {
+    const id = String(route?.id || '');
+    if (['DB', 'MadSKS'].includes(id))
+        return true;
+    if (['Answer', 'Help', 'Wiki', 'Goal', 'Research', 'AutoResearch', 'PPT', 'ImageUXReview', 'ComputerUse', 'GX'].includes(id))
+        return false;
+    return looksLikeCodeChangingWork(String(task || ''));
 }
 function routeContext(route, id, task, required, next) {
     const visibleTask = stripVisibleDecisionAnswerBlocks(task);

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

@@ -1,5 +1,6 @@
 import path from 'node:path';
-import { appendJsonl, exists, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import fsp from 'node:fs/promises';
+import { appendJsonl, exists, nowIso, readJson, readText, sha256, writeJsonAtomic } from '../fsx.js';
 import { containsUserQuestion, noQuestionContinuationReason } from '../no-question-guard.js';
 import { missionDir, setCurrent } from '../mission.js';
 import { evaluateResearchGate } from '../research.js';
@@ -14,7 +15,9 @@ import { MISTAKE_RECALL_ARTIFACT, mistakeRecallGateStatus } from '../mistake-rec
 import { SSOT_GUARD_ARTIFACT, validateSsotGuardArtifact } from '../safety/ssot-guard.js';
 import { checkStopGate } from '../stop-gate/stop-gate-check.js';
 import { readWorkOrderLedger, evaluateWorkOrderCoverage } from '../work-order-ledger.js';
-import { clarificationStopReason, context7Evidence, hasContext7DocsEvidence, hasSubagentEvidence, subagentEvidence, } from './runtime-core.js';
+import { DB_ACCESS_REVIEW_ARTIFACT, DB_REVIEW_ARTIFACT, validateDbAccessReviewArtifact, validateDbReview, validateMadSksSqlPlaneCompletion } from '../db-review.js';
+import { ENGINEERING_SANITY_REVIEW_ARTIFACT, validateEngineeringSanityReviewArtifact } from '../engineering-sanity-review.js';
+import { clarificationStopReason, context7Evidence, hasContext7DocsEvidence, hasSubagentEvidence, subagentEvidence, PIPELINE_PLAN_ARTIFACT, } from './runtime-core.js';
 import { projectTriwikiToAgentsMd } from '../triwiki/agents-md-projector.js';
 import { effectiveSubagentTarget, normalizeLegacySubagentCountFields, subagentCountContractBlockers } from '../subagents/wave-lifecycle.js';
 const REFLECTION_ARTIFACT = 'reflection.md';
@@ -85,6 +88,33 @@ async function workOrderCoverageGateStatus(root, state = {}) {
     const coverage = evaluateWorkOrderCoverage(ledger);
     return { ok: coverage.ok, blockers: coverage.blockers };
 }
+async function dbAccessReviewGateStatus(root, state = {}, jsonCache) {
+    if (state?.db_access_review_required !== true)
+        return { ok: true, blockers: [] };
+    const id = state?.mission_id;
+    if (!id)
+        return { ok: false, blockers: ['mission_id'] };
+    const review = await readJsonCached(jsonCache, path.join(missionDir(root, id), DB_ACCESS_REVIEW_ARTIFACT), null);
+    return validateDbAccessReviewArtifact(root, id, review);
+}
+async function engineeringSanityGateStatus(root, state = {}, jsonCache) {
+    if (state?.engineering_sanity_required !== true)
+        return { ok: true, blockers: [] };
+    const id = state?.mission_id;
+    if (!id)
+        return { ok: false, blockers: ['mission_id'] };
+    const dir = missionDir(root, id);
+    const reviewFile = path.join(dir, ENGINEERING_SANITY_REVIEW_ARTIFACT);
+    if (!(await exists(reviewFile))) {
+        const plan = await readJsonCached(jsonCache, path.join(dir, PIPELINE_PLAN_ARTIFACT), null);
+        if (!plan?.engineering_sanity_review)
+            return { ok: true, blockers: [], not_applicable: true };
+    }
+    const review = await readJsonCached(jsonCache, reviewFile, null);
+    return validateEngineeringSanityReviewArtifact(root, id, review, {
+        base: typeof state?.engineering_sanity_scope_base === 'string' ? state.engineering_sanity_scope_base : null
+    });
+}
 async function staleReflectionReasons(root, state = {}, gate = {}) {
     const created = Date.parse(gate.created_at || gate.updated_at || '');
     if (!Number.isFinite(created))
@@ -119,6 +149,24 @@ export async function projectGateStatus(root, state = {}) {
             source: id ? `.sneakoscope/missions/${id}/questions.md` : null
         });
     }
+    if (state?.db_access_review_required === true) {
+        const dbAccess = await dbAccessReviewGateStatus(root, state);
+        gates.push({
+            id: DB_ACCESS_REVIEW_ARTIFACT,
+            ok: dbAccess.ok,
+            missing: dbAccess.blockers || [],
+            source: id ? `.sneakoscope/missions/${id}/${DB_ACCESS_REVIEW_ARTIFACT}` : null
+        });
+    }
+    if (state?.engineering_sanity_required === true) {
+        const sanity = await engineeringSanityGateStatus(root, state);
+        gates.push({
+            id: ENGINEERING_SANITY_REVIEW_ARTIFACT,
+            ok: sanity.ok,
+            missing: sanity.blockers || [],
+            source: id ? `.sneakoscope/missions/${id}/${ENGINEERING_SANITY_REVIEW_ARTIFACT}` : null
+        });
+    }
     if (state?.context7_required) {
         const evidence = await context7Evidence(root, state);
         gates.push({
@@ -200,21 +248,44 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     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) {
+    if (!opts.noQuestion
+        && (stopGate === 'none' || stopGate === 'honest_mode')
+        && !state?.context7_required
+        && !state?.subagents_required
+        && !completionProofRequired
+        && !reflectionRequired
+        && state?.engineering_sanity_required !== true
+        && state?.db_access_review_required !== true) {
         return null;
     }
     const activeGatePreview = state?.subagents_required
         ? await passedActiveGate(root, state, jsonCache)
         : null;
     const activeGateNotApplicable = activeGatePreview?.not_applicable === true;
+    const dbAccessPromise = dbAccessReviewGateStatus(root, state, jsonCache);
+    const engineeringSanityPromise = engineeringSanityGateStatus(root, state, jsonCache);
     const context7Promise = state?.context7_required ? hasContext7DocsEvidence(root, state) : Promise.resolve(true);
     const subagentPromise = state?.subagents_required && !activeGateNotApplicable ? hasSubagentEvidence(root, state) : Promise.resolve(true);
     const mistakeRecallPromise = mistakeRecallGateStatus(root, state);
-    const [context7Ok, subagentOk, mistakeRecall] = await Promise.all([
+    const [dbAccess, engineeringSanity, context7Ok, subagentOk, mistakeRecall] = await Promise.all([
+        dbAccessPromise,
+        engineeringSanityPromise,
         context7Promise,
         subagentPromise,
         mistakeRecallPromise
     ]);
+    await resolveRecoveredComplianceBlocker(root, state, {
+        [DB_ACCESS_REVIEW_ARTIFACT]: dbAccess.ok,
+        [ENGINEERING_SANITY_REVIEW_ARTIFACT]: engineeringSanity.ok,
+        'context7-evidence': context7Ok,
+        'official-subagent-evidence': subagentOk
+    });
+    if (!dbAccess.ok) {
+        return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} must verify the existing canonical DB access path before completion. Complete ${DB_ACCESS_REVIEW_ARTIFACT} with actual entry points/callers, canonical adapter or query helper, pool ownership/acquire/release/shutdown/exhaustion evidence, N+1 review, and transaction integrity for sensitive or multi-step mutations. Missing: ${(dbAccess.blockers || []).join(', ')}.`, { gate: DB_ACCESS_REVIEW_ARTIFACT, missing: dbAccess.blockers });
+    }
+    if (!engineeringSanity.ok) {
+        return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} must complete the engineering sanity review before completion. Static candidates are advisory only; inspect added hunks and real callers for SOLID boundaries, N+1/repeated I/O, bounded render/recursion/event/retry/polling behavior, and verification bypasses. Missing: ${(engineeringSanity.blockers || []).join(', ')}.`, { gate: ENGINEERING_SANITY_REVIEW_ARTIFACT, missing: engineeringSanity.blockers });
+    }
     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, so SKS can record context7-evidence.jsonl.`, { gate: 'context7-evidence' });
     }
@@ -458,6 +529,95 @@ function normalizeComplianceReason(reason = '') {
         .trim()
         .slice(0, 1200);
 }
+async function resolveRecoveredComplianceBlocker(root, state = {}, recovered) {
+    if (!state?.mission_id)
+        return false;
+    const dir = missionDir(root, state.mission_id);
+    const blockerFile = path.join(dir, HARD_BLOCKER_ARTIFACT);
+    const guardFile = path.join(dir, COMPLIANCE_LOOP_GUARD_ARTIFACT);
+    const [blockerText, guardText] = await Promise.all([
+        readText(blockerFile, ''),
+        readText(guardFile, '')
+    ]);
+    if (!blockerText || !guardText)
+        return false;
+    let blocker;
+    let guard;
+    try {
+        blocker = JSON.parse(blockerText);
+        guard = JSON.parse(guardText);
+    }
+    catch {
+        return false;
+    }
+    const gate = String(blocker?.gate || guard?.gate || '');
+    if (blocker?.schema !== 'sks.hard-blocker.v1'
+        || blocker?.status !== 'hard_blocked'
+        || blocker?.reason !== 'compliance_loop_guard_tripped'
+        || guard?.schema_version !== 1
+        || guard?.mission_id !== state.mission_id
+        || guard?.tripped !== true
+        || guard?.gate !== gate
+        || recovered[gate] !== true)
+        return false;
+    const artifactName = gate === 'context7-evidence'
+        ? 'context7-evidence.jsonl'
+        : gate === 'official-subagent-evidence'
+            ? 'subagent-evidence.json'
+            : gate;
+    if (!artifactName || path.isAbsolute(artifactName) || artifactName.includes('..'))
+        return false;
+    const artifactFile = path.join(dir, artifactName);
+    const artifactStat = await fsp.stat(artifactFile).catch(() => null);
+    const blockerAt = Date.parse(String(blocker.created_at || ''));
+    const guardAt = Date.parse(String(guard.updated_at || ''));
+    if (!artifactStat?.isFile()
+        || !Number.isFinite(blockerAt)
+        || !Number.isFinite(guardAt)
+        || artifactStat.mtimeMs <= Math.max(blockerAt, guardAt))
+        return false;
+    const blockerSha256 = `sha256:${sha256(blockerText)}`;
+    const guardSha256 = `sha256:${sha256(guardText)}`;
+    await writeJsonAtomic(path.join(dir, 'hard-blocker.resolved.json'), {
+        schema: 'sks.hard-blocker-resolution.v1',
+        status: 'resolved',
+        passed: true,
+        mission_id: state.mission_id,
+        resolved_at: nowIso(),
+        resolution_reason: `newer_${gate}_evidence_resolved_compliance_loop`,
+        hard_blocker_sha256: blockerSha256,
+        compliance_loop_guard_sha256: guardSha256,
+        recovery_artifact: artifactName,
+        recovery_artifact_mtime: artifactStat.mtime.toISOString(),
+        original_hard_blocker: blocker,
+        original_compliance_loop_guard: guard
+    });
+    const [currentBlockerText, currentGuardText] = await Promise.all([
+        readText(blockerFile, ''),
+        readText(guardFile, '')
+    ]);
+    if (currentBlockerText !== blockerText || currentGuardText !== guardText)
+        return false;
+    await Promise.all([
+        fsp.unlink(blockerFile).catch((err) => {
+            if (err?.code !== 'ENOENT')
+                throw err;
+        }),
+        fsp.unlink(guardFile).catch((err) => {
+            if (err?.code !== 'ENOENT')
+                throw err;
+        })
+    ]);
+    await appendJsonl(path.join(dir, 'events.jsonl'), {
+        ts: nowIso(),
+        type: 'pipeline.compliance_loop_guard.resolved',
+        gate,
+        recovery_artifact: artifactName,
+        hard_blocker_sha256: blockerSha256,
+        compliance_loop_guard_sha256: guardSha256
+    });
+    return true;
+}
 function readJsonCached(cache, file, fallback) {
     if (!cache)
         return readJson(file, fallback);
@@ -571,6 +731,35 @@ function missingRequiredGateFields(file, state, gate = {}) {
 }
 async function missingRequiredGateArtifacts(root, file, state, gate = {}) {
     const mode = String(state?.mode || '').toUpperCase();
+    if (file === DB_REVIEW_ARTIFACT || mode === 'DB') {
+        const evaluated = await validateDbReview(root, String(state.mission_id || ''), gate);
+        if (evaluated.ok)
+            return [];
+        return evaluated.blockers.map((reason) => `${DB_REVIEW_ARTIFACT}:${reason}`);
+    }
+    if (file === 'mad-sks-gate.json' || mode === 'MADSKS') {
+        const evaluated = await validateMadSksSqlPlaneCompletion(root, String(state.mission_id || ''), {
+            capability_schema: 'sks.mad-sks-sql-plane-capability.v2',
+            result_file: 'mad-sks/sql-plane/result.json',
+            cycle_id: gate?.cycle_id || gate?.sql_plane?.cycle_id || null,
+            read_back_passed: gate?.sql_plane?.read_back_passed === true,
+            capability_closed: gate?.sql_plane?.profile_closed === true,
+            read_only_restored: gate?.read_only_restoration?.ok === true
+        });
+        const missing = [];
+        if (gate?.permissions_deactivated !== true)
+            missing.push('permissions_deactivated');
+        if (gate?.mad_sks_permission_active !== false)
+            missing.push('mad_sks_permission_active_false');
+        if (gate?.sql_plane?.requested !== true)
+            missing.push('sql_plane_requested');
+        if (gate?.control_plane_denied !== true)
+            missing.push('control_plane_denied');
+        if (!Array.isArray(gate?.blockers) || gate.blockers.length > 0)
+            missing.push('blockers_empty');
+        missing.push(...evaluated.blockers);
+        return [...new Set(missing.map((reason) => `mad-sks-gate:${reason}`))];
+    }
     if (file === 'research-gate.json' || mode === 'RESEARCH') {
         const evaluated = await evaluateResearchGate(missionDir(root, state.mission_id));
         if (evaluated.passed === true)

package/dist/core/pipeline.js

@@ -1,4 +1,4 @@
-export { PIPELINE_PLAN_ARTIFACT, PIPELINE_PLAN_SCHEMA_VERSION, routePrompt, buildPipelinePlan, writePipelinePlan, validatePipelinePlan } from './pipeline/pipeline-plan-writer.js';
+export { PIPELINE_PLAN_ARTIFACT, PIPELINE_PLAN_SCHEMA_VERSION, routePrompt, buildPipelinePlan, writePipelinePlan, validatePipelinePlan, pipelinePlanState } from './pipeline/pipeline-plan-writer.js';
 export { promptPipelineContext, dfixQuickContext, answerOnlyContext, computerUseFastContext } from './pipeline/prompt-context.js';
 export { prepareRoute } from './pipeline/route-prep.js';
 export { activeRouteContext } from './pipeline/active-context.js';

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

@@ -4,6 +4,7 @@ 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';
+import { imagegenEvidenceClassBlockers, isFullImagegenEvidenceClass, isFullImagegenOutputSource } from '../imagegen/imagegen-evidence.js';
 export const PPT_SLIDE_CALLOUT_LEDGER_ARTIFACT = 'ppt-slide-callout-ledger.json';
 export const PPT_SLIDE_IMAGEGEN_REQUEST_ARTIFACT = 'ppt-slide-imagegen-request.json';
 export const PPT_SLIDE_IMAGEGEN_RESPONSE_ARTIFACT = 'ppt-slide-imagegen-response.json';
@@ -98,9 +99,8 @@ export async function generateSlideCalloutReviews({ root, dir, slideExportLedger
             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');
+            const codexGenerated = isFullImagegenEvidenceClass(evidenceClass);
+            blockers.push(...imagegenEvidenceClassBlockers('ppt_imagegen', evidenceClass));
             generatedReviewImages.push({
                 ...await generatedSlideMetadata(root, generated.generated_image_path, slide, {
                     mock: fakeGenerated,
@@ -189,9 +189,8 @@ export function buildSlideImagegenEvidence(calloutLedger = {}) {
         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(...imagegenEvidenceClassBlockers('ppt_slide_imagegen', evidenceClass));
+        if (!isFullImagegenOutputSource(outputSource))
             blockers.push(`ppt_slide_imagegen_output_source_invalid:${outputSource || 'missing'}`);
         if (!outputSha)
             blockers.push('ppt_slide_imagegen_output_sha256_missing');
@@ -249,7 +248,8 @@ async function generatedSlideMetadata(root, relPath, slide, opts = {}) {
         height: dims.height,
         format: dims.format,
         provider_surface: opts.mock ? 'mock_fixture' : (opts.providerSurface || 'Codex App $imagegen'),
-        real_generated: opts.realGenerated === true && (opts.evidenceClass || (opts.mock ? 'mock_fixture' : 'codex_app_imagegen')) === 'codex_app_imagegen',
+        real_generated: opts.realGenerated === true
+            && isFullImagegenEvidenceClass(opts.evidenceClass || (opts.mock ? 'mock_fixture' : 'codex_app_imagegen')),
         mock: opts.mock === true,
         local_only: true
     };