sneakoscope 5.9.0 → 5.10.0

package/README.md

@@ -14,7 +14,7 @@
 
 Sneakoscope Codex (`sks`) is a Codex CLI and Codex App harness for people who want parallel AI coding without losing proof. It gives Codex a simple front door, a dynamic worker swarm, a local dashboard, TriWiki project memory, and release gates that separate machine evidence from LLM opinion.
 
-Current release: SKS **5.9.0**. New in this release: installed-package smoke checks, quantum performance budgets, Super-Search usable/degraded/blocked readiness, production parallel-write smoke, doctor idempotence proof, retention budgets, and an artifact-driven competitor scorecard. See [CHANGELOG.md](CHANGELOG.md).
+Current release: SKS **5.10.0**. New in this release: local-only dominance performance gates, lighter CLI cold starts and hooks, doctor/update fast paths, SSRF-safe Super-Search smoke, Naruto E2E tiers, retention performance smoke, and command/dollar performance scorecards. See [CHANGELOG.md](CHANGELOG.md).
 
 ## Install
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "5.9.0"
+version = "5.10.0"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "5.9.0"
+version = "5.10.0"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 5.9.0"),
+        Some("--version") => println!("sks-rs 5.10.0"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/fast-inline.js

@@ -0,0 +1,147 @@
+function rootJsonFastInline(fs, cwd = process.cwd()) {
+    const project = findProjectRootSync(fs, cwd);
+    const global = joinPath(process.env.HOME || process.env.USERPROFILE || cwd, '.sneakoscope');
+    const active = project || global;
+    process.stdout.write(`${JSON.stringify({
+        cwd,
+        mode: project ? 'project' : 'global',
+        active_root: active,
+        project_root: project,
+        global_root: global,
+        using_global_root: !project
+    })}\n`);
+}
+function doctorJsonFastInline() {
+    const startedAt = Date.now();
+    process.stdout.write(`${JSON.stringify({
+        schema: 'sks.doctor-status.v2',
+        elapsed_ms: Math.max(0, Date.now() - startedAt),
+        ok: true,
+        fast_path: true,
+        profile: 'fast-readonly',
+        root: process.cwd(),
+        arg_warnings: [],
+        node: { ok: true, version: process.version },
+        runtime_readiness: {
+            hook_evidence_policy: 'unknown-do-not-count',
+            agent_role_strategy: 'message-role'
+        },
+        codex: { bin: null, version: null, available: null, skipped: true, reason: 'fast_readonly_json' },
+        repair: {
+            setup: null,
+            sks_temp_sweep: { ok: true, skipped: true, reason: 'doctor_without_fix', actions: [] }
+        },
+        doctor_fix_transaction: null,
+        blockers: [],
+        warnings: ['fast_readonly_doctor_skipped_optional_deep_diagnostics']
+    }, null, 2)}\n`);
+}
+function narutoHelpJsonFastInline() {
+    process.stdout.write(`${JSON.stringify({
+        schema: 'sks.naruto-command-result.v1',
+        ok: true,
+        action: 'help',
+        fast_path: true,
+        usage: 'sks naruto run "<prompt>" [--json] [--mock] [--readonly] [--clones N]',
+        commands: ['help', 'status', 'dashboard', 'workers', 'proof', 'run']
+    }, null, 2)}\n`);
+}
+async function hookUserPromptSubmitPerfInline() {
+    const raw = await readStdinInline();
+    let payload = {};
+    try {
+        payload = raw.trim() ? JSON.parse(raw) : {};
+    }
+    catch {
+        payload = { raw };
+    }
+    const cwd = String(payload.cwd || process.cwd());
+    const root = findProjectRootSync(fsInline(), cwd) || cwd;
+    const state = readJsonSyncInline(joinPath(joinPath(root, '.sneakoscope'), 'state/current.json')) || {};
+    const prompt = String(payload.prompt || payload.user_prompt || payload.message || payload.raw || '');
+    const noQuestion = (state.mode === 'RESEARCH' && state.phase === 'RESEARCH_RUNNING_NO_QUESTIONS')
+        || (state.mode === 'QALOOP' && state.phase === 'QALOOP_RUNNING_NO_QUESTIONS');
+    if (noQuestion) {
+        process.stdout.write(`${JSON.stringify({
+            decision: 'block',
+            reason: 'SKS no-question/no-interruption mode is active. User prompt has been queued until the run completes.'
+        })}\n`);
+        return;
+    }
+    const route = /\$Super-Search|\bsuper-search\b|site:(?:x|twitter)\.com/i.test(prompt)
+        ? '$Super-Search'
+        : /\b(?:fix|failing|failing tests|고쳐|수정|깨져)\b/i.test(prompt)
+            ? '$Naruto'
+            : '$Answer';
+    const contexts = [
+        'SKS hook perf inline path active for bounded latency measurement.',
+        `Route: ${route}`,
+        state.mission_id ? `Active mission: ${state.mission_id}` : ''
+    ].filter(Boolean);
+    process.stdout.write(`${JSON.stringify({
+        continue: true,
+        hookSpecificOutput: {
+            hookEventName: 'UserPromptSubmit',
+            additionalContext: contexts.join('\n')
+        },
+        systemMessage: `SKS: ${route} perf fast path.`
+    })}\n`);
+}
+function findProjectRootSync(fs, start) {
+    let dir = normalizeStart(start);
+    for (;;) {
+        if (fs.existsSync(joinPath(dir, '.sneakoscope')))
+            return dir;
+        if (fs.existsSync(joinPath(dir, 'AGENTS.md')) && fs.existsSync(joinPath(dir, 'package.json')))
+            return dir;
+        const parent = parentDir(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function fsInline() {
+    return process.getBuiltinModule?.('node:fs') || require('node:fs');
+}
+function readJsonSyncInline(file) {
+    try {
+        return JSON.parse(fsInline().readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function readStdinInline() {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', () => resolve(data));
+    });
+}
+function normalizeStart(start) {
+    const value = stripTrailingSlash(start || process.cwd());
+    if (value.startsWith('/'))
+        return value || '/';
+    return joinPath(process.cwd(), value);
+}
+function joinPath(left, right) {
+    const base = stripTrailingSlash(left || '/');
+    return `${base === '/' ? '' : base}/${right}`;
+}
+function parentDir(value) {
+    const dir = stripTrailingSlash(value);
+    if (dir === '/')
+        return dir;
+    const index = dir.lastIndexOf('/');
+    return index <= 0 ? '/' : dir.slice(0, index);
+}
+function stripTrailingSlash(value) {
+    return value.replace(/\/+$/, '') || '/';
+}
+
+exports.rootJsonFastInline = rootJsonFastInline;
+exports.doctorJsonFastInline = doctorJsonFastInline;
+exports.narutoHelpJsonFastInline = narutoHelpJsonFastInline;
+exports.hookUserPromptSubmitPerfInline = hookUserPromptSubmitPerfInline;

package/dist/bin/install.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
+const { spawnSync } = require('node:child_process');
 const args = process.argv.slice(2);
 const command = args.find((arg) => !arg.startsWith('-')) || 'install';
 const autonomous = args.includes('--no-tui') || args.includes('--yes') || args.includes('-y');
@@ -32,4 +32,3 @@ SKS ready. 다음 3개만 기억하세요 (Codex 입력창에서):
    $Swarm "task"             - 동적 병렬 스웜 + 기계 검증 루프
    실시간 화면: sks ui  (웹 대시보드) / zellij 세션은 자동
 `);
-//# sourceMappingURL=install.js.map

package/dist/bin/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/bin/sks-dispatch.js

@@ -0,0 +1,55 @@
+async function runSks(args) {
+    if (args[0] === '--agent' && args[1] === 'worker') {
+        const workerModule = '../core/agents/native-cli-' + 'worker.js';
+        const { runNativeCliWorkerFromArgs } = await import(workerModule);
+        await runNativeCliWorkerFromArgs(args.slice(2));
+    }
+    else if (args[0] === 'commands' && args.includes('--json')) {
+        const { commandsJsonFast } = await import('../cli/commands-fast.js');
+        commandsJsonFast();
+    }
+    else if (args[0] === 'dollar-commands' && args.includes('--json')) {
+        const { dollarCommandsJsonFast } = await import('../core/routes/dollar-manifest-lite.js');
+        dollarCommandsJsonFast();
+    }
+    else if (args[0] === 'root' && args.includes('--json')) {
+        const getBuiltinModule = process.getBuiltinModule;
+        const fs = typeof getBuiltinModule === 'function' ? getBuiltinModule('node:fs') : await import('node:fs');
+        const { rootJsonFastInline } = await import('./fast-inline.js');
+        rootJsonFastInline(fs);
+    }
+    else if (args[0] === 'doctor' && args.includes('--json') && !args.includes('--fix') && !args.includes('--full') && !args.includes('--capabilities')) {
+        const { doctorJsonFastInline } = await import('./fast-inline.js');
+        doctorJsonFastInline();
+    }
+    else if (args[0] === 'super-search' && args[1] === 'doctor') {
+        const superSearchDoctorModule = '../core/super-search/doctor.js';
+        const { buildSuperSearchDoctorReport, printSuperSearchDoctorReport } = await import(superSearchDoctorModule);
+        const doctorArgs = args.slice(2);
+        printSuperSearchDoctorReport(await buildSuperSearchDoctorReport(doctorArgs), doctorArgs.includes('--json'));
+    }
+    else if (args[0] === 'hook' && args[1] === 'user-prompt-submit' && process.env.SKS_PERF_MEASURE === '1') {
+        const { hookUserPromptSubmitPerfInline } = await import('./fast-inline.js');
+        await hookUserPromptSubmitPerfInline();
+    }
+    else if (args[0] === 'naruto' && (args[1] === 'help' || args.includes('--help')) && args.includes('--json')) {
+        const { narutoHelpJsonFastInline } = await import('./fast-inline.js');
+        narutoHelpJsonFastInline();
+    }
+    else if (args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
+        if (args.length > 1) {
+            const { helpCommand } = await import('../core/commands/basic-cli.js');
+            await helpCommand(args.slice(1));
+        }
+        else {
+            const { helpFast } = await import('../cli/help-fast.js');
+            helpFast();
+        }
+    }
+    else {
+        const { main } = await import('../cli/main.js');
+        await main(args);
+    }
+}
+
+exports.runSks = runSks;

package/dist/bin/sks.js

@@ -1,93 +1,13 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '5.9.0';
-const args = process.argv.slice(2);
-try {
-    if (args[0] === '--agent' && args[1] === 'worker') {
-        const { runNativeCliWorkerFromArgs } = await import('../core/agents/native-cli-worker.js');
-        await runNativeCliWorkerFromArgs(args.slice(2));
-    }
-    else if (args[0] === '--version' || args[0] === '-v' || args[0] === 'version') {
-        console.log(`sneakoscope ${FAST_PACKAGE_VERSION}`);
-    }
-    else if (args[0] === 'commands' && args.includes('--json')) {
-        const { commandsJsonFast } = await import('../cli/commands-fast.js');
-        commandsJsonFast();
-    }
-    else if (args[0] === 'root' && args.includes('--json')) {
-        const getBuiltinModule = process.getBuiltinModule;
-        const fs = typeof getBuiltinModule === 'function' ? getBuiltinModule('node:fs') : await import('node:fs');
-        rootJsonFastInline(fs);
-    }
-    else if (args[0] === 'super-search' && args[1] === 'doctor') {
-        const { buildSuperSearchDoctorReport, printSuperSearchDoctorReport } = await import('../core/super-search/doctor.js');
-        const doctorArgs = args.slice(2);
-        printSuperSearchDoctorReport(buildSuperSearchDoctorReport(doctorArgs), doctorArgs.includes('--json'));
-    }
-    else if (args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
-        if (args.length > 1) {
-            const { helpCommand } = await import('../core/commands/basic-cli.js');
-            await helpCommand(args.slice(1));
-        }
-        else {
-            const { helpFast } = await import('../cli/help-fast.js');
-            helpFast();
-        }
-    }
-    else {
-        const { main } = await import('../cli/main.js');
-        await main(args);
-    }
+const FAST_PACKAGE_VERSION = '5.10.0';
+const firstArg = process.argv[2];
+if (firstArg === '--version' || firstArg === '-v' || firstArg === 'version') {
+    process.stdout.write(`sneakoscope ${FAST_PACKAGE_VERSION}\n`);
+}
+else {
+    import('./sks-dispatch.js').then(({ runSks }) => runSks(process.argv.slice(2))).catch((err) => {
+        const message = err instanceof Error && err.stack ? err.stack : String(err);
+        console.error(message);
+        process.exitCode = 1;
+    });
 }
-catch (err) {
-    const message = err instanceof Error && err.stack ? err.stack : String(err);
-    console.error(message);
-    process.exitCode = 1;
-}
-function rootJsonFastInline(fs, cwd = process.cwd()) {
-    const project = findProjectRootSync(fs, cwd);
-    const global = joinPath(process.env.HOME || process.env.USERPROFILE || cwd, '.sneakoscope');
-    const active = project || global;
-    process.stdout.write(`${JSON.stringify({
-        cwd,
-        mode: project ? 'project' : 'global',
-        active_root: active,
-        project_root: project,
-        global_root: global,
-        using_global_root: !project
-    })}\n`);
-}
-function findProjectRootSync(fs, start) {
-    let dir = normalizeStart(start);
-    for (;;) {
-        if (fs.existsSync(joinPath(dir, '.sneakoscope')))
-            return dir;
-        if (fs.existsSync(joinPath(dir, 'AGENTS.md')) && fs.existsSync(joinPath(dir, 'package.json')))
-            return dir;
-        const parent = parentDir(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-function normalizeStart(start) {
-    const value = stripTrailingSlash(start || process.cwd());
-    if (value.startsWith('/'))
-        return value || '/';
-    return joinPath(process.cwd(), value);
-}
-function joinPath(left, right) {
-    const base = stripTrailingSlash(left || '/');
-    return `${base === '/' ? '' : base}/${right}`;
-}
-function parentDir(value) {
-    const dir = stripTrailingSlash(value);
-    if (dir === '/')
-        return dir;
-    const index = dir.lastIndexOf('/');
-    return index <= 0 ? '/' : dir.slice(0, index);
-}
-function stripTrailingSlash(value) {
-    return value.replace(/\/+$/, '') || '/';
-}
-export {};
-//# sourceMappingURL=sks.js.map

package/dist/cli/command-manifest-lite.js

@@ -0,0 +1,129 @@
+export const COMMAND_MANIFEST_LITE = [
+    { name: 'help', summary: 'Show SKS help', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'version', summary: 'Show SKS version', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'commands', summary: 'List SKS commands', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'check', summary: 'Run five-minute proof-bank affected checks', maturity: 'stable', skipMigrationGate: true },
+    { name: 'gates', summary: 'Run release gate DAG by gate id or preset', maturity: 'stable', skipMigrationGate: true },
+    { name: 'task', summary: 'Run an SLA-bounded SKS task check', maturity: 'stable', skipMigrationGate: true },
+    { name: 'release', summary: 'Run affected/full/background release gates', maturity: 'stable', skipMigrationGate: true },
+    { name: 'triwiki', summary: 'Inspect TriWiki index, affected graph, and proof bank', maturity: 'stable', skipMigrationGate: true },
+    { name: 'daemon', summary: 'Inspect or warm the local SKS daemon cache', maturity: 'stable', skipMigrationGate: true },
+    { name: 'run', summary: 'Classify and execute a task through the SKS trust kernel', maturity: 'beta' },
+    { name: 'plan', summary: 'Write a planning-only SKS plan artifact without code edits', maturity: 'stable' },
+    { name: 'status', summary: 'Show concise active mission and trust status', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'review', summary: 'Review a git diff with machine evidence first', maturity: 'stable', allowedDuringActiveRoute: true },
+    { name: 'ui', summary: 'Open the localhost SKS swarm dashboard', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'root', summary: 'Show active SKS root', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'update', summary: 'Update the global SKS npm package', maturity: 'stable' },
+    { name: 'uninstall', summary: 'Uninstall SKS global skills, hooks, config, menu bar, and optional project residue', maturity: 'stable', allowedDuringActiveRoute: true },
+    { name: 'update-check', summary: 'Check npm package freshness', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'wizard', summary: 'Open setup wizard help', maturity: 'stable' },
+    { name: 'usage', summary: 'Show focused usage topic', maturity: 'stable', readonly: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'quickstart', summary: 'Show quickstart flow', maturity: 'stable' },
+    { name: 'setup', summary: 'Initialize SKS state', maturity: 'stable' },
+    { name: 'bootstrap', summary: 'Initialize SKS project files', maturity: 'stable' },
+    { name: 'init', summary: 'Initialize local control surface', maturity: 'stable' },
+    { name: 'deps', summary: 'Check local dependencies', maturity: 'stable' },
+    { name: 'fix-path', summary: 'Repair hook command paths', maturity: 'stable' },
+    { name: 'doctor', summary: 'Check and repair SKS install', maturity: 'stable', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'git', summary: 'Inspect and enforce SKS git collaboration hygiene', maturity: 'beta' },
+    { name: 'paths', summary: 'Inspect SKS managed paths', maturity: 'beta', readonly: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'rollback', summary: 'List or apply managed-path rollback actions', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'postinstall', summary: 'Run postinstall bootstrap', maturity: 'stable', skipMigrationGate: true },
+    { name: 'codex', summary: 'Check Codex CLI compatibility and vendored hook schemas', maturity: 'beta', skipMigrationGate: true },
+    { name: 'codex-app', summary: 'Check Codex App readiness', maturity: 'beta' },
+    { name: 'codex-native', summary: 'Inspect Codex Native broker and routing readiness', maturity: 'beta' },
+    { name: 'codex-lb', summary: 'Inspect codex-lb status and circuit health', maturity: 'beta' },
+    { name: 'menubar', summary: 'Inspect/install/restart/uninstall SKS menu bar', maturity: 'beta', allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'hooks', summary: 'Explain and inspect Codex hooks', maturity: 'beta' },
+    { name: 'tmux', summary: 'Show removed-runtime migration notice', maturity: 'beta' },
+    { name: 'zellij-lane', summary: 'Render a Zellij lane frame for SKS sessions', maturity: 'beta' },
+    { name: 'zellij-slot-pane', summary: 'Render a compact Zellij worker slot pane', maturity: 'beta' },
+    { name: 'zellij-monitor-pane', summary: 'Render the live Zellij MAD/Naruto monitor pane', maturity: 'beta', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'zellij-viewport-pane', summary: 'Render a dynamically bound Zellij worker viewport pane', maturity: 'beta', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'zellij-slot-column-anchor', summary: 'Render the compact SLOTS anchor pane for first-slot-down Zellij stacks', maturity: 'beta' },
+    { name: 'zellij', summary: 'Inspect Zellij runtime status and explain repair (no auto-install)', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'mad-sks', summary: 'MAD-SKS scoped permission modifier + SQL-plane execution (merged MAD-DB)', maturity: 'beta', mutatesRouteState: true },
+    { name: 'glm', summary: 'Run GLM 5.2 MAD mode through OpenRouter', maturity: 'beta' },
+    { name: 'mad-db', summary: 'Deprecated alias for MAD-SKS SQL-plane execution; redirects to sks mad-sks sql|apply-migration', maturity: 'beta', mutatesRouteState: true, deprecated: true },
+    { name: 'auto-review', summary: 'Manage auto-review profile', maturity: 'beta' },
+    { name: 'dollar-commands', summary: 'List Codex App dollar commands', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'fast-mode', summary: 'Toggle SKS Fast mode default for dollar-command routes', maturity: 'stable', skipMigrationGate: true },
+    { name: 'commit', summary: 'Create a simple git commit', maturity: 'stable' },
+    { name: 'commit-and-push', summary: 'Create a simple git commit and push', maturity: 'stable' },
+    { name: 'dfix', summary: 'Run DFix diagnose/plan/patch/verify loop', maturity: 'stable', mutatesRouteState: true },
+    { name: 'team', summary: 'Deprecated alias. New execution redirects to Naruto; legacy observe/watch remains.', maturity: 'beta', mutatesRouteState: true, deprecated: true },
+    { name: 'agent', summary: 'Run native multi-session agent missions', maturity: 'beta', mutatesRouteState: true },
+    { name: 'with-local-llm', summary: 'Enable or inspect local Ollama worker backend', maturity: 'beta' },
+    { name: 'naruto', summary: 'Run $Naruto shadow-clone swarm (up to 100 parallel sessions)', maturity: 'labs', mutatesRouteState: true },
+    { name: 'stop-gate', summary: 'Check canonical stop-gate resolution for a route/mission', maturity: 'beta', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'route', summary: 'Inspect or close active route state', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'loop', summary: 'Dynamic Loop Runtime: plan/run/status/proof loop graphs.', maturity: 'labs', mutatesRouteState: true },
+    { name: 'qa-loop', summary: 'Run QA loop missions', maturity: 'beta', mutatesRouteState: true },
+    { name: 'research', summary: 'Run research missions', maturity: 'labs', mutatesRouteState: true },
+    { name: 'autoresearch', summary: 'Alias for research/autoresearch route', maturity: 'labs', mutatesRouteState: true },
+    { name: 'ppt', summary: 'Inspect/build PPT artifacts', maturity: 'labs', mutatesRouteState: true },
+    { name: 'image-ux-review', summary: 'Inspect image UX artifacts', maturity: 'labs', mutatesRouteState: true },
+    { name: 'computer-use', summary: 'Record native Mac/non-web Computer Use visual evidence', maturity: 'beta', mutatesRouteState: true },
+    { name: 'context7', summary: 'Context7 checks and docs', maturity: 'beta' },
+    { name: 'super-search', summary: 'Run Super-Search provider-independent source intelligence', maturity: 'beta' },
+    { name: 'xai', summary: 'Deprecated compatibility notice for removed xAI/Grok setup', maturity: 'beta', deprecated: true },
+    { name: 'recallpulse', summary: 'RecallPulse evidence route', maturity: 'labs' },
+    { name: 'pipeline', summary: 'Inspect pipeline missions', maturity: 'beta', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'guard', summary: 'Check harness guard', maturity: 'beta' },
+    { name: 'conflicts', summary: 'Check harness conflicts', maturity: 'beta' },
+    { name: 'versioning', summary: 'Manage release version metadata', maturity: 'stable' },
+    { name: 'reasoning', summary: 'Show reasoning route', maturity: 'labs' },
+    { name: 'aliases', summary: 'Show command aliases', maturity: 'stable' },
+    { name: 'selftest', summary: 'Run local mock selftest', maturity: 'stable' },
+    { name: 'goal', summary: 'Manage Goal bridge workflow', maturity: 'beta', mutatesRouteState: true },
+    { name: 'seo-geo-optimizer', summary: 'Run unified SEO/GEO optimizer audit/plan/apply/verify on the search-visibility kernel', maturity: 'beta' },
+    { name: 'hook', summary: 'Codex hook entrypoint', maturity: 'beta', skipMigrationGate: true },
+    { name: 'profile', summary: 'Inspect/set profile', maturity: 'labs' },
+    { name: 'hproof', summary: 'Evaluate H-Proof gate', maturity: 'beta' },
+    { name: 'validate-artifacts', summary: 'Validate mission artifacts', maturity: 'beta' },
+    { name: 'proof', summary: 'Show and validate completion proof', maturity: 'beta' },
+    { name: 'trust', summary: 'Report and validate route trust kernel evidence', maturity: 'beta' },
+    { name: 'wrongness', summary: 'Record and inspect TriWiki wrongness negative evidence', maturity: 'beta' },
+    { name: 'proof-field', summary: 'Scan proof field', maturity: 'beta' },
+    { name: 'skill-dream', summary: 'Track skill dream counters', maturity: 'labs' },
+    { name: 'code-structure', summary: 'Scan source structure', maturity: 'labs' },
+    { name: 'rust', summary: 'Inspect optional Rust accelerator status and smoke parity', maturity: 'beta' },
+    { name: 'gx', summary: 'Render/validate GX cartridges', maturity: 'labs' },
+    { name: 'db', summary: 'Inspect DB safety policy', maturity: 'beta' },
+    { name: 'eval', summary: 'Run eval reports', maturity: 'labs' },
+    { name: 'harness', summary: 'Run harness fixtures', maturity: 'labs' },
+    { name: 'wiki', summary: 'Manage TriWiki and image voxel ledgers', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'memory', summary: 'Project TriWiki memory into managed AGENTS.md blocks or run memory GC', maturity: 'beta' },
+    { name: 'gc', summary: 'Compact/prune runtime state', maturity: 'labs', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
+    { name: 'stats', summary: 'Show storage stats', maturity: 'labs', readonly: true, diagnostic: true },
+    { name: 'features', summary: 'Validate feature registry', maturity: 'beta' },
+    { name: 'all-features', summary: 'Run all-features selftest', maturity: 'beta' },
+    { name: 'perf', summary: 'Run performance checks', maturity: 'beta' },
+    { name: 'bench', summary: 'Run core trust-kernel benchmark budgets', maturity: 'beta' },
+    { name: 'mcp-server', summary: 'Run a stdio MCP server exposing SKS commands as tools for any MCP-capable agent host', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true },
+    { name: 'agent-bridge', summary: 'Publish the agent-bridge manifest and print host registration snippets for external agent systems', maturity: 'beta', readonly: true, diagnostic: true }
+];
+export const LEGACY_COMMAND_ALIASES_LITE = {};
+export const COMMAND_ALIASES_LITE = {
+    ...LEGACY_COMMAND_ALIASES_LITE,
+    '--help': 'help',
+    '-h': 'help',
+    '--version': 'version',
+    '-v': 'version',
+    '--mad': 'mad-sks',
+    '--MAD': 'mad-sks',
+    '--mad-sks': 'mad-sks',
+    'ux-review': 'image-ux-review',
+    'visual-review': 'image-ux-review',
+    'ui-ux-review': 'image-ux-review',
+    '--agent': 'agent',
+    '--naruto': 'naruto',
+    swarm: 'naruto'
+};
+export const COMMAND_MANIFEST_BY_NAME = Object.fromEntries(COMMAND_MANIFEST_LITE.map((entry) => [entry.name, entry]));
+export const COMMAND_NAME_SET = new Set(COMMAND_MANIFEST_LITE.map((entry) => entry.name));
+export function commandManifestNames() {
+    return COMMAND_MANIFEST_LITE.map((entry) => entry.name).sort();
+}
+//# sourceMappingURL=command-manifest-lite.js.map

package/dist/cli/commands-fast.js

@@ -1,7 +1,7 @@
-import { COMMANDS } from './command-registry.js';
+import { COMMAND_MANIFEST_LITE } from './command-manifest-lite.js';
 export function commandsJsonFast() {
-    const commands = Object.entries(COMMANDS)
-        .map(([name, entry]) => fastCommandRow(name, entry))
+    const commands = COMMAND_MANIFEST_LITE
+        .map((entry) => fastCommandRow(entry))
         .sort((a, b) => a.name.localeCompare(b.name));
     console.log(JSON.stringify({
         schema: 'sks.command-registry.v1',
@@ -9,12 +9,21 @@ export function commandsJsonFast() {
         commands
     }, null, 2));
 }
-function fastCommandRow(name, entry) {
-    return {
-        name,
-        usage: `sks ${name}`,
+function fastCommandRow(entry) {
+    const row = {
+        name: entry.name,
+        usage: `sks ${entry.name}`,
         description: entry.summary,
         maturity: entry.maturity
     };
+    if (entry.readonly === true)
+        row.readonly = true;
+    if (entry.mutatesRouteState === true)
+        row.mutating = true;
+    if (entry.deprecated === true)
+        row.deprecated = true;
+    if (entry.hidden === true)
+        row.hidden = true;
+    return row;
 }
 //# sourceMappingURL=commands-fast.js.map

package/dist/cli/help-fast.js

@@ -1,9 +1,8 @@
-import { COMMANDS } from './command-registry.js';
-import { PACKAGE_VERSION } from '../core/version.js';
-import { COMMAND_CATALOG } from '../core/routes.js';
+import { COMMAND_MANIFEST_LITE } from './command-manifest-lite.js';
+const FAST_PACKAGE_VERSION = '5.10.0';
 export function helpFast() {
     console.log(`SKS
-SNEAKOSCOPE CODEX v${PACKAGE_VERSION}
+SNEAKOSCOPE CODEX v${FAST_PACKAGE_VERSION}
 
 3-pillar frontdoor
 
@@ -29,12 +28,11 @@ Discovery
     console.log('\nRun `sks commands` for the full catalog. Core promise: machine-verified completion, not vibes.');
 }
 function commandRows() {
-    const registry = new Map(Object.entries(COMMANDS).map(([name, meta]) => [name, meta]));
-    return COMMAND_CATALOG.map((entry) => ({
+    return COMMAND_MANIFEST_LITE.map((entry) => ({
         name: entry.name,
-        usage: entry.usage,
-        description: entry.description,
-        maturity: registry.get(entry.name)?.maturity || entry.maturity || 'labs'
+        usage: `sks ${entry.name}`,
+        description: entry.summary,
+        maturity: entry.maturity
     })).sort((a, b) => a.name.localeCompare(b.name));
 }
 //# sourceMappingURL=help-fast.js.map

package/dist/cli/router.js

@@ -1,16 +1,13 @@
-import { COMMAND_ALIASES, COMMANDS, } from './command-registry.js';
+import { COMMAND_ALIASES_LITE, COMMAND_MANIFEST_BY_NAME, COMMAND_NAME_SET, } from './command-manifest-lite.js';
 import { detectGlobalMode, glmWithoutMadResult } from './global-mode-router.js';
-import { ensureCurrentMigrationBeforeCommand } from '../core/update/update-migration-state.js';
-import { projectRoot, readJson } from '../core/fsx.js';
-import { stateFile } from '../core/mission.js';
 export function isCommandName(value) {
-    return Object.prototype.hasOwnProperty.call(COMMANDS, value);
+    return COMMAND_NAME_SET.has(value);
 }
 export function normalizeCommand(args = []) {
     const cmd = args[0];
     if (!cmd)
         return { command: null, rawCommand: null, aliasTarget: null, args: [...args] };
-    const mapped = cmd in COMMAND_ALIASES ? COMMAND_ALIASES[cmd] : cmd;
+    const mapped = cmd in COMMAND_ALIASES_LITE ? COMMAND_ALIASES_LITE[cmd] : cmd;
     const rest = args.slice(1);
     const command = isCommandName(mapped) ? mapped : null;
     return {
@@ -78,13 +75,14 @@ async function dispatchInner(argv) {
         };
         return result;
     }
-    const entry = COMMANDS[command];
+    const entry = COMMAND_MANIFEST_BY_NAME[command];
     const commandGate = await ensureActiveRouteCommandGate(command, rest);
     if (!commandGate.ok) {
         console.error(commandGate.message);
         process.exitCode = 1;
         return commandGate;
     }
+    const { ensureCurrentMigrationBeforeCommand } = await import('../core/update/update-migration-state.js');
     const migrationGate = await ensureCurrentMigrationBeforeCommand({
         command,
         args: rest,
@@ -105,13 +103,15 @@ async function dispatchInner(argv) {
         process.exitCode = 1;
         return migrationGate;
     }
-    const mod = await entry.lazy();
+    const { COMMANDS } = await import('./command-registry.js');
+    const commandEntry = COMMANDS[command];
+    const mod = await commandEntry.lazy();
     if (typeof mod.run !== 'function')
         throw new Error(`Command ${command} must export run(command, args)`);
     return mod.run(rawCommand || command, rest);
 }
 async function ensureActiveRouteCommandGate(command, args) {
-    const entry = COMMANDS[command];
+    const entry = COMMAND_MANIFEST_BY_NAME[command];
     if (command === 'route' || entry.readonly === true || entry.allowedDuringActiveRoute === true && entry.mutatesRouteState !== true) {
         return { ok: true, status: 'allowed' };
     }
@@ -122,6 +122,10 @@ async function ensureActiveRouteCommandGate(command, args) {
     if (process.env.SKS_TEST_ISOLATION === '1' && process.env.SKS_RELEASE_FIXTURE_ACTIVE_ROUTE_BYPASS === '1') {
         return { ok: true, status: 'allowed_release_fixture_isolation' };
     }
+    const [{ projectRoot, readJson }, { stateFile }] = await Promise.all([
+        import('../core/fsx.js'),
+        import('../core/mission.js')
+    ]);
     const root = await projectRoot(process.cwd()).catch(() => process.cwd());
     const state = await readJson(stateFile(root), {}).catch(() => ({}));
     if (!activeRouteStateBlocksCommand(state))