sneakoscope 5.5.3 → 5.6.1

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: `5.3.0`.
+Current release: `5.6.0`. New in this release: a source-cited TriWiki code index/pack (`sks wiki refresh --code`) so LLMs use fewer tokens navigating a codebase, native repair for Codex Desktop's Computer Use and Browser Use features, and an agent bridge (`sks mcp-server`, `SKS_AGENT_MODE`, NDJSON `--stream`) so any agent system — not a specific one — can drive SKS's full command surface. See [docs/AGENT-BRIDGE.md](docs/AGENT-BRIDGE.md) and [CHANGELOG.md](CHANGELOG.md).
 
 ## Install
 
@@ -81,6 +81,9 @@ It shows the v5 flow: one-line install, `$Plan`, `$Work`/`$Swarm`, `sks review`,
 - Review report: `.sneakoscope/reports/review-report.json`
 - Harness benchmark: `.sneakoscope/reports/harness-benchmark.json`
 - Project memory: `sks memory build`
+- Codebase index/pack for LLM context: `sks wiki refresh --code`, `sks wiki validate --json` (code-pack freshness)
+- Native capability repair: `sks doctor --fix` (imagegen/Computer Use/Browser Use), `.sneakoscope/reports/native-capability-readiness.json`
+- Agent bridge for any agent system: `sks mcp-server`, `sks agent-bridge setup`, `SKS_AGENT_MODE=1` — see [docs/AGENT-BRIDGE.md](docs/AGENT-BRIDGE.md)
 - Release gates: `node ./dist/scripts/release-gate-dag-runner.js --preset release --full`
 - Release readiness notes: [docs/release-readiness.md](docs/release-readiness.md) and [CHANGELOG.md](CHANGELOG.md)
 - Image generation review routes require Codex App `$imagegen`/`gpt-image-2` evidence with recorded output hashes; direct API fallback and mock fixtures do not satisfy full route gates.

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "5.5.3"
+version = "5.6.1"
 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.5.3"),
+        Some("--version") => println!("sks-rs 5.6.1"),
         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.5.3';
+const FAST_PACKAGE_VERSION = '5.6.1';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/command-registry.js

@@ -196,7 +196,13 @@ export const COMMANDS = {
     features: entry('beta', 'Validate feature registry', 'dist/commands/features.js', directCommand(() => import('../commands/features.js'), 'dist/commands/features.js')),
     'all-features': entry('beta', 'Run all-features selftest', 'dist/commands/all-features.js', directCommand(() => import('../commands/all-features.js'), 'dist/commands/all-features.js')),
     perf: entry('beta', 'Run performance checks', 'dist/commands/perf.js', directCommand(() => import('../commands/perf.js'), 'dist/commands/perf.js')),
-    bench: entry('beta', 'Run core trust-kernel benchmark budgets', 'dist/core/commands/bench-command.js', argsCommand(() => import('../core/commands/bench-command.js'), 'benchCommand', 'dist/core/commands/bench-command.js'))
+    bench: entry('beta', 'Run core trust-kernel benchmark budgets', 'dist/core/commands/bench-command.js', argsCommand(() => import('../core/commands/bench-command.js'), 'benchCommand', 'dist/core/commands/bench-command.js')),
+    'mcp-server': entry('beta', 'Run a stdio MCP server exposing SKS commands as tools for any MCP-capable agent host', 'dist/core/commands/mcp-server-command.js', argsCommand(() => import('../core/commands/mcp-server-command.js'), 'mcpServerCommand', 'dist/core/commands/mcp-server-command.js'), {
+        skipMigrationGate: true,
+        allowedDuringActiveRoute: true,
+        activeRoutePolicy: 'always'
+    }),
+    'agent-bridge': readOnly(entry('beta', 'Publish the agent-bridge manifest and print host registration snippets for external agent systems', 'dist/core/commands/agent-bridge-command.js', subcommand(() => import('../core/commands/agent-bridge-command.js'), 'agentBridgeCommand', 'dist/core/commands/agent-bridge-command.js', 'setup')))
 };
 export const TYPED_COMMANDS = COMMANDS;
 export const LEGACY_COMMAND_ALIASES = {};

