sneakoscope 5.8.0 → 5.9.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.8.0**. New in this release: intent routing no longer treats every question mark as answer-only, Naruto parallel-write proof now requires real worker/file/timestamp evidence, production gates reject mock-only or source-less success, and the fragmented legacy search surface is replaced by the canonical `sks super-search` / `$Super-Search` path. See [CHANGELOG.md](CHANGELOG.md).
+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).
 
 ## Install
 

package/config/competitor-scorecard-baseline.json

@@ -0,0 +1,97 @@
+{
+  "schema": "sks.competitor-scorecard-baseline.v1",
+  "target": {
+    "total_min": 94,
+    "each_min": 90
+  },
+  "categories": {
+    "code_stability": [
+      {
+        "id": "doctor-idempotence",
+        "path": ".sneakoscope/reports/doctor-idempotence.json"
+      },
+      {
+        "id": "super-search-offline-contract",
+        "path": ".sneakoscope/reports/super-search-offline-contract.json"
+      },
+      {
+        "id": "route-regression",
+        "path": ".sneakoscope/reports/route-regression.json"
+      }
+    ],
+    "test_release_gates": [
+      {
+        "id": "release-readiness",
+        "path": ".sneakoscope/reports/release-readiness-5.9.0.json"
+      },
+      {
+        "id": "installed-package-smoke",
+        "path": ".sneakoscope/reports/installed-package-smoke.json"
+      },
+      {
+        "id": "release-gate-timing",
+        "path": ".sneakoscope/reports/gate-timing.json"
+      }
+    ],
+    "parallel_isolation": [
+      {
+        "id": "parallel-runtime-proof",
+        "path": ".sneakoscope/reports/parallel-production-smoke.json"
+      },
+      {
+        "id": "worktree-runtime",
+        "path": ".sneakoscope/reports/parallel-production-smoke.json"
+      },
+      {
+        "id": "patch-merge-proof",
+        "path": ".sneakoscope/reports/parallel-production-smoke.json"
+      }
+    ],
+    "speed_performance": [
+      {
+        "id": "perf-budget",
+        "path": ".sneakoscope/reports/perf-budget.json"
+      },
+      {
+        "id": "hook-latency-quantum",
+        "path": ".sneakoscope/reports/hook-latency-quantum.json"
+      },
+      {
+        "id": "gate-timing",
+        "path": ".sneakoscope/reports/gate-timing.json"
+      }
+    ],
+    "install_operations": [
+      {
+        "id": "installed-package-smoke",
+        "path": ".sneakoscope/reports/installed-package-smoke.json"
+      },
+      {
+        "id": "doctor-idempotence",
+        "path": ".sneakoscope/reports/doctor-idempotence.json"
+      },
+      {
+        "id": "package-surface-budget",
+        "path": ".sneakoscope/reports/package-surface-budget.json"
+      }
+    ],
+    "maintainability": [
+      {
+        "id": "architecture-check",
+        "command": "architecture:check"
+      },
+      {
+        "id": "route-modularity-check",
+        "command": "route-modularity:check"
+      },
+      {
+        "id": "command-budget-check",
+        "command": "command-budget:check"
+      },
+      {
+        "id": "package-surface-budget",
+        "path": ".sneakoscope/reports/package-surface-budget.json"
+      }
+    ]
+  }
+}

package/config/perf-budgets.v1.json

