sneakoscope 4.8.7 → 5.1.2

package/dist/core/feature-fixture-runner.js

@@ -181,7 +181,7 @@ function inspectExpectedArtifact(root, tempRoot, artifact, ctx = {}) {
         return { ...result, failure: 'json_parse' };
     }
     if (schema === 'sks.completion-proof.v1')
-        return { ...result, schema_ok: parsed.schema === schema, content_ok: ['verified', 'verified_partial', 'blocked'].includes(parsed.status), status: parsed.status };
+        return { ...result, schema_ok: parsed.schema === schema, content_ok: ['verified', 'verified_partial', 'mock_only', 'blocked'].includes(parsed.status), status: parsed.status };
     if (schema === 'sks.image-voxel-ledger.v1') {
         const anchorCount = Array.isArray(parsed.anchors) ? parsed.anchors.length : 0;
         const relationCount = Array.isArray(parsed.relations) ? parsed.relations.length : 0;
@@ -241,7 +241,7 @@ function renderFeatureFixtureMarkdown(report = {}) {
 }
 export function validateCompletionProofArtifact(file) {
     const proof = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return proof.schema === 'sks.completion-proof.v1' && ['verified', 'verified_partial', 'blocked'].includes(proof.status);
+    return proof.schema === 'sks.completion-proof.v1' && ['verified', 'verified_partial', 'mock_only', 'blocked'].includes(proof.status);
 }
 export function validateImageVoxelArtifact(file, { requireAnchors = true, requireRelations = false } = {}) {
     const ledger = JSON.parse(fs.readFileSync(file, 'utf8'));

package/dist/core/feature-fixtures.js

@@ -2,7 +2,7 @@ import { PACKAGE_VERSION } from './fsx.js';
 export const FEATURE_FIXTURE_SCHEMA = 'sks.feature-fixtures.v1';
 export const FEATURE_QUALITY_LEVELS = Object.freeze([
     'runtime_verified',
-    'runtime_mock_verified',
+    'wiring_only',
     'integration_optional',
     'static_contract',
     'missing'
@@ -12,21 +12,31 @@ const FIXTURES = Object.freeze({
     'cli-version': fixture('execute', 'sks --version', [], 'pass'),
     'cli-root': fixture('execute', 'sks root --json', [], 'pass'),
     'cli-doctor': fixture('real_optional', 'sks doctor --json', [], 'pass'),
+    'doctor:imagegen-repair': fixture('execute_and_validate_artifacts', 'sks doctor --json', [{ path: '.sneakoscope/reports/feature-fixtures/doctor-imagegen-repair.json', schema: 'sks.doctor-imagegen-repair.v1', optional: true }], 'pass', {
+        quality: 'runtime_verified',
+        validates_json_fields: ['imagegen_repair', 'repair.imagegen']
+    }),
     'cli-paths': fixture('execute_and_validate_artifacts', 'sks paths managed --json', ['.sneakoscope/managed-paths.json'], 'pass'),
     'cli-rollback': fixture('execute', 'sks rollback list --json', [], 'pass'),
     'cli-setup': fixture('real_optional', 'sks setup --json --local-only', [], 'pass'),
     'cli-codex': fixture('execute', 'sks codex compatibility --json', [], 'pass'),
     'cli-codex-app': fixture('real_optional', 'sks codex-app check --json', [], 'pass'),
     'cli-codex-lb': fixture('execute_and_validate_artifacts', 'sks codex-lb metrics --json', [], 'pass'),
-    'cli-hooks': fixture('mock', 'sks hooks trust-report --json', [], 'pass'),
+    'cli-hooks': fixture('execute', 'sks hooks trust-report --json', [], 'pass'),
     'cli-features': fixture('execute', 'sks features check --json', [], 'pass'),
     'cli-commands': fixture('execute', 'sks commands --json', [], 'pass'),
     'cli-check': fixture('execute', 'sks check --tier confidence --sla 5m --plan --json', [], 'pass'),
+    'cli-plan': fixture('execute', 'sks plan "fixture" --json', [], 'pass'),
+    'cli-review': fixture('execute', 'sks review --diff HEAD --json', [], 'pass'),
+    'cli-ui': fixture('static', 'sks ui [--port 4477] [--mission latest] [--once] [--json]', [], 'pass', {
+        quality: 'static_contract',
+        reason: 'UI command opens a localhost dashboard; release fixture tracks the CLI contract without launching a server.'
+    }),
     'cli-run': fixture('execute_and_validate_artifacts', 'sks run "fixture" --mock --json', ['run-classification.json', 'completion-proof.json', 'evidence-index.json', 'route-completion-contract.json', 'trust-report.json'], 'pass'),
     'cli-status': fixture('execute', 'sks status --json', [], 'pass'),
     'cli-usage': fixture('execute', 'sks usage overview', [], 'pass'),
     'cli-quickstart': fixture('execute', 'sks quickstart', [], 'pass'),
-    'cli-update': fixture('mock', 'sks update now --dry-run --json', [], 'pass'),
+    'cli-update': fixture('execute', 'sks update now --dry-run --json', [], 'pass'),
     'cli-update-check': fixture('static', 'sks update-check --json', [], 'pass'),
     'cli-guard': fixture('execute', 'sks guard check --json', [], 'pass'),
     'cli-conflicts': fixture('execute', 'sks conflicts check --json', [], 'pass'),
@@ -35,20 +45,21 @@ const FIXTURES = Object.freeze({
     'cli-fix-path': fixture('execute', 'sks fix-path --json', [], 'pass'),
     'cli-selftest': fixture('execute', 'sks selftest --mock', [], 'pass'),
     'cli-git': fixture('execute', 'sks git policy --json', [], 'pass'),
-    'cli-goal': fixture('mock', 'sks goal status latest --json', ['goal-workflow.json'], 'pass'),
+    'cli-uninstall': fixture('execute', 'sks uninstall --dry-run --json', [], 'pass'),
+    'cli-goal': fixture('execute_and_validate_artifacts', 'sks goal status latest --json', ['goal-workflow.json'], 'pass'),
     'cli-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode seo --json', ['search-visibility/site-inventory.json', 'search-visibility/seo-findings.json', 'search-visibility/verification-report.json', 'seo-gate.json', 'completion-proof.json'], 'pass'),
-    'cli-research': fixture('mock', 'sks research status latest --json', ['research-gate.json', 'completion-proof.json'], 'pass'),
-    'cli-qa-loop': fixture('mock', 'sks qa-loop status latest --json', ['qa-loop-proof.json', 'completion-proof.json'], 'pass'),
-    'cli-ppt': fixture('mock', 'sks ppt fixture --mock --json', ['ppt-imagegen-review-gate.json', 'completion-proof.json'], 'pass'),
-    'cli-image-ux-review': fixture('mock', 'sks image-ux-review status latest --json', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
+    'cli-research': fixture('execute_and_validate_artifacts', 'sks research status latest --json', ['research-gate.json', 'completion-proof.json'], 'pass'),
+    'cli-qa-loop': fixture('execute_and_validate_artifacts', 'sks qa-loop status latest --json', ['qa-loop-proof.json', 'completion-proof.json'], 'pass'),
+    'cli-ppt': fixture('execute_and_validate_artifacts', 'sks ppt fixture --mock --json', ['ppt-imagegen-review-gate.json', 'completion-proof.json'], 'pass'),
+    'cli-image-ux-review': fixture('execute_and_validate_artifacts', 'sks image-ux-review status latest --json', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
     'cli-computer-use': fixture('real_optional', 'sks computer-use status --json', [], 'pass'),
-    'cli-pipeline': fixture('mock', 'sks pipeline status latest --json', ['pipeline-plan.json'], 'pass'),
-    'cli-validate-artifacts': fixture('mock', 'sks validate-artifacts latest --json', ['validation-report.json'], 'pass'),
-    'cli-hproof': fixture('mock', 'sks hproof check latest', ['completion-proof.json'], 'pass'),
+    'cli-pipeline': fixture('execute_and_validate_artifacts', 'sks pipeline status latest --json', ['pipeline-plan.json'], 'pass'),
+    'cli-validate-artifacts': fixture('execute_and_validate_artifacts', 'sks validate-artifacts latest --json', ['validation-report.json'], 'pass'),
+    'cli-hproof': fixture('execute_and_validate_artifacts', 'sks hproof check latest', ['completion-proof.json'], 'pass'),
     'cli-proof-field': fixture('execute', 'sks proof-field scan --json --intent fixture', [], 'pass'),
-    'cli-recallpulse': fixture('mock', 'sks recallpulse status latest --json', ['recallpulse-report.json'], 'pass'),
+    'cli-recallpulse': fixture('execute_and_validate_artifacts', 'sks recallpulse status latest --json', ['recallpulse-report.json'], 'pass'),
     'cli-agent': fixture('execute_and_validate_artifacts', 'sks agent run fixture --mock --json', ['agents/agent-central-ledger.json', 'agents/agent-task-board.json', 'agents/agent-leases.json', 'agents/agent-no-overlap-proof.json', 'agents/agent-session-cleanup.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass'),
-    'cli-gx': fixture('mock', 'sks gx validate fixture', ['gx-validation.json'], 'pass'),
+    'cli-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture', ['gx-validation.json'], 'pass'),
     'cli-perf': fixture('execute', 'sks perf cold-start --json --iterations 1', [], 'pass'),
     'cli-bench': fixture('execute_and_validate_artifacts', 'sks bench core --tier npx-one-shot --json --iterations 1', ['.sneakoscope/reports/performance/core-bench.json'], 'pass'),
     'cli-code-structure': fixture('execute', 'sks code-structure scan --json', [], 'pass'),
@@ -63,16 +74,16 @@ const FIXTURES = Object.freeze({
     'cli-dfix': fixture('execute_and_validate_artifacts', 'sks dfix fixture --json', ['completion-proof.json', 'dfix-gate.json', 'dfix-verification.json'], 'pass'),
     'cli-wiki': fixture('execute_and_validate_artifacts', 'sks wiki image-ingest test/fixtures/images/one-by-one.png --json', [{ path: '.sneakoscope/wiki/image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1', require_anchors: false }], 'pass'),
     'cli-db': fixture('execute', 'sks db policy', [], 'pass'),
-    'cli-wizard': fixture('mock', 'sks wizard', [], 'pass'),
-    'cli-bootstrap': fixture('mock', 'sks bootstrap --dry-run', [], 'pass'),
-    'cli-deps': fixture('mock', 'sks deps check --json', [], 'pass'),
-    'cli-auth': fixture('mock', 'sks auth status --json', [], 'pass'),
-    'cli-codex-native': fixture('mock', 'sks codex-native status --json', [], 'pass'),
+    'cli-wizard': fixture('execute', 'sks wizard', [], 'pass'),
+    'cli-bootstrap': fixture('execute', 'sks bootstrap --dry-run', [], 'pass'),
+    'cli-deps': fixture('execute', 'sks deps check --json', [], 'pass'),
+    'cli-auth': fixture('execute', 'sks auth status --json', [], 'pass'),
+    'cli-codex-native': fixture('execute', 'sks codex-native status --json', [], 'pass'),
     'cli-zellij': fixture('mock', 'npm run zellij:capability --silent', [], 'pass'),
     'cli-tmux': fixture('mock', 'removed runtime migration notice: sks tmux --json', [], 'pass'),
-    'cli-mad': fixture('mock', 'sks mad --help', [], 'pass'),
+    'cli-mad': fixture('execute', 'sks mad --help', [], 'pass'),
     'cli-mad-sks': fixture('static', 'sks mad-sks status --json', [], 'pass'),
-    'cli-auto-review': fixture('mock', 'sks auto-review status --json', [], 'pass'),
+    'cli-auto-review': fixture('execute', 'sks auto-review status --json', [], 'pass'),
     'cli-commit': fixture('mock', 'sks commit --dry-run', [], 'pass'),
     'cli-commit-and-push': fixture('mock', 'sks commit-and-push --dry-run', [], 'pass'),
     'cli-context7': fixture('real_optional', 'sks context7 check --json', [], 'pass'),
@@ -80,29 +91,39 @@ const FIXTURES = Object.freeze({
     'cli-ultra-search': fixture('execute', 'sks ultra-search doctor --json', [], 'pass'),
     'cli-xai': fixture('real_optional', 'sks xai check --json', [], 'pass'),
     'cli-task': fixture('execute', 'sks task instant --plan --json', [], 'pass'),
-    'cli-release': fixture('mock', 'sks release affected --json', [], 'pass'),
+    'cli-release': fixture('execute', 'sks release affected --json', [], 'pass'),
     'cli-triwiki': fixture('execute', 'sks triwiki index --json', [], 'pass'),
     'cli-daemon': fixture('execute', 'sks daemon status --json', [], 'pass'),
-    'cli-all-features': fixture('mock', 'sks all-features complete --json', [`.sneakoscope/reports/all-feature-completion-${PACKAGE_VERSION}.json`], 'pass'),
-    'cli-init': fixture('mock', 'sks init --local-only --dry-run', [], 'pass'),
-    'cli-eval': fixture('mock', 'sks eval run --mock --json', [], 'pass'),
-    'cli-harness': fixture('mock', 'sks harness fixture --mock --json', [], 'pass'),
-    'cli-naruto': fixture('mock', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['completion-proof.json', 'naruto-gate.json'], 'pass'),
-    'cli-team': fixture('mock', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json'], 'pass'),
-    'cli-reasoning': fixture('mock', 'sks reasoning status --json', [], 'pass'),
-    'cli-profile': fixture('mock', 'sks profile status --json', [], 'pass'),
-    'skill-db-safety-guard': fixture('mock', 'sks db check --sql "SELECT 1" --json', ['db-operation-report.json', 'completion-proof.json'], 'pass'),
-    'skill-honest-mode': fixture('mock', 'sks proof smoke --json', ['completion-proof.json', 'trust-report.json'], 'pass'),
-    'skill-imagegen': fixture('mock', 'sks image-ux-review fixture --mock --json', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
-    'skill-gx-visual-validate': fixture('mock', 'sks gx validate fixture --mock --json', ['gx-validation.json'], 'pass'),
+    'cli-all-features': fixture('execute_and_validate_artifacts', 'sks all-features complete --json', [`.sneakoscope/reports/all-feature-completion-${PACKAGE_VERSION}.json`], 'pass'),
+    'cli-init': fixture('execute', 'sks init --local-only --dry-run', [], 'pass'),
+    'cli-eval': fixture('execute', 'sks eval run --mock --json', [], 'pass'),
+    'cli-harness': fixture('execute', 'sks harness fixture --mock --json', [], 'pass'),
+    'cli-naruto': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['completion-proof.json', 'naruto-gate.json'], 'pass'),
+    'cli-team': fixture('execute_and_validate_artifacts', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json'], 'pass'),
+    'cli-reasoning': fixture('execute', 'sks reasoning status --json', [], 'pass'),
+    'cli-profile': fixture('execute', 'sks profile status --json', [], 'pass'),
+    'skill-db-safety-guard': fixture('execute_and_validate_artifacts', 'sks db check --sql "SELECT 1" --json', ['db-operation-report.json', 'completion-proof.json'], 'pass'),
+    'skill-honest-mode': fixture('execute_and_validate_artifacts', 'sks proof smoke --json', ['completion-proof.json', 'trust-report.json'], 'pass'),
+    'skill-imagegen': fixture('execute_and_validate_artifacts', 'sks image-ux-review fixture --mock --json', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
+    'ux-review:run-wires-imagegen': fixture('execute_and_validate_artifacts', 'npm run ux-review:run-wires-imagegen --silent', [{ path: 'image-ux-review-gate.json', schema: 'sks.image-ux-review-gate.v2', optional: true }], 'pass', {
+        validates_source_contracts: ['requireCodexImagegen', 'generateGptImage2CalloutReview', 'evidence_class', 'output_sha256']
+    }),
+    'ppt:real-imagegen-wiring': fixture('execute_and_validate_artifacts', 'npm run ppt:real-imagegen-wiring --silent', [{ path: 'ppt-imagegen-review-gate.json', schema: 'sks.ppt-imagegen-review-gate.v1', optional: true }], 'pass', {
+        validates_source_contracts: ['generateGptImage2CalloutReview', 'buildSlideImagegenEvidence', 'imagegen_evidence']
+    }),
+    'skill-gx-visual-validate': fixture('execute_and_validate_artifacts', 'sks gx validate fixture --mock --json', ['gx-validation.json'], 'pass'),
     'skill-context7-docs': fixture('real_optional', 'sks context7 check --json', [], 'pass'),
-    'skill-seo-geo-optimizer': fixture('mock', 'sks seo-geo-optimizer fixture --mode geo --json', ['search-visibility/site-inventory.json', 'search-visibility/geo-findings.json', 'geo-gate.json', 'completion-proof.json'], 'pass'),
+    'skill-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode geo --json', ['search-visibility/site-inventory.json', 'search-visibility/geo-findings.json', 'geo-gate.json', 'completion-proof.json'], 'pass'),
     'cli-proof': fixture('execute_and_validate_artifacts', 'sks proof smoke --json', ['.sneakoscope/proof/latest.json'], 'pass'),
     'cli-trust': fixture('execute_and_validate_artifacts', 'sks trust report latest --json', ['trust-report.json'], 'pass'),
     'cli-wrongness': fixture('execute_and_validate_artifacts', 'sks wrongness add --kind missing_evidence --claim "fixture wrongness" --json', ['.sneakoscope/wiki/wrongness-ledger.json'], 'pass'),
     'route-team': fixture('execute_and_validate_artifacts', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json'], 'pass'),
     'route-team-alias': fixture('execute_and_validate_artifacts', 'sks team "fixture" --mock --clones 4 --backend fake --work-items 4 --json', ['naruto-gate.json', 'team-alias-to-naruto.json'], 'pass'),
     'route-naruto': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --clones 4 --backend fake --work-items 4 --json', ['agents/agent-proof-evidence.json', 'agents/agent-scheduler-state.json'], 'pass'),
+    'route-work': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['completion-proof.json', 'naruto-gate.json'], 'pass'),
+    'route-swarm': fixture('execute_and_validate_artifacts', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['completion-proof.json', 'naruto-gate.json'], 'pass'),
+    'route-plan': fixture('execute', 'sks plan "fixture" --json', [], 'pass'),
+    'route-review': fixture('execute', 'sks review --diff HEAD --json', [], 'pass'),
     'route-shadowclone': fixture('mock', '$ShadowClone alias of $Naruto shadow-clone swarm route', [], 'pass'),
     'route-kagebunshin': fixture('mock', '$Kagebunshin alias of $Naruto shadow-clone swarm route', [], 'pass'),
     'route-qa-loop': fixture('execute_and_validate_artifacts', 'sks qa-loop run latest --mock --json', ['completion-proof.json', 'qa-gate.json'], 'pass'),
@@ -120,11 +141,11 @@ const FIXTURES = Object.freeze({
     'route-ultrasearch': fixture('execute', 'sks run "$UltraSearch source intelligence fixture" --execute --json', [], 'pass'),
     'route-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode geo --json', ['search-visibility/site-inventory.json', 'search-visibility/geo-findings.json', 'search-visibility/verification-report.json', 'geo-gate.json', 'completion-proof.json'], 'pass'),
     'route-autoresearch': fixture('mock', '$AutoResearch fixture route', ['research-gate.json', 'completion-proof.json'], 'pass'),
-    'route-mad-sks': fixture('mock', '$MAD-SKS permission gate route', ['mad-sks-gate.json', 'completion-proof.json'], 'pass'),
+    'route-mad-sks': fixture('mock', '$MAD-SKS permission gate + sql_plane route', [{ path: 'mad-sks-gate.json', schema: 'sks.mad-sks-gate.v1' }, 'completion-proof.json'], 'pass'),
     'route-from-chat-img': fixture('mock', '$From-Chat-IMG visual work order route', ['from-chat-img-work-order.md', 'image-voxel-ledger.json', 'completion-proof.json'], 'pass'),
     'route-ux-review': fixture('mock', '$UX-Review image UX alias route', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
     'route-db': fixture('execute_and_validate_artifacts', 'sks db check --sql "SELECT 1" --json', ['completion-proof.json', 'db-operation-report.json'], 'pass'),
-    'route-mad-db': fixture('mock', '$MAD-DB one-cycle DB break-glass route contract', ['mad-db-capability.json', 'mad-db-ledger.jsonl', 'completion-proof.json'], 'pass'),
+    'route-mad-db': fixture('mock', '$MAD-DB deprecated alias to $MAD-SKS sql-plane contract', ['mad-sks-gate.json', 'completion-proof.json'], 'pass'),
     'route-wiki': fixture('execute_and_validate_artifacts', 'sks wiki image-ingest test/fixtures/images/one-by-one.png --json', [{ path: 'completion-proof.json', schema: 'sks.completion-proof.v1' }, { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }], 'pass'),
     'route-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'gx-validation.json'], 'pass'),
     'route-sks': fixture('mock', '$SKS control-surface route', ['completion-proof.json'], 'pass'),
@@ -249,7 +270,7 @@ function qualityForKind(kind) {
     if (kind === 'execute' || kind === 'execute_and_validate_artifacts')
         return 'runtime_verified';
     if (kind === 'mock')
-        return 'runtime_mock_verified';
+        return 'wiring_only';
     if (kind === 'real_optional')
         return 'integration_optional';
     if (kind === 'not_available')

package/dist/core/feature-registry.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { COMMANDS } from '../cli/command-registry.js';
 import { COMMAND_CATALOG, DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS, ROUTES } from './routes.js';
 import { FEATURE_QUALITY_LEVELS, fixtureForFeature, fixtureSummary, validateFeatureFixtures } from './feature-fixtures.js';
 import { runFeatureFixture, writeFeatureFixtureReports } from './feature-fixture-runner.js';
@@ -51,6 +52,8 @@ export async function buildFeatureRegistry({ root = packageRoot(), generatedAt =
     }
     features.push(nativeAgentIntakeFeature());
     features.push(agentProofEvidenceFeature());
+    features.push(doctorImagegenRepairFeature());
+    features.push(...imagegenWiringFeatures());
     for (const skillName of skillNames) {
         if (!skillCoveredByRoute(skillName))
             features.push(skillFeature(skillName));
@@ -102,7 +105,8 @@ export function validateFeatureRegistry(registry = {}) {
     const blockers = [
         ...Object.entries(unmapped).flatMap(([kind, values]) => values.map((value) => `${kind}:${value}`)),
         ...duplicateFeatureIds.map((id) => `duplicate_feature_id:${id}`),
-        ...routeMentionsWithoutRoute.map((mention) => `doc_route_mention_without_route:${mention}`)
+        ...routeMentionsWithoutRoute.map((mention) => `doc_route_mention_without_route:${mention}`),
+        ...routeGateConsistencyBlockers()
     ];
     return {
         ok: blockers.length === 0,
@@ -118,6 +122,7 @@ export function validateFeatureRegistry(registry = {}) {
         unmapped,
         duplicate_feature_ids: duplicateFeatureIds,
         doc_route_mentions_without_route: routeMentionsWithoutRoute,
+        route_gate_consistency_blockers: routeGateConsistencyBlockers(),
         blockers,
         nonblocking_known_gaps: [
             'feature fixtures remain progressive',
@@ -127,6 +132,41 @@ export function validateFeatureRegistry(registry = {}) {
         feature_quality_summary: featureQualitySummary(features)
     };
 }
+export function routeGateConsistencyBlockers() {
+    const blockers = [];
+    for (const route of ROUTES) {
+        const cliName = routeCliCommandName(route);
+        if (!cliName)
+            continue;
+        const entry = COMMANDS[cliName];
+        if (!entry?.ownsGates)
+            continue;
+        const routeGates = stopGateFiles(route.stopGate);
+        const owned = new Set((entry.ownedGateFiles || []).map((file) => String(file)));
+        if (!routeGates.length && owned.size > 0)
+            blockers.push(`route_gate_mismatch:${route.id}:routes_none_registry_${[...owned].join('|')}`);
+        for (const gate of routeGates) {
+            if (!owned.has(gate))
+                blockers.push(`route_gate_mismatch:${route.id}:${gate}_not_owned_by_${cliName}`);
+        }
+    }
+    return blockers;
+}
+function routeCliCommandName(route) {
+    const command = String(route.command || '').replace(/^\$/, '').toLowerCase();
+    if (Object.hasOwn(COMMANDS, command))
+        return command;
+    const alias = (route.dollarAliases || [])
+        .map((value) => String(value || '').replace(/^\$/, '').toLowerCase())
+        .find((value) => Object.hasOwn(COMMANDS, value));
+    return alias || null;
+}
+function stopGateFiles(stopGate) {
+    const text = String(stopGate || '');
+    if (!text || text === 'none' || text === 'honest_mode' || text === 'plan-only')
+        return [];
+    return text.split('|').map((part) => part.trim()).filter((part) => part.endsWith('.json'));
+}
 export async function writeFeatureInventoryDocs({ root = packageRoot(), outFile = path.join(root, 'docs', 'feature-inventory.md') } = {}) {
     const registry = await buildFeatureRegistry({ root });
     const markdown = renderFeatureInventoryMarkdown(registry);
@@ -674,6 +714,66 @@ function agentProofEvidenceFeature() {
         }
     });
 }
+function doctorImagegenRepairFeature() {
+    return baseFeature({
+        id: 'doctor:imagegen-repair',
+        commands: ['sks doctor --json', 'sks doctor --fix --json'],
+        aliases: ['repair.imagegen', 'imagegen_repair'],
+        category: 'safety',
+        maturity: 'beta',
+        intent: 'Doctor repair path that detects Codex App imagegen, attempts repair when requested, and reports imagegen_repair evidence without claiming success unless re-detection passes.',
+        voxel_triwiki_integration: 'policy voxel required for visual/image routes that depend on Codex App imagegen',
+        completion_proof_integration: 'doctor report imagegen_repair is consumed by imagegen route blockers before visual route proof',
+        known_gaps: ['live Codex App feature enablement remains environment-dependent and reports manual actions when unavailable'],
+        source_refs: {
+            cli_command_names: ['doctor'],
+            handler_keys: ['doctor'],
+            dollar_commands: [],
+            app_skill_aliases: [],
+            skills: ['imagegen']
+        }
+    });
+}
+function imagegenWiringFeatures() {
+    return [
+        baseFeature({
+            id: 'ux-review:run-wires-imagegen',
+            commands: ['npm run ux-review:run-wires-imagegen', 'sks ux-review run --image <screenshot> --generate-callouts --json'],
+            aliases: ['$Image-UX-Review', '$UX-Review'],
+            category: 'visual-memory',
+            maturity: 'beta',
+            intent: 'Image UX route start gate, shared gpt-image-2 adapter, callout extraction, and Codex App evidence validation wiring.',
+            voxel_triwiki_integration: 'image/source/bbox voxel required',
+            completion_proof_integration: 'image-ux-review-gate and Completion Proof must separate real Codex image evidence from mock/API fallback evidence',
+            known_gaps: ['live Codex App image generation remains environment-dependent'],
+            source_refs: {
+                cli_command_names: ['image-ux-review'],
+                handler_keys: ['image-ux-review', 'ux-review'],
+                dollar_commands: ['$Image-UX-Review', '$UX-Review'],
+                app_skill_aliases: ['$image-ux-review', '$ux-review'],
+                skills: ['image-ux-review', 'ux-review', 'imagegen']
+            }
+        }),
+        baseFeature({
+            id: 'ppt:real-imagegen-wiring',
+            commands: ['npm run ppt:real-imagegen-wiring', 'sks ppt review --deck <pptx> --json'],
+            aliases: ['$PPT'],
+            category: 'visual-memory',
+            maturity: 'beta',
+            intent: 'PPT slide callout review path reuses the shared gpt-image-2 adapter and records imagegen_evidence in PPT gates.',
+            voxel_triwiki_integration: 'image/source/bbox voxel required',
+            completion_proof_integration: 'ppt-imagegen-review-gate and ppt-gate must include Codex App imagegen evidence classes and hashes',
+            known_gaps: ['live deck export and live Codex App image generation remain environment-dependent'],
+            source_refs: {
+                cli_command_names: ['ppt'],
+                handler_keys: ['ppt'],
+                dollar_commands: ['$PPT'],
+                app_skill_aliases: ['$ppt'],
+                skills: ['ppt', 'imagegen']
+            }
+        })
+    ];
+}
 function skillFeature(skillName) {
     return baseFeature({
         id: `skill-${slug(skillName)}`,
@@ -876,7 +976,7 @@ function routeKnownGaps(command) {
     if (command === '$MAD-SKS')
         return ['permission closed by owning gate'];
     if (command === '$MAD-DB')
-        return ['active cycle must execute requested SQL-plane work, read back postconditions, and close the mission-local write profile'];
+        return ['deprecated alias; SQL-plane execution is merged into $MAD-SKS and must still read back postconditions and close the mission-local write profile'];
     return [];
 }
 function checkRow(id, ok, blockers = []) {

package/dist/core/fsx.js

@@ -5,12 +5,42 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '4.8.7';
+export const PACKAGE_VERSION = '5.1.2';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {
     return new Date().toISOString();
 }
+export function lastLine(chunk) {
+    const lines = String(chunk || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    return lines[lines.length - 1] || '';
+}
+export function throttleLines(fn, ms = 500) {
+    let lastAt = 0;
+    let pending = null;
+    let timer = null;
+    const flush = () => {
+        timer = null;
+        if (!pending)
+            return;
+        lastAt = Date.now();
+        const line = pending;
+        pending = null;
+        fn(line);
+    };
+    return (chunk) => {
+        const line = lastLine(chunk);
+        if (!line)
+            return;
+        pending = line;
+        const now = Date.now();
+        const wait = Math.max(0, ms - (now - lastAt));
+        if (wait === 0)
+            flush();
+        else if (!timer)
+            timer = setTimeout(flush, wait);
+    };
+}
 export function sha256(input) {
     return crypto.createHash('sha256').update(input).digest('hex');
 }
@@ -109,18 +139,21 @@ export async function writeReceiptRotated(p, data, opts = {}) {
     const rotated = prior
         .filter((entry) => entry.isFile() && entry.name.startsWith(`${base}.`) && entry.name.endsWith('.json'))
         .map((entry) => path.join(path.dirname(p), entry.name));
+    const rotatedFiles = new Set(rotated);
     const existing = await fsp.stat(p).catch(() => null);
     if (existing) {
         const stamp = new Date(existing.mtimeMs).toISOString().replace(/[:.]/g, '-');
-        await fsp.rename(p, path.join(path.dirname(p), `${base}.${stamp}.json`)).catch(() => undefined);
+        const rotatedPath = path.join(path.dirname(p), `${base}.${stamp}.json`);
+        await fsp.rename(p, rotatedPath).catch(() => undefined);
+        rotatedFiles.add(rotatedPath);
     }
     await writeJsonAtomic(p, data);
-    const rows = await Promise.all(rotated.map(async (file) => ({ file, stat: await fsp.stat(file).catch(() => null) })));
-    rows
+    const rows = await Promise.all([...rotatedFiles].map(async (file) => ({ file, stat: await fsp.stat(file).catch(() => null) })));
+    const removable = rows
         .filter((row) => Boolean(row.stat))
         .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)
-        .slice(keep)
-        .forEach((row) => void fsp.rm(row.file, { force: true }).catch(() => undefined));
+        .slice(keep);
+    await Promise.all(removable.map((row) => fsp.rm(row.file, { force: true }).catch(() => undefined)));
 }
 export async function writeBinaryAtomic(p, data) {
     await ensureDir(path.dirname(p));

package/dist/core/image-ux-review/imagegen-adapter.js

@@ -107,6 +107,7 @@ export function createCodexAppImagegenAdapter(opts = {}) {
                     schema: 'sks.image-ux-gpt-image-2-response.v1',
                     created_at: nowIso(),
                     provider: 'codex_app_imagegen',
+                    evidence_class: 'codex_app_imagegen',
                     model: 'gpt-image-2',
                     ok: false,
                     status: 'blocked',
@@ -131,11 +132,13 @@ export function createCodexAppImagegenAdapter(opts = {}) {
                     schema: 'sks.image-ux-gpt-image-2-response.v1',
                     created_at: nowIso(),
                     provider: 'codex_app_imagegen',
+                    evidence_class: 'codex_app_imagegen',
                     model: 'gpt-image-2',
                     ok: true,
                     status: 'generated',
                     output_image_path: dest,
                     output_image_sha256: meta.sha256,
+                    output_sha256: meta.sha256,
                     output_id: meta.output_id,
                     output_source: outputSource,
                     image_artifact_path_contract: imageContract?.artifact_path || null,
@@ -161,6 +164,7 @@ export function createCodexAppImagegenAdapter(opts = {}) {
                 schema: 'sks.image-ux-gpt-image-2-response.v1',
                 created_at: nowIso(),
                 provider: 'codex_app_imagegen',
+                evidence_class: 'codex_app_imagegen',
                 model: 'gpt-image-2',
                 ok: false,
                 status: 'blocked',
@@ -196,6 +200,22 @@ export function createFakeImagegenAdapter(opts = {}) {
             await ensureDir(input.output_dir);
             const requestArtifact = path.join(input.output_dir, 'image-ux-gpt-image-2-request.json');
             const responseArtifact = path.join(input.output_dir, 'image-ux-gpt-image-2-response.json');
+            if (!imagegenMockContext(opts)) {
+                await writeJsonAtomic(responseArtifact, {
+                    schema: 'sks.image-ux-gpt-image-2-response.v1',
+                    created_at: nowIso(),
+                    provider: 'fake_imagegen_adapter',
+                    fake_adapter: true,
+                    execution_class: 'mock_fixture',
+                    evidence_class: 'mock_fixture',
+                    model: 'gpt-image-2',
+                    ok: false,
+                    status: 'blocked',
+                    blocker: 'fake_imagegen_requires_test_or_mock_context',
+                    local_only: true
+                });
+                return { ok: false, status: 'blocked', generated_image_path: null, output_id: null, blocker: 'fake_imagegen_requires_test_or_mock_context', provider: 'fake_imagegen_adapter', request_artifact: null, response_artifact: responseArtifact, latency_ms: Date.now() - started };
+            }
             const validation = await validateGptImage2Request({
                 provider: 'fake_imagegen_adapter',
                 endpoint: 'local hermetic fixture',
@@ -227,6 +247,9 @@ export function createFakeImagegenAdapter(opts = {}) {
                     schema: 'sks.image-ux-gpt-image-2-response.v1',
                     created_at: nowIso(),
                     provider: 'fake_imagegen_adapter',
+                    fake_adapter: true,
+                    execution_class: 'mock_fixture',
+                    evidence_class: 'mock_fixture',
                     model: 'gpt-image-2',
                     ok: false,
                     status: 'blocked',
@@ -251,16 +274,20 @@ export function createFakeImagegenAdapter(opts = {}) {
                 schema: 'sks.image-ux-gpt-image-2-response.v1',
                 created_at: nowIso(),
                 provider: 'fake_imagegen_adapter',
+                fake_adapter: true,
+                execution_class: 'mock_fixture',
+                evidence_class: 'mock_fixture',
                 model: 'gpt-image-2',
                 ok: true,
                 status: 'generated',
                 output_image_path: out,
                 output_image_sha256: meta.sha256,
+                output_sha256: meta.sha256,
                 output_id: meta.output_id,
+                output_source: 'mock_fixture',
                 image_artifact_path_contract: imageContract?.artifact_path || null,
                 dimensions: { width: meta.width, height: meta.height, format: meta.format },
                 latency_ms: Date.now() - started,
-                fake_adapter: true,
                 source: 'mock_like_fixture',
                 real_generated: false,
                 mock: true,
@@ -320,6 +347,7 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                     schema: 'sks.image-ux-gpt-image-2-response.v1',
                     created_at: nowIso(),
                     provider: 'openai_images_api',
+                    evidence_class: 'non_codex_api_fallback',
                     model: 'gpt-image-2',
                     ok: false,
                     status: 'blocked',
@@ -334,6 +362,7 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                     schema: 'sks.image-ux-gpt-image-2-response.v1',
                     created_at: nowIso(),
                     provider: 'openai_images_api',
+                    evidence_class: 'non_codex_api_fallback',
                     model: 'gpt-image-2',
                     ok: false,
                     status: 'blocked',
@@ -397,6 +426,7 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                         schema: 'sks.image-ux-gpt-image-2-response.v1',
                         created_at: nowIso(),
                         provider: 'openai_responses_image_generation',
+                        evidence_class: 'non_codex_api_fallback',
                         model: 'gpt-image-2',
                         responses_model: responsesImagegenModel(opts),
                         auth_source: auth.auth_source,
@@ -404,6 +434,7 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                         status: 'generated',
                         output_image_path: out,
                         output_image_sha256: meta.sha256,
+                        output_sha256: meta.sha256,
                         output_id: meta.output_id,
                         image_artifact_path_contract: imageContract?.artifact_path || null,
                         dimensions: { width: meta.width, height: meta.height, format: meta.format },
@@ -454,12 +485,14 @@ export function createOpenAIImagesApiAdapter(opts = {}) {
                     schema: 'sks.image-ux-gpt-image-2-response.v1',
                     created_at: nowIso(),
                     provider: 'openai_images_api',
+                    evidence_class: 'non_codex_api_fallback',
                     model: 'gpt-image-2',
                     auth_source: auth.auth_source,
                     ok: true,
                     status: 'generated',
                     output_image_path: out,
                     output_image_sha256: meta.sha256,
+                    output_sha256: meta.sha256,
                     output_id: meta.output_id,
                     image_artifact_path_contract: imageContract?.artifact_path || null,
                     dimensions: { width: meta.width, height: meta.height, format: meta.format },
@@ -511,24 +544,17 @@ async function resolveImageArtifactRoot(input) {
     return projectRoot(input.output_dir || process.cwd()).catch(() => cwdRoot);
 }
 export async function generateGptImage2CalloutReview(input, opts = {}) {
-    if (opts.fake === true || process.env.SKS_TEST_FAKE_IMAGEGEN === '1') {
-        return createFakeImagegenAdapter(opts.fakeAdapter || {}).generateCalloutReview(input);
+    if ((opts.fake === true || process.env.SKS_TEST_FAKE_IMAGEGEN === '1') && imagegenMockContext(opts)) {
+        return createFakeImagegenAdapter({ ...(opts.fakeAdapter || {}), mockContext: true }).generateCalloutReview(input);
     }
     const capability = await detectImagegenCapability(opts.capability || {}).catch(() => null);
-    // Auto-enable the OpenAI direct-key API fallback whenever an OPENAI_API_KEY is
-    // available, so a missing/failed Codex App $imagegen surface still produces a
-    // real image instead of a hard block. Explicit opt-out wins: pass
-    // allowApiFallback:false or SKS_IMAGEGEN_ALLOW_API_FALLBACK=0.
-    const openAiKeyPresent = Boolean(opts.openai?.apiKey || process.env.OPENAI_API_KEY);
-    const explicitDisableApiFallback = opts.allowApiFallback === false || process.env.SKS_IMAGEGEN_ALLOW_API_FALLBACK === '0';
     // codex-lb imagegen is a direct API fallback, not Codex App imagegen evidence.
     // It must be explicitly enabled by the caller or environment.
     const explicitDisableCodexLbFallback = opts.allowCodexLbApiFallback === false || process.env.SKS_IMAGEGEN_ALLOW_CODEX_LB_API_FALLBACK === '0';
     const allowCodexLbApiFallback = !explicitDisableCodexLbFallback && (opts.allowCodexLbApiFallback === true
         || process.env.SKS_IMAGEGEN_ALLOW_CODEX_LB_API_FALLBACK === '1');
-    const allowApiFallback = !explicitDisableApiFallback && (opts.allowApiFallback === true
+    const allowApiFallback = (opts.allowApiFallback === true
         || process.env.SKS_IMAGEGEN_ALLOW_API_FALLBACK === '1'
-        || openAiKeyPresent
         || allowCodexLbApiFallback);
     const openaiOptions = {
         ...(opts.openai || {}),
@@ -544,6 +570,13 @@ export async function generateGptImage2CalloutReview(input, opts = {}) {
         return codexResult;
     return createOpenAIImagesApiAdapter(openaiOptions).generateCalloutReview(input);
 }
+function imagegenMockContext(opts = {}) {
+    return opts.mockContext === true
+        || opts.testContext === true
+        || process.env.NODE_ENV === 'test'
+        || process.env.SKS_SELFTEST_MOCK === '1'
+        || process.env.SKS_MOCK === '1';
+}
 export function imagegenCapabilityBlocker(surface = 'Codex App $imagegen') {
     return {
         schema: 'sks.image-ux-imagegen-blocker.v1',
@@ -705,6 +738,9 @@ export async function generatedImageMetadata(root, imagePath, opts = {}) {
         source_screen_id: opts.source_screen_id || null,
         provider_model: 'gpt-image-2',
         provider_surface: opts.provider_surface || 'codex_app_imagegen',
+        evidence_class: opts.evidence_class || (opts.mock ? 'mock_fixture' : 'codex_app_imagegen'),
+        output_source: opts.output_source || (opts.mock ? 'mock_fixture' : 'manual_attach'),
+        output_sha256: opts.output_sha256 || await sha256File(absolute),
         requested_fidelity: 'high_fidelity_automatic',
         image_input_fidelity_note: 'high_fidelity_automatic',
         privacy: 'local-only',
@@ -729,6 +765,7 @@ function redactedImagegenResponse(payload, ok, latencyMs, provider = 'openai_ima
         schema: 'sks.image-ux-gpt-image-2-response.v1',
         created_at: nowIso(),
         provider,
+        evidence_class: provider === 'codex_app_imagegen' ? 'codex_app_imagegen' : 'non_codex_api_fallback',
         model: 'gpt-image-2',
         ok,
         status: ok ? 'generated' : 'blocked',