package/dist/cli/router.js

@@ -22,6 +22,34 @@ export function normalizeCommand(args = []) {
 }
 export async function dispatch(args) {
     const argv = args ?? process.argv.slice(2);
+    try {
+        return await dispatchInner(argv);
+    }
+    catch (err) {
+        // Final choke point: any uncaught bug anywhere in the dispatch chain (gate
+        // checks, lazy command import, command run()) must never leak a raw stack
+        // dump to the user as their "answer" — convert it to a structured, honest
+        // failure instead. Every existing explicit error path above already sets
+        // process.exitCode and returns normally (never throws), so this only ever
+        // catches genuinely unexpected exceptions; it changes nothing about those
+        // paths' exit codes or messages.
+        const message = err instanceof Error ? err.message : String(err);
+        if (err instanceof Error && err.stack)
+            process.stderr.write(`${err.stack}\n`);
+        else
+            process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+        const result = { ok: false, error: message, command: normalizeCommand(argv).rawCommand };
+        // A --json caller depends on stdout always being exactly one JSON result
+        // (this is the same non-interactive contract SKS_AGENT_MODE promises) — an
+        // uncaught crash must not leave stdout empty, or a JSON.parse on the
+        // consuming end breaks with no diagnosable output at all.
+        if (argv.includes('--json'))
+            console.log(JSON.stringify(result, null, 2));
+        return result;
+    }
+}
+async function dispatchInner(argv) {
     const globalMode = detectGlobalMode(argv);
     if (globalMode?.kind === 'mad-glm') {
         const mod = await import('../core/commands/glm-command.js');

package/dist/commands/doctor.js

@@ -1,6 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
-import { projectRoot, exists, formatBytes } from '../core/fsx.js';
+import { projectRoot, exists, formatBytes, nowIso, writeJsonAtomic } from '../core/fsx.js';
 import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
 import { ui as cliUi } from '../cli/cli-theme.js';
@@ -48,6 +48,9 @@ import { reconcileSkills } from '../core/init/skills.js';
 import { codexHookTrustDoctor } from '../core/codex-hooks/codex-hook-trust-doctor.js';
 import { detectImagegenCapability } from '../core/imagegen/imagegen-capability.js';
 import { repairCodexImagegen } from '../core/doctor/imagegen-repair.js';
+import { repairComputerUse } from '../core/doctor/computer-use-repair.js';
+import { repairBrowserUse } from '../core/doctor/browser-use-repair.js';
+import { detectAndRepairMcpTransportCollisions } from '../core/doctor/mcp-transport-collision-repair.js';
 export async function run(_command, args = []) {
     const root = await projectRoot();
     const doctorFix = flag(args, '--fix');
@@ -638,7 +641,8 @@ async function runDoctor(args = [], root, doctorFix) {
             after: imagegen,
             steps: [],
             blockers: [],
-            manual_actions: []
+            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',
@@ -649,6 +653,49 @@ async function runDoctor(args = [], root, doctorFix) {
             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.']
+    }));
+    const mcpTransportCollisionRepair = doctorFix
+        ? await detectAndRepairMcpTransportCollisions({ root, apply: true }).catch((err) => ({
+            schema: 'sks.mcp-transport-collision-repair.v1',
+            ok: false,
+            apply: true,
+            project_config_path: null,
+            global_config_path: null,
+            servers: [],
+            blockers: [err?.message || String(err)],
+            warnings: [],
+            raw_secret_values_recorded: false
+        }))
+        : null;
+    const nativeCapabilityReadinessStatus = (repair) => (repair?.recovered === true || repair?.ok === true ? 'ok' : repair?.attempted ? 'blocked' : 'not-needed');
+    const nativeCapabilityReadiness = {
+        schema: 'sks.native-capability-readiness.v1',
+        generated_at: nowIso(),
+        apply: doctorFix,
+        imagegen: { status: nativeCapabilityReadinessStatus(imagegenRepair), communication_test: imagegenRepair?.communication_test || null, blockers: imagegenRepair?.blockers || [] },
+        computer_use: { status: nativeCapabilityReadinessStatus(computerUseRepair), blockers: computerUseRepair?.blockers || [], next_actions: computerUseRepair?.next_actions || [] },
+        browser_use: { status: nativeCapabilityReadinessStatus(browserUseRepair), blockers: browserUseRepair?.blockers || [], next_actions: browserUseRepair?.next_actions || [] }
+    };
+    if (doctorFix) {
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'native-capability-readiness.json'), nativeCapabilityReadiness).catch(() => undefined);
+    }
     const codex0138Capability = deepDiagnostics
         ? await writeCodex0138CapabilityArtifacts(root, { codexBin: codexBin || null }).catch((err) => ({ error: err?.message || String(err), report: null }))
         : { skipped: true, report: null };
