sneakoscope 9.2.3 → 9.2.4

package/README.md

@@ -22,7 +22,7 @@ Proof-first orchestration for Codex CLI, ChatGPT Desktop, AI coding agents, mult
 Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-This README documents package **SKS 9.2.3** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
+This README documents package **SKS 9.2.4** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
 
 Use the official latest stable SKS and Codex CLI releases. The Codex compatibility SSOT is always the **current latest stable** host; capability probes measure what that host can actually do. Product docs do not crown a fixed `0.x.y` string as SSOT (release pins and schema directories are measured artifacts for the current package, not a permanent product version claim). Menu Bar / Center induce updates to the latest stable build. Run `sks update-check` for what is installed and read the capability report for what is supported. Install SSOT is npm `sneakoscope@latest`; PATH `sks` and Menu Bar stamped generation must match that version or gates fail. It resolves managed SKS skills from the authoritative global install, preserves a runnable Naruto child slot when `max_threads=2`, and keeps Menu Bar repair transactional so stamped generations remain verifiable. Naruto uses stable opt-in multi-agent V2 when the host exposes it (Codex official multi-agent wrap-only; SKS does not reimplement a parallel runtime). Local code search is mode-separated (`sks search files|text|structure|symbol|context`); `context` is answered by the compiled TriWiki Context Graph (`context-graph.json` is exhaustive authority; `context-pack.json` and managed `AGENTS.md` are bounded projections) — see [docs/architecture/context-graph.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/architecture/context-graph.md) and [docs/PRODUCT-CONTRACT.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/PRODUCT-CONTRACT.md). See [CHANGELOG.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/CHANGELOG.md).
 

package/crates/sks-core/Cargo.lock

@@ -259,7 +259,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "9.2.3"
+version = "9.2.4"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

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

package/dist/commands/bridge.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { readStdin } from '../core/fsx.js';
+import { BRIDGE_CLI_BOOLEAN_OPTIONS, BRIDGE_CLI_VALUE_OPTIONS, DESKTOP_BRIDGE_SUPERVISED_FLAG, isBridgeCliBooleanOption, isBridgeCliValueOption } from '../core/codex-lb/bridge-cli-contract.js';
 import { serveDesktopBridge } from '../core/codex-lb/desktop-service.js';
 import { BridgeCliError, errorOutput, mergeMetadata, ordinaryOutput, sanitizeBridgeValue, textSummary, verificationOutput } from './bridge-command-output.js';
 const CONTROLLER_FACADE_EXPORT = 'executeDesktopBridgeCommand';
