sneakoscope 5.7.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.7.0**. New in this release: repaired Codex App menu bar persistence and Fast Mode actions, codex-lb Fast Mode defaults pinned to the required current Codex model, legacy upgrade repair through `sks update` and `sks doctor --fix`, and a safer `npm publish --ignore-scripts` wrapper that runs the release gates before lifecycle-disabled publish. 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.7.0"
+version = "5.9.0"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "5.7.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.7.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.7.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

@@ -161,8 +161,7 @@ export const COMMANDS = {
     'image-ux-review': routeStateMutator(entry('labs', 'Inspect image UX artifacts', 'dist/core/commands/image-ux-review-command.js', commandArgsCommand(() => import('../core/commands/image-ux-review-command.js'), 'imageUxReviewCommand', 'dist/core/commands/image-ux-review-command.js')), ['image-ux-review-gate.json']),
     'computer-use': routeStateMutator(entry('beta', 'Record native Mac/non-web Computer Use visual evidence', 'dist/core/commands/computer-use-command.js', commandArgsCommand(() => import('../core/commands/computer-use-command.js'), 'computerUseCommand', 'dist/core/commands/computer-use-command.js')), ['computer-use-gate.json']),
     context7: entry('beta', 'Context7 checks and docs', 'dist/cli/context7-command.js', subcommand(() => import('./context7-command.js'), 'context7Command', 'dist/cli/context7-command.js', 'check')),
-    'insane-search': entry('beta', 'Run provider-independent InsaneSearch source intelligence', 'dist/cli/insane-search-command.js', subcommand(() => import('./insane-search-command.js'), 'insaneSearchCommand', 'dist/cli/insane-search-command.js', 'doctor')),
-    'ultra-search': entry('beta', 'Compatibility alias for InsaneSearch source intelligence', 'dist/cli/insane-search-command.js', subcommand(() => import('./insane-search-command.js'), 'ultraSearchCommand', 'dist/cli/insane-search-command.js', 'doctor')),
+    'super-search': entry('beta', 'Run Super-Search provider-independent source intelligence', 'dist/cli/super-search-command.js', subcommand(() => import('./super-search-command.js'), 'superSearchCommand', 'dist/cli/super-search-command.js', 'doctor')),
     xai: entry('beta', 'Deprecated compatibility notice for removed xAI/Grok setup', 'dist/cli/xai-command.js', subcommand(() => import('./xai-command.js'), 'xaiCommand', 'dist/cli/xai-command.js', 'check')),
     recallpulse: entry('labs', 'RecallPulse evidence route', 'dist/commands/recallpulse.js', directCommand(() => import('../commands/recallpulse.js'), 'dist/commands/recallpulse.js')),
     pipeline: activeRouteDiagnostic(entry('beta', 'Inspect pipeline missions', 'dist/commands/pipeline.js', directCommand(() => import('../commands/pipeline.js'), 'dist/commands/pipeline.js'))),
@@ -174,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

@@ -0,0 +1,221 @@
+import fs from 'node:fs/promises';
+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 = []) {
+    const action = sub || 'help';
+    if (action === 'run')
+        return runCommand(args);
+    if (action === 'x')
+        return runCommand(['--mode', 'x_search', ...args]);
+    if (action === 'fetch')
+        return runCommand(['--mode', 'url_acquisition', ...args]);
+    if (action === 'doctor')
+        return doctorCommand(args);
+    if (action === 'status' || action === 'inspect' || action === 'sources' || action === 'claims')
+        return inspectCommand(action, args);
+    if (action === 'cache')
+        return cacheCommand(args);
+    if (action === 'bench')
+        return benchCommand(args);
+    return helpCommand();
+}
+async function runCommand(args) {
+    const json = args.includes('--json');
+    const mode = readOption(args, '--mode');
+    const rawQuery = positional(args).join(' ').trim();
+    const query = rawQuery || (mode === 'url_acquisition' ? 'fetch' : '');
+    if (!query)
+        throw new Error('Usage: sks super-search run "<query>" [--mode fast|balanced|deep|exhaustive] [--json]');
+    if (mode && !['fast', 'balanced', 'deep', 'exhaustive', 'x_search', 'url_acquisition'].includes(mode)) {
+        throw new Error('Unsupported Super-Search mode: ' + mode);
+    }
+    const missionDir = await mkMissionDir();
+    const result = await runSuperSearch({
+        missionDir,
+        query,
+        ...(mode ? { mode } : {})
+    });
+    const gate = await evaluateSuperSearchGate(missionDir);
+    const finalResult = {
+        ...result,
+        ok: result.ok === true && gate.ok === true,
+        blockers: [...new Set([...(result.blockers || []), ...gate.blockers])],
+        gate_evaluation: gate
+    };
+    if (json)
+        console.log(JSON.stringify(finalResult, null, 2));
+    else {
+        console.log(`Super-Search ${finalResult.ok ? 'completed' : 'partial/blocked'}: ${result.mode}`);
+        console.log(`Mission: ${missionDir}`);
+        console.log(`Sources: ${result.sources.length}, verified: ${result.proof.verified_source_count}`);
+        if (finalResult.blockers.length)
+            console.log(`Blockers: ${finalResult.blockers.join(', ')}`);
+    }
+    if (!finalResult.ok)
+        process.exitCode = 1;
+    return finalResult;
+}
+async function doctorCommand(args) {
+    const json = args.includes('--json');
+    const report = buildSuperSearchDoctorReport(args);
+    printSuperSearchDoctorReport(report, json);
+    return report;
+}
+async function inspectCommand(action, args) {
+    const json = args.includes('--json');
+    const mission = positional(args)[0] || 'latest';
+    const target = mission === 'latest' ? await latestMissionDir() : mission;
+    const file = path.join(target, 'super-search', action === 'sources' ? 'source-ledger.json' : action === 'claims' ? 'claim-ledger.json' : 'super-search-result.json');
+    const text = await fs.readFile(file, 'utf8').catch(() => null);
+    const parsed = text ? JSON.parse(text) : {
+        schema: 'sks.super-search-inspect-missing.v1',
+        ok: false,
+        mission: target,
+        blockers: ['super_search_mission_artifact_missing:' + path.relative(process.cwd(), file)]
+    };
+    const gate = await evaluateSuperSearchGate(target);
+    const evidence = await evaluateSuperSearchArtifacts(target);
+    const parsedOk = parsed.ok === false ? false : true;
+    const result = {
+        ...parsed,
+        ok: parsedOk && gate.ok === true && evidence.ok === true,
+        gate_evaluation: gate,
+        real_evidence_policy: evidence,
+        blockers: [...new Set([...(parsed.blockers || []), ...gate.blockers, ...evidence.blockers])]
+    };
+    if (!result.ok)
+        process.exitCode = 1;
+    if (json)
+        console.log(JSON.stringify(result, null, 2));
+    else
+        console.log(JSON.stringify(result, null, 2));
+    return result;
+}
+async function cacheCommand(args) {
+    const sub = positional(args)[0] || 'status';
+    const report = { schema: 'sks.super-search-cache.v1', ok: true, action: sub, local_only: true };
+    console.log(JSON.stringify(report, null, 2));
+    return report;
+}
+async function benchCommand(args) {
+    const report = {
+        schema: 'sks.super-search-bench.v1',
+        ok: false,
+        suite: readOption(args, '--suite') || 'all',
+        status: 'real_benchmark_not_run',
+        blockers: ['real_web_or_x_parity_corpus_required']
+    };
+    console.log(JSON.stringify(report, null, 2));
+    return report;
+}
+function helpCommand() {
+    console.log([
+        'Usage:',
+        '  sks super-search doctor [--json]',
+        '  sks super-search run "<query>" [--mode fast|balanced|deep|exhaustive] [--json]',
+        '  sks super-search x "<query>" [--json]',
+        '  sks super-search fetch "<url>" [--json]',
+        '  sks super-search status|inspect|sources|claims <mission|latest> [--json]',
+        '  sks super-search cache status|prune|clear [--json]',
+        '  sks super-search bench [--suite all|x|web|docs|blocked] [--json]'
+    ].join('\n'));
+    return { ok: true, status: 'help' };
+}
+function readOption(args, flag) {
+    const index = args.indexOf(flag);
+    const value = index >= 0 ? args[index + 1] : undefined;
+    return value || null;
+}
+function positional(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const value = args[i];
+        if (!value)
+            continue;
+        if (value.startsWith('--')) {
+            if (value !== '--json')
+                i++;
+            continue;
+        }
+        out.push(value);
+    }
+    return out;
+}
+async function mkMissionDir() {
+    const dir = path.join(process.cwd(), '.sneakoscope', 'missions', `super-search-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`);
+    await fs.mkdir(dir, { recursive: true });
+    return dir;
+}
+async function latestMissionDir() {
+    const root = path.join(process.cwd(), '.sneakoscope', 'missions');
+    const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(root, entry.name)).sort();
+    let latest = null;
+    for (const dir of dirs.reverse()) {
+        if (await hasSuperSearchArtifactDir(dir)) {
+            latest = dir;
+            break;
+        }
+    }
+    if (!latest)
+        return path.join(os.tmpdir(), 'sks-super-search-missing');
+    return latest;
+}
+async function hasSuperSearchArtifactDir(dir) {
+    try {
+        const stat = await fs.stat(path.join(dir, 'super-search'));
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function evaluateSuperSearchGate(missionDir) {
+    return evaluateLocalGate({
+        root: process.cwd(),
+        dir: missionDir,
+        gateFile: path.join('super-search', 'super-search-gate.json'),
+        requiredArtifacts: [
+            path.join('super-search', 'source-ledger.json'),
+            path.join('super-search', 'claim-ledger.json'),
+            path.join('super-search', 'super-search-proof.json'),
+            path.join('super-search', 'super-search-result.json')
+        ]
+    });
+}
+async function evaluateSuperSearchArtifacts(missionDir) {
+    const artifactDir = path.join(missionDir, 'super-search');
+    const [result, sourceLedger, claimLedger, proof] = await Promise.all([
+        readJsonFile(path.join(artifactDir, 'super-search-result.json')),
+        readJsonFile(path.join(artifactDir, 'source-ledger.json')),
+        readJsonFile(path.join(artifactDir, 'claim-ledger.json')),
+        readJsonFile(path.join(artifactDir, 'super-search-proof.json'))
+    ]);
+    const sources = Array.isArray(result?.sources) ? result.sources : Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : [];
+    const claims = Array.isArray(result?.claims) ? result.claims : Array.isArray(claimLedger?.claims) ? claimLedger.claims : [];
+    const proofData = result?.proof || proof || {};
+    return evaluateRealEvidencePolicy({
+        productionMode: true,
+        mode: result?.mode || proofData?.mode,
+        sources,
+        claims,
+        proof: proofData
+    });
+}
+async function readJsonFile(file) {
+    const text = await fs.readFile(file, 'utf8').catch(() => null);
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=super-search-command.js.map

package/dist/cli/xai-command.js

@@ -9,19 +9,19 @@ export async function xaiCommand(sub = 'check', args = []) {
         setup_performed: false,
         xai_required: false,
         replacement: {
-            doctor: 'sks insane-search doctor',
-            x_search: 'sks insane-search x "<query>"',
-            migration: 'sks insane-search migrate-xai [--apply]'
+            doctor: 'sks super-search doctor',
+            x_search: 'sks super-search x "<query>"',
+            fetch: 'sks super-search fetch "<url>"'
         },
-        blockers: action === 'setup' ? ['xai_setup_removed_use_ultra_search'] : [],
+        blockers: action === 'setup' ? ['xai_setup_removed_use_super_search'] : [],
         warnings: ['sks_xai_is_deprecated_and_does_not_configure_mcp_or_require_XAI_API_KEY']
     };
     if (json)
         console.log(JSON.stringify(result, null, 2));
     else {
-        console.log('`sks xai` is deprecated. InsaneSearch no longer requires xAI/Grok or XAI_API_KEY.');
-        console.log('Use: sks insane-search doctor');
-        console.log('Use: sks insane-search x "<query>"');
+        console.log('`sks xai` is deprecated. Super-Search no longer requires xAI/Grok or XAI_API_KEY.');
+        console.log('Use: sks super-search doctor');
+        console.log('Use: sks super-search x "<query>"');
         if (action === 'setup') {
             console.log('No MCP setup was performed.');
             process.exitCode = 1;