@@ -856,7 +903,7 @@ async function runDoctor(args = [], root, doctorFix) {
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
         skills: skillsReconcile,
-        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair, context7: context7Repair, codex_startup: codexStartupRepair, startup_config: startupConfigRepair, context7_mcp: context7McpRepair, supabase_mcp: supabaseMcpRepair, imagegen: imagegenRepair, hook_trust: hookTrustRepair, sks_menubar: sksMenuBar, doctor_transaction: doctorFixTransaction, doctor_dirty_plan: doctorDirtyPlan, doctor_postcheck: doctorFixPostcheck, codex_native: codexNativeRepair, doctor_native_capability: doctorNativeCapabilityRepair, command_aliases: commandAliasCleanup, skills: skillsReconcile, sks_temp_sweep: sksTempSweep }
+        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair, context7: context7Repair, codex_startup: codexStartupRepair, startup_config: startupConfigRepair, context7_mcp: context7McpRepair, supabase_mcp: supabaseMcpRepair, mcp_transport_collision: mcpTransportCollisionRepair, imagegen: imagegenRepair, computer_use: computerUseRepair, browser_use: browserUseRepair, hook_trust: hookTrustRepair, sks_menubar: sksMenuBar, doctor_transaction: doctorFixTransaction, doctor_dirty_plan: doctorDirtyPlan, doctor_postcheck: doctorFixPostcheck, codex_native: codexNativeRepair, doctor_native_capability: doctorNativeCapabilityRepair, command_aliases: commandAliasCleanup, skills: skillsReconcile, sks_temp_sweep: sksTempSweep }
     };
     if (reportFile)
         await writeJsonReportFile(reportFile, result);
@@ -1012,6 +1059,21 @@ async function runDoctor(args = [], root, doctorFix) {
     console.log(`Image Gen repair: ${imagegenRepair.recovered ? 'ok' : imagegenRepair.attempted ? 'blocked' : 'not-needed'}`);
     for (const action of imagegenRepair.manual_actions || [])
         console.log(`  - ${action}`);
+    console.log(`Computer Use repair: ${computerUseRepair.recovered ? 'ok' : computerUseRepair.attempted ? 'blocked' : 'not-needed'}`);
+    for (const action of computerUseRepair.next_actions || [])
+        console.log(`  - ${action}`);
+    console.log(`Browser Use repair: ${browserUseRepair.recovered ? 'ok' : browserUseRepair.attempted ? 'blocked' : 'not-needed'}`);
+    for (const action of browserUseRepair.next_actions || [])
+        console.log(`  - ${action}`);
+    if (mcpTransportCollisionRepair) {
+        const collisionCount = (mcpTransportCollisionRepair.servers || []).filter((s) => s.status === 'collision_resolved').length;
+        console.log(`MCP transport collision repair: ${mcpTransportCollisionRepair.ok ? 'ok' : 'blocked'}${collisionCount ? ` (${collisionCount} resolved)` : ''}`);
+    }
+    {
+        const manifestPath = path.join(root, '.sneakoscope', 'agent-bridge', 'manifest.json');
+        const manifestExists = await exists(manifestPath);
+        console.log(`Agent bridge: ${manifestExists ? 'manifest present' : 'not set up'}${manifestExists ? '' : ' — run `sks agent-bridge setup` to publish the manifest and register with an MCP host'}`);
+    }
     const codex0138 = codex0138Capability.report || {};
     console.log('Codex current compatibility:');
     console.log(`  target: rust-v0.142.0`);