@@ -0,0 +1,10 @@
+{
+  "schema": "sks.perf-budgets.v1",
+  "commands": [
+    { "name": "version", "argv": ["node", "./dist/bin/sks.js", "--version"], "budget_p50_ms": 170, "budget_p95_ms": 180 },
+    { "name": "commands-json", "argv": ["node", "./dist/bin/sks.js", "commands", "--json"], "budget_p50_ms": 260, "budget_p95_ms": 320 },
+    { "name": "root-json", "argv": ["node", "./dist/bin/sks.js", "root", "--json"], "budget_p50_ms": 170, "budget_p95_ms": 220 },
+    { "name": "doctor-json", "argv": ["node", "./dist/bin/sks.js", "doctor", "--json"], "budget_p50_ms": 2000, "budget_p95_ms": 2500 },
+    { "name": "super-search-doctor-json", "argv": ["node", "./dist/bin/sks.js", "super-search", "doctor", "--json"], "budget_p50_ms": 180, "budget_p95_ms": 240 }
+  ]
+}

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "5.8.0"
+version = "5.9.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.8.0"),
+        Some("--version") => println!("sks-rs 5.9.0"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '5.8.0';
+const FAST_PACKAGE_VERSION = '5.9.0';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {
@@ -9,6 +9,20 @@ try {
     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');
@@ -29,5 +43,51 @@ catch (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-registry.js

@@ -173,7 +173,7 @@ export const COMMANDS = {
     selftest: entry('stable', 'Run local mock selftest', 'dist/core/commands/basic-cli.js', basicArgs('selftestCommand')),
     goal: routeStateMutator(entry('beta', 'Manage Goal bridge workflow', 'dist/core/commands/goal-command.js', subcommand(() => import('../core/commands/goal-command.js'), 'goalCommand', 'dist/core/commands/goal-command.js')), ['loop-graph-proof.json']),
     'seo-geo-optimizer': entry('beta', 'Run unified SEO/GEO optimizer audit/plan/apply/verify on the search-visibility kernel', 'dist/core/commands/seo-command.js', argsCommand(() => import('../core/commands/seo-command.js'), 'seoGeoOptimizerCommand', 'dist/core/commands/seo-command.js')),
-    hook: entry('beta', 'Codex hook entrypoint', 'dist/commands/hook.js', directCommand(() => import('../commands/hook.js'), 'dist/commands/hook.js')),
+    hook: skipMigrationGate(entry('beta', 'Codex hook entrypoint', 'dist/commands/hook.js', directCommand(() => import('../commands/hook.js'), 'dist/commands/hook.js'))),
     profile: entry('labs', 'Inspect/set profile', 'dist/commands/profile.js', directCommand(() => import('../commands/profile.js'), 'dist/commands/profile.js')),
     hproof: entry('beta', 'Evaluate H-Proof gate', 'dist/commands/hproof.js', directCommand(() => import('../commands/hproof.js'), 'dist/commands/hproof.js')),
     'validate-artifacts': entry('beta', 'Validate mission artifacts', 'dist/core/commands/validate-artifacts-command.js', argsCommand(() => import('../core/commands/validate-artifacts-command.js'), 'validateArtifactsCommand', 'dist/core/commands/validate-artifacts-command.js')),

package/dist/cli/commands-fast.js

@@ -0,0 +1,20 @@
+import { COMMANDS } from './command-registry.js';
+export function commandsJsonFast() {
+    const commands = Object.entries(COMMANDS)
+        .map(([name, entry]) => fastCommandRow(name, entry))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    console.log(JSON.stringify({
+        schema: 'sks.command-registry.v1',
+        aliases: ['sks', 'sneakoscope'],
+        commands
+    }, null, 2));
+}
+function fastCommandRow(name, entry) {
+    return {
+        name,
+        usage: `sks ${name}`,
+        description: entry.summary,
+        maturity: entry.maturity
+    };
+}
+//# sourceMappingURL=commands-fast.js.map

package/dist/cli/root-fast.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+export function rootJsonFast(cwd = process.cwd()) {
+    const project = findProjectRootSync(cwd);
+    const global = joinPath(process.env.HOME || process.env.USERPROFILE || cwd, '.sneakoscope');
+    const active = project || global;
+    console.log(JSON.stringify({
+        cwd,
+        mode: project ? 'project' : 'global',
+        active_root: active,
+        project_root: project,
+        global_root: global,
+        using_global_root: !project
+    }, null, 2));
+}
+function findProjectRootSync(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(/\/+$/, '') || '/';
+}
+//# sourceMappingURL=root-fast.js.map

package/dist/cli/router.js

@@ -119,6 +119,9 @@ async function ensureActiveRouteCommandGate(command, args) {
         return { ok: true, status: 'allowed' };
     if (safeReadOnlySubcommand(args))
         return { ok: true, status: 'allowed_status_subcommand' };
+    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 root = await projectRoot(process.cwd()).catch(() => process.cwd());
     const state = await readJson(stateFile(root), {}).catch(() => ({}));
     if (!activeRouteStateBlocksCommand(state))

package/dist/cli/super-search-command.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { runSuperSearch } from '../core/super-search/index.js';
+import { buildSuperSearchDoctorReport, printSuperSearchDoctorReport } from '../core/super-search/doctor.js';
 import { evaluateLocalGate } from '../core/commands/route-success-helpers.js';
 import { evaluateRealEvidencePolicy } from '../core/verification/real-evidence-policy.js';
 export async function superSearchCommand(sub = 'help', args = []) {
@@ -61,24 +62,8 @@ async function runCommand(args) {
 }
 async function doctorCommand(args) {
     const json = args.includes('--json');
-    const report = {
-        schema: 'sks.super-search-doctor.v1',
-        ok: true,
-        core_ready: true,
-        xai_required: false,
-        optional: {
-            context7: 'external_runtime_optional_by_intent',
-            codex_web: process.env.SKS_CODEX_WEB_SEARCH_AVAILABLE === '1' || process.env.CODEX_WEB_SEARCH_AVAILABLE === '1' ? 'available' : 'not_bound',
-            authenticated_chrome: 'operator_consented_optional',
-            official_x_api: 'credentials_optional_not_required'
-        },
-        blockers: [],
-        warnings: []
-    };
-    if (json)
-        console.log(JSON.stringify(report, null, 2));
-    else
-        console.log('Super-Search doctor: core ready; xAI/Grok is not required.');
+    const report = buildSuperSearchDoctorReport(args);
+    printSuperSearchDoctorReport(report, json);
     return report;
 }
 async function inspectCommand(action, args) {

package/dist/commands/doctor.js

@@ -620,6 +620,7 @@ async function runDoctor(args = [], root, doctorFix) {
     const globalSksInstallCleanup = flag(args, '--fix') && !flag(args, '--local-only')
         ? await cleanDuplicateGlobalSksInstalls({ root, fix: true }).catch((err) => ({ schema: 'sks.global-sks-install-cleanup.v1', ok: false, fix: true, error: err?.message || String(err), blockers: ['global_sks_install_cleanup_exception'] }))
         : null;
+    const shouldProbeNativeCapabilityRepairs = doctorFix || deepDiagnostics || nativeCapabilityDiagnosticsRequested;
     const imagegen = await detectImagegenCapability({ codexBin: codexBin || undefined }).catch((err) => ({ ok: false, error: err.message, auth_readiness: null, core_ready: false, blockers: ['imagegen_detection_exception'] }));
     const imagegenRepair = imagegen.core_ready === true
         ? {
@@ -635,33 +636,47 @@ async function runDoctor(args = [], root, doctorFix) {
             manual_actions: [],
             communication_test: { level: 'flag_level', ok: true, checked: 'codex features list --json (feature-flag/plugin metadata only)', real_generation_round_trip_performed: false, blocker: null }
         }
-        : await repairCodexImagegen({ root, apply: doctorFix, codexBin: codexBin || null }).catch((err) => ({
-            schema: 'sks.doctor-imagegen-repair.v1',
+        : shouldProbeNativeCapabilityRepairs
+            ? await repairCodexImagegen({ root, apply: doctorFix, codexBin: codexBin || null }).catch((err) => ({
+                schema: 'sks.doctor-imagegen-repair.v1',
+                ok: false,
+                attempted: true,
+                apply: doctorFix,
+                recovered: false,
+                blockers: [err?.message || String(err)],
+                manual_actions: ['Run `sks doctor --fix --json` after enabling Codex App image_generation.']
+            }))
+            : deferredNativeRepair('sks.doctor-imagegen-repair.v1', doctorFix, [
+                'Run `sks doctor --fix --repair-native-capabilities --json` after enabling Codex App image_generation.'
+            ]);
+    const computerUseRepair = shouldProbeNativeCapabilityRepairs
+        ? await repairComputerUse({ root, apply: doctorFix, codexBin: codexBin || null }).catch((err) => ({
+            schema: 'sks.doctor-computer-use-repair.v1',
             ok: false,
-            attempted: true,
+            attempted: false,
             apply: doctorFix,
             recovered: false,
             blockers: [err?.message || String(err)],
-            manual_actions: ['Run `sks doctor --fix --json` after enabling Codex App image_generation.']
-        }));
-    const computerUseRepair = await repairComputerUse({ root, apply: doctorFix, codexBin: codexBin || null }).catch((err) => ({
-        schema: 'sks.doctor-computer-use-repair.v1',
-        ok: false,
-        attempted: false,
-        apply: doctorFix,
-        recovered: false,
-        blockers: [err?.message || String(err)],
-        next_actions: ['Run `sks doctor --fix --json` after checking Codex App settings for Computer Use.']
-    }));
-    const browserUseRepair = await repairBrowserUse({ root, apply: doctorFix, codexBin: codexBin || null }).catch((err) => ({
-        schema: 'sks.doctor-browser-use-repair.v1',
-        ok: false,
-        attempted: false,
-        apply: doctorFix,
-        recovered: false,
-        blockers: [err?.message || String(err)],
-        next_actions: ['Run `sks doctor --fix --json` after checking Codex App settings for Browser Use / Chrome extension.']
-    }));
+            next_actions: ['Run `sks doctor --fix --json` after checking Codex App settings for Computer Use.']
+        }))
+        : deferredNativeRepair('sks.doctor-computer-use-repair.v1', doctorFix, [
+            'Computer Use route needs manual OS/App permission verification before use.',
+            'Run `sks doctor --fix --repair-native-capabilities --json` for an explicit Computer Use repair probe.'
+        ]);
+    const browserUseRepair = shouldProbeNativeCapabilityRepairs
+        ? await repairBrowserUse({ root, apply: doctorFix, codexBin: codexBin || null }).catch((err) => ({
+            schema: 'sks.doctor-browser-use-repair.v1',
+            ok: false,
+            attempted: false,
+            apply: doctorFix,
+            recovered: false,
+            blockers: [err?.message || String(err)],
+            next_actions: ['Run `sks doctor --fix --json` after checking Codex App settings for Browser Use / Chrome extension.']
+        }))
+        : deferredNativeRepair('sks.doctor-browser-use-repair.v1', doctorFix, [
+            'Chrome/web review route needs the Codex Chrome Extension enabled before use.',
+            'Run `sks doctor --fix --repair-native-capabilities --json` for an explicit Browser Use repair probe.'
+        ]);
     const mcpTransportCollisionRepair = doctorFix
         ? await detectAndRepairMcpTransportCollisions({ root, apply: true }).catch((err) => ({
             schema: 'sks.mcp-transport-collision-repair.v1',
@@ -675,7 +690,9 @@ async function runDoctor(args = [], root, doctorFix) {
             raw_secret_values_recorded: false
         }))
         : null;
-    const nativeCapabilityReadinessStatus = (repair) => (repair?.recovered === true || repair?.ok === true ? 'ok' : repair?.attempted ? 'blocked' : 'not-needed');
+    const nativeCapabilityReadinessStatus = (repair) => repair?.skipped === true
+        ? (repair.status || 'deferred')
+        : (repair?.recovered === true || repair?.ok === true ? 'ok' : repair?.attempted ? 'blocked' : 'not-needed');
     const nativeCapabilityReadiness = {
         schema: 'sks.native-capability-readiness.v1',
         generated_at: nowIso(),
@@ -1211,6 +1228,21 @@ function buildRuntimeReadiness(zellijReadiness, matrix) {
         repair_actions: [...new Set(repairActions)]
     };
 }
+function deferredNativeRepair(schema, doctorFix, nextActions) {
+    return {
+        schema,
+        generated_at: nowIso(),
+        ok: true,
+        skipped: true,
+        status: 'deferred_to_explicit_native_capability_probe',
+        attempted: false,
+        apply: doctorFix,
+        recovered: false,
+        blockers: [],
+        next_actions: nextActions,
+        manual_actions: nextActions
+    };
+}
 function fallbackCodexNativeFeatureMatrix(codex, blockers = [], warnings = []) {
     return {
         schema: 'sks.codex-native-feature-matrix.v1',