sneakoscope 4.8.6 → 5.1.2

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,40 +74,56 @@ 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'),
     'cli-insane-search': fixture('execute', 'sks insane-search doctor --json', [], 'pass'),
     'cli-ultra-search': fixture('execute', 'sks ultra-search doctor --json', [], 'pass'),
     'cli-xai': fixture('real_optional', 'sks xai check --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-team': fixture('mock', 'sks team "fixture" --mock --json', ['completion-proof.json', 'team-gate.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-task': fixture('execute', 'sks task instant --plan --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('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 --json', ['completion-proof.json', 'team-gate.json', 'team-session-cleanup.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'),
@@ -114,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'),
@@ -133,7 +160,7 @@ const FIXTURES = Object.freeze({
     'route-commit-and-push': fixture('mock', '$Commit-And-Push git route', ['completion-proof.json'], 'pass'),
     'route-release-review': fixture('mock', 'sks agent run "release audit" --route "$Release-Review" --agents 10 --concurrency 5 --mock --json', ['release-review-native-agent-plan.json', 'agents/agent-proof-evidence.json', 'agents/agent-effort-policy.json'], 'pass'),
     'route-native-agent-intake': fixture('mock', 'sks agent run "fixture" --route "$Team" --agents 5 --concurrency 5 --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'),
-    'proof-agent-evidence': fixture('mock', 'sks team "fixture" --mock --json', ['completion-proof.json', 'agents/agent-proof-evidence.json'], 'pass')
+    'proof-agent-evidence': fixture('mock', 'sks naruto run "fixture" --backend fake --work-items 4 --json', ['naruto-gate.json', 'agents/agent-proof-evidence.json'], 'pass')
 });
 const STATIC_CONTRACT_FEATURES = new Set([
     'cli-wizard',
@@ -151,6 +178,7 @@ const STATIC_CONTRACT_FEATURES = new Set([
     'cli-all-features',
     'cli-eval',
     'cli-harness',
+    'cli-naruto',
     'cli-team',
     'cli-reasoning',
     'cli-profile',
@@ -242,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);
@@ -484,9 +524,12 @@ const SAFE_EXECUTABLE_FIXTURE_ARGS = Object.freeze({
     'cli-stats': ['stats', '--json'],
     'cli-dollar-commands': ['dollar-commands', '--json'],
     'cli-fast-mode': ['fast-mode', 'status', '--json'],
+    'cli-task': ['task', 'instant', '--plan', '--json'],
+    'cli-triwiki': ['triwiki', 'index', '--json'],
+    'cli-daemon': ['daemon', 'status', '--json'],
     'cli-dfix': ['dfix', 'fixture', '--json'],
     'cli-all-features': ['all-features', 'complete', '--json'],
-    'route-team': ['team', 'fixture', '--mock', '--json'],
+    'route-team': ['team', 'fixture', '--mock', '--clones', '4', '--backend', 'fake', '--work-items', '4', '--json'],
     'route-naruto': ['naruto', 'run', 'fixture', '--clones', '4', '--backend', 'fake', '--work-items', '4', '--json'],
     'route-qa-loop': { setup: [['qa-loop', 'prepare', 'fixture API QA', '--json']], command: ['qa-loop', 'run', 'latest', '--mock', '--json'] },
     'route-research': { setup: [['research', 'prepare', 'fixture research topic', '--json']], command: ['research', 'run', 'latest', '--mock', '--json'] },
@@ -671,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)}`,
@@ -873,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.6';
+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');
 }
@@ -101,6 +131,30 @@ export async function readJson(p, fallback) {
 export async function writeJsonAtomic(p, data) {
     await writeTextAtomic(p, `${JSON.stringify(data, null, 2)}\n`);
 }
+export async function writeReceiptRotated(p, data, opts = {}) {
+    await ensureDir(path.dirname(p));
+    const keep = Math.max(1, opts.keep ?? 5);
+    const prior = await fsp.readdir(path.dirname(p), { withFileTypes: true }).catch(() => []);
+    const base = path.basename(p);
+    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, '-');
+        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([...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);
+    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));
     try {
@@ -129,6 +183,12 @@ export async function appendJsonl(p, obj) {
     await ensureDir(path.dirname(p));
     await fsp.appendFile(p, `${JSON.stringify(obj)}\n`, 'utf8');
 }
+export async function appendJsonlMany(p, rows) {
+    if (!rows.length)
+        return;
+    await ensureDir(path.dirname(p));
+    await fsp.appendFile(p, rows.map((row) => JSON.stringify(row)).join('\n') + '\n', 'utf8');
+}
 export async function appendJsonlBounded(p, obj, maxBytes = 5 * 1024 * 1024) {
     await appendJsonl(p, obj);
     try {
@@ -426,8 +486,37 @@ export async function readStdin() {
         process.stdin.on('end', () => resolve(data));
     });
 }
+export function managedSksTmpRoot(baseDir = os.tmpdir()) {
+    return path.join(baseDir, 'sks');
+}
 export function tmpdir(prefix = 'sks-') {
-    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    const base = managedSksTmpRoot();
+    fs.mkdirSync(base, { recursive: true });
+    return fs.mkdtempSync(path.join(base, prefix));
+}
+export async function withScratchDir(prefix = 'sks-', fn, opts = {}) {
+    const base = opts.baseDir || managedSksTmpRoot();
+    await fsp.mkdir(base, { recursive: true });
+    const dir = await fsp.mkdtemp(path.join(base, prefix));
+    try {
+        return await fn(dir);
+    }
+    finally {
+        if (!opts.keep)
+            await fsp.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+export function withScratchDirSync(prefix = 'sks-', fn, opts = {}) {
+    const base = opts.baseDir || managedSksTmpRoot();
+    fs.mkdirSync(base, { recursive: true });
+    const dir = fs.mkdtempSync(path.join(base, prefix));
+    try {
+        return fn(dir);
+    }
+    finally {
+        if (!opts.keep)
+            fs.rmSync(dir, { recursive: true, force: true });
+    }
 }
 export async function fileSize(p) {
     try {

package/dist/core/hooks-runtime/skill-reconcile-preflight.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+import { PACKAGE_VERSION, readJson, readText } from '../fsx.js';
+import { loadSkillsManifest, reconcileSkills } from '../init/skills.js';
+export async function maybeReconcileProjectSkillsPreflight(root) {
+    const manifestPath = path.join(root, '.agents', 'skills', '.sks-generated.json');
+    const manifest = await readJson(manifestPath, null);
+    const needsByManifest = manifest?.version && manifest.version !== PACKAGE_VERSION;
+    const needsByResidue = await hasProjectOfficialResidue(root);
+    if (!needsByManifest && !needsByResidue)
+        return null;
+    return reconcileSkills({
+        targetDir: path.join(root, '.agents', 'skills'),
+        scope: 'project',
+        fix: true
+    });
+}
+async function hasProjectOfficialResidue(root) {
+    const manifest = await loadSkillsManifest().catch(() => null);
+    const official = new Set([
+        ...(manifest?.skills || []).map((skill) => canonical(skill.canonical_name)),
+        ...(manifest?.skills || []).flatMap((skill) => (skill.deprecated_aliases || []).map((name) => canonical(name))),
+        ...((manifest?.removed_skills || []).map((name) => canonical(name)))
+    ]);
+    for (const dir of [path.join(root, '.agents', 'skills'), path.join(root, '.codex', 'skills')]) {
+        const rows = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const row of rows) {
+            if (!row.isDirectory())
+                continue;
+            const text = await readText(path.join(dir, row.name, 'SKILL.md'), null);
+            if (typeof text !== 'string')
+                continue;
+            const display = /^name:\s*(.+)\s*$/m.exec(text)?.[1] || row.name;
+            if (official.has(canonical(display)))
+                return true;
+        }
+    }
+    return false;
+}
+function canonical(value) {
+    return String(value || '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+//# sourceMappingURL=skill-reconcile-preflight.js.map