@@ -117,7 +118,7 @@ async function parseInvocation(args, io) {
         return { ...base, request: { operation: 'status' }, label: 'Desktop Bridge status' };
     }
     if (area === 'serve' && action === undefined) {
-        allowOnly(parsed, ['--json', '--supervised'], ['--settings']);
+        allowOnly(parsed, ['--json', DESKTOP_BRIDGE_SUPERVISED_FLAG], ['--settings']);
         const settingsPath = parsed.values.get('--settings') || '';
         if (!path.isAbsolute(settingsPath)) {
             throw new BridgeCliError('desktop_bridge_settings_path_must_be_absolute');
@@ -280,10 +281,8 @@ function parseArgs(args) {
     const positionals = [];
     const flags = new Set();
     const values = new Map();
-    const booleanOptions = new Set([
-        '--json', '--strict', '--require-ready', '--api-key-stdin', '--confirm'
-    ]);
-    const valueOptions = new Set(['--level', '--host', '--settings', '--set']);
+    const booleanOptions = new Set(BRIDGE_CLI_BOOLEAN_OPTIONS);
+    const valueOptions = new Set(BRIDGE_CLI_VALUE_OPTIONS);
     for (let index = 0; index < args.length; index += 1) {
         const value = String(args[index] || '');
         if (!value.startsWith('--')) {
@@ -323,6 +322,10 @@ function rejectSecretArgv(args) {
     }
 }
 function allowOnly(parsed, allowedFlags, allowedValues) {
+    if (allowedFlags.some((entry) => !isBridgeCliBooleanOption(entry))
+        || allowedValues.some((entry) => !isBridgeCliValueOption(entry))) {
+        throw new BridgeCliError('bridge_command_option_table_desynchronized');
+    }
     const flags = new Set(allowedFlags);
     const values = new Set(allowedValues);
     if ([...parsed.flags].some((entry) => !flags.has(entry))) {

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "9.2.3",
+  "package_version": "9.2.4",
   "skills": [
     {
       "canonical_name": "sks",

package/dist/core/codex-lb/bridge-cli-contract.js

@@ -0,0 +1,35 @@
+import { DesktopBridgeError } from './desktop-bridge/types.js';
+export const DESKTOP_BRIDGE_SUPERVISED_FLAG = '--supervised';
+export const BRIDGE_CLI_BOOLEAN_OPTIONS = [
+    '--json',
+    '--strict',
+    '--require-ready',
+    '--api-key-stdin',
+    '--confirm',
+    DESKTOP_BRIDGE_SUPERVISED_FLAG
+];
+export const BRIDGE_CLI_VALUE_OPTIONS = ['--level', '--host', '--settings', '--set'];
+export function isBridgeCliBooleanOption(value) {
+    return BRIDGE_CLI_BOOLEAN_OPTIONS.includes(value);
+}
+export function isBridgeCliValueOption(value) {
+    return BRIDGE_CLI_VALUE_OPTIONS.includes(value);
+}
+export function isBridgeCliOption(value) {
+    return isBridgeCliBooleanOption(value) || isBridgeCliValueOption(value);
+}
+export function desktopBridgeServeArguments(settingsPath) {
+    const argv = [
+        'bridge',
+        'serve',
+        '--settings',
+        settingsPath,
+        '--json',
+        DESKTOP_BRIDGE_SUPERVISED_FLAG
+    ];
+    const unregistered = argv.filter((token) => token.startsWith('--') && !isBridgeCliOption(token));
+    if (unregistered.length) {
+        throw new DesktopBridgeError(`bridge_serve_option_unregistered:${unregistered.join(',')}`);
+    }
+    return argv;
+}

package/dist/core/codex-lb/desktop-service.js

@@ -8,6 +8,7 @@ import { withFileLock } from '../locks/file-lock.js';
 import { loadCodexLbEnv } from './codex-lb-env.js';
 import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
 import { cleanupRetiredDesktopBridgeRuntime, prepareRetiredDesktopBridgeRuntime, } from './desktop-bridge-migration/retired-runtime-cleanup.js';
+import { DESKTOP_BRIDGE_SUPERVISED_FLAG, desktopBridgeServeArguments } from './bridge-cli-contract.js';
 import { canonicalizeBridgeModelId, normalizeBridgeUpstreamModelId, sha256Stable } from './route-index.js';
 import { captureCodexAuthSnapshot } from './desktop-auth-invariant.js';
 import { applyOfficialModelPassthrough, bridgeRoutePolicyPath, writeBridgeRoutingPolicy } from './provider-route-policy.js';
@@ -352,12 +353,13 @@ export async function installAndStartDesktopBridgeService(options = {}) {
     catch (error) {
         return failedStatus(paths, settings, launchService(options.uid), 'credentials_unavailable', safeServiceError(error));
     }
-    const command = await resolveLaunchCommand(options);
+    const launch = await resolveLaunchCommand(options, home);
+    const command = launch.command;
     if (!command)
-        return failedStatus(paths, settings, launchService(options.uid), 'settings_missing', 'desktop_bridge_sks_executable_missing');
+        return failedStatus(paths, settings, launchService(options.uid), 'settings_missing', launch.blocker);
     await prepareDesktopBridgeServicePaths(paths);
     await writeDesktopBridgeServiceSettings(paths.settings_path, { ...settings, provider_registry: runtime.config.providerRegistry, route_policy: runtime.config.routePolicy });
-    await writeDesktopBridgeLaunchdPlist(paths.launch_agent_path, { executablePath: command.executable, arguments: [...command.arguments, 'bridge', 'serve', '--settings', paths.settings_path, '--json', '--supervised'], stdoutPath: paths.stdout_log_path, stderrPath: paths.stderr_log_path });
+    await writeDesktopBridgeLaunchdPlist(paths.launch_agent_path, { executablePath: command.executable, arguments: [...command.arguments, ...desktopBridgeServeArguments(paths.settings_path)], stdoutPath: paths.stdout_log_path, stderrPath: paths.stderr_log_path });
     const run = options.run || runProcess;
     const ctl = options.launchctl || '/bin/launchctl';
     const service = launchService(options.uid);
@@ -426,8 +428,8 @@ export async function stopDesktopBridgeService(options = {}) {
     const status = await desktopBridgeServiceStatus({ ...options, home });
     return { ...status, ok: !status.running, blockers: status.running ? ['desktop_bridge_process_still_running'] : [] };
 }
-function desktopBridgeIsSupervised(env = process.env, argv = process.argv) {
-    return env.XPC_SERVICE_NAME === DESKTOP_BRIDGE_LAUNCHD_LABEL || argv.includes('--supervised');
+export function desktopBridgeIsSupervised(env = process.env, argv = process.argv) {
+    return env.XPC_SERVICE_NAME === DESKTOP_BRIDGE_LAUNCHD_LABEL || argv.includes(DESKTOP_BRIDGE_SUPERVISED_FLAG);
 }
 async function installedPackageVersion() {
     try {
@@ -697,9 +699,30 @@ function normalizeProviderRegistrySnapshot(value) {
 function overridePaths(base, options) { return { settings_path: options.settingsPath || base.settings_path, state_path: options.statePath || base.state_path, client_capability_path: options.clientCapabilityPath || base.client_capability_path, launch_agent_path: options.launchAgentPath || base.launch_agent_path, stdout_log_path: options.stdoutLogPath || base.stdout_log_path, stderr_log_path: options.stderrLogPath || base.stderr_log_path }; }
 function launchDomain(uid = typeof process.getuid === 'function' ? process.getuid() : 0) { return `gui/${uid}`; }
 function launchService(uid) { return `${launchDomain(uid)}/${DESKTOP_BRIDGE_LAUNCHD_LABEL}`; }
-async function resolveLaunchCommand(options) { if (options.executablePath)
-    return await exists(path.resolve(options.executablePath)) ? { executable: path.resolve(options.executablePath), arguments: [...(options.executableArguments || [])] } : null; const entry = String(process.argv[1] || ''); if (entry && ['sks', 'sneakoscope'].includes(path.basename(entry).replace(/\.js$/i, '')) && await exists(entry))
-    return { executable: path.resolve(process.execPath), arguments: [path.resolve(entry)] }; const sks = await which('sks').catch(() => null); return sks ? { executable: path.resolve(sks), arguments: [] } : null; }
+async function resolveLaunchCommand(options, home) {
+    if (options.executablePath) {
+        return await exists(path.resolve(options.executablePath))
+            ? { command: { executable: path.resolve(options.executablePath), arguments: [...(options.executableArguments || [])] }, blocker: 'desktop_bridge_sks_executable_missing' }
+            : { command: null, blocker: 'desktop_bridge_sks_executable_missing' };
+    }
+    const candidates = [];
+    const entry = String(process.argv[1] || '');
+    if (entry && ['sks', 'sneakoscope'].includes(path.basename(entry).replace(/\.js$/i, '')) && await exists(entry)) {
+        candidates.push({ executable: path.resolve(process.execPath), arguments: [path.resolve(entry)] });
+    }
+    const sks = await which('sks').catch(() => null);
+    if (sks)
+        candidates.push({ executable: path.resolve(sks), arguments: [] });
+    let rejectedProtected = false;
+    for (const candidate of candidates) {
+        if (await launchTargetsProtectedFolder([candidate.executable, ...candidate.arguments], home)) {
+            rejectedProtected = true;
+            continue;
+        }
+        return { command: candidate, blocker: 'desktop_bridge_sks_executable_missing' };
+    }
+    return { command: null, blocker: rejectedProtected ? 'desktop_bridge_entry_macos_protected_folder' : 'desktop_bridge_sks_executable_missing' };
+}
 function macosProtectedUserPath(target, home) {
     if (!target)
         return false;

package/dist/core/update/update-migration-state/desktop-bridge-restage.js

@@ -1,46 +1,73 @@
 import os from 'node:os';
 import path from 'node:path';
 import { exists, PACKAGE_VERSION, readJson, runProcess } from '../../fsx.js';
-export async function runDesktopBridgeRestageStage() {
+import { bootstrapExistingDesktopBridgeService, desktopBridgeServicePaths } from '../../codex-lb/desktop-service.js';
+export async function desktopBridgeRestage(options = {}) {
     const skip = (reason) => ({ ok: true, status: 'ok', actions: [reason], blockers: [], warnings: [] });
-    if (process.platform !== 'darwin')
+    const warn = (warnings) => ({ ok: true, status: 'ok', actions: [], blockers: [], warnings });
+    const env = options.env || process.env;
+    const version = options.packageVersion || PACKAGE_VERSION;
+    const reachesRealLaunchd = !(options.run && options.bootstrapService);
+    if ((options.platform || process.platform) !== 'darwin')
         return skip('desktop_bridge_restage_not_macos');
-    if (process.env.NODE_TEST_CONTEXT !== undefined)
+    if (reachesRealLaunchd && (env.NODE_TEST_CONTEXT !== undefined || env.SKS_TEST_ISOLATION === '1')) {
         return skip('desktop_bridge_restage_skipped_under_tests');
-    if (process.env.SKS_SKIP_BRIDGE_RESTAGE === '1')
+    }
+    if (env.SKS_SKIP_BRIDGE_RESTAGE === '1')
         return skip('desktop_bridge_restage_disabled');
-    const home = os.homedir();
-    const plist = path.join(home, 'Library', 'LaunchAgents', 'com.sneakoscope.desktop-bridge.plist');
-    if (!(await exists(plist)))
+    const home = options.home || path.resolve(env.HOME || os.homedir());
+    const paths = desktopBridgeServicePaths(home);
+    if (!(await exists(paths.launch_agent_path)))
         return skip('desktop_bridge_restage_no_launch_agent');
-    const state = await readJson(path.join(home, '.codex', 'sks', 'desktop-bridge-state.json'), null);
+    const state = await readJson(paths.state_path, null);
     const runningVersion = typeof state?.sks_version === 'string' ? state.sks_version : null;
     const pid = typeof state?.pid === 'number' && Number.isInteger(state.pid) && state.pid > 1 ? state.pid : null;
-    if (!pid)
-        return skip('desktop_bridge_restage_no_running_bridge');
-    try {
-        process.kill(pid, 0);
+    if (pid === null || !(options.processAlive || processAlive)(pid)) {
+        if (!(await exists(paths.settings_path)))
+            return skip('desktop_bridge_restage_no_managed_bridge');
+        const bootstrap = await (options.bootstrapService || bootstrapExistingDesktopBridgeService)({ home })
+            .catch(() => null);
+        if (bootstrap?.running) {
+            return {
+                ok: true,
+                status: 'ok',
+                actions: [`desktop_bridge_bootstrapped:${version}`],
+                blockers: [],
+                warnings: bootstrap.blockers.map((blocker) => `desktop_bridge_restage_bootstrap_incomplete:${blocker}`)
+            };
+        }
+        return warn([
+            ...(bootstrap?.blockers || ['desktop_bridge_restage_bootstrap_failed'])
+                .map((blocker) => `desktop_bridge_restage_bootstrap_incomplete:${blocker}`),
+            'Desktop Bridge is installed but not running: run `sks bridge repair` from your home directory'
+        ]);
     }
-    catch {
-        return skip('desktop_bridge_restage_no_running_bridge');
-    }
-    if (runningVersion === PACKAGE_VERSION)
+    if (runningVersion === version)
         return skip('desktop_bridge_restage_already_current');
-    const uid = typeof process.getuid === 'function' ? process.getuid() : null;
+    const uid = options.uid === undefined
+        ? (typeof process.getuid === 'function' ? process.getuid() : null)
+        : options.uid;
     if (uid === null)
         return skip('desktop_bridge_restage_no_uid');
-    const kick = await runProcess('/bin/launchctl', ['kickstart', '-k', `gui/${uid}/com.sneakoscope.desktop-bridge`], { timeoutMs: 10_000, maxOutputBytes: 16 * 1024 }).catch(() => null);
+    const kick = await (options.run || runProcess)('/bin/launchctl', ['kickstart', '-k', `gui/${uid}/com.sneakoscope.desktop-bridge`], { timeoutMs: 10_000, maxOutputBytes: 16 * 1024 }).catch(() => null);
     if (!kick || kick.code !== 0) {
-        return {
-            ok: true, status: 'ok',
-            actions: [],
-            blockers: [],
-            warnings: [`desktop_bridge_restage_kickstart_failed:${runningVersion || 'pre-8.6.2'}`]
-        };
+        return warn([`desktop_bridge_restage_kickstart_failed:${runningVersion || 'pre-8.6.2'}`]);
     }
     return {
         ok: true, status: 'ok',
-        actions: [`desktop_bridge_restarted:${runningVersion || 'pre-8.6.2'}:${PACKAGE_VERSION}`],
+        actions: [`desktop_bridge_restarted:${runningVersion || 'pre-8.6.2'}:${version}`],
         blockers: [], warnings: []
     };
 }
+export function runDesktopBridgeRestageStage() {
+    return desktopBridgeRestage();
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/version-manager.js

@@ -362,8 +362,7 @@ async function syncSourcePackageVersion(root, version) {
                 .replace(/not represented as current \d+\.\d+\.\d+ completion proof\./g, `not represented as current ${version} completion proof.`)
                 .replace(/^For \d+\.\d+\.\d+, a selected codex-lb/m, `For ${version}, a selected codex-lb`)
                 .replace(/^The \d+\.\d+\.\d+ SKS menu bar/m, `The ${version} SKS menu bar`)
-                .replace(/the \d+\.\d+\.\d+ to \d+\.\d+\.\d+ upgrade smoke/g, `the ${RELEASE_UPGRADE_BASELINE_VERSION} to ${version} upgrade smoke`)
-                .replace(/to \d+\.\d+\.\d+ upgrade smoke/g, `to ${version} upgrade smoke`)
+                .replace(/\bthe (isolated )?\d+\.\d+\.\d+ to \d+\.\d+\.\d+ upgrade smoke/, (_match, isolated) => `the ${isolated || ''}${RELEASE_UPGRADE_BASELINE_VERSION} to ${version} upgrade smoke`)
                 .replace(/under the \d+\.\d+\.\d+ release evidence root/g, `under the ${version} release evidence root`)
                 .replace(/^Do not cut \d+\.\d+\.\d+ while/m, `Do not cut ${version} while`)
                 .replace(/must agree on \d+\.\d+\.\d+\./g, `must agree on ${version}.`)

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '9.2.3';
+export const PACKAGE_VERSION = '9.2.4';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "9.2.3",
+  "version": "9.2.4",
   "description": "Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",