sneakoscope 9.0.0 → 9.0.1

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.0.0** — 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.0.1** — 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.0.0"
+version = "9.0.1"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

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

package/dist/commands/bridge.js

@@ -116,7 +116,7 @@ async function parseInvocation(args, io) {
         return { ...base, request: { operation: 'status' }, label: 'Desktop Bridge status' };
     }
     if (area === 'serve' && action === undefined) {
-        allowOnly(parsed, ['--json'], ['--settings']);
+        allowOnly(parsed, ['--json', '--supervised'], ['--settings']);
         const settingsPath = parsed.values.get('--settings') || '';
         if (!path.isAbsolute(settingsPath)) {
             throw new BridgeCliError('desktop_bridge_settings_path_must_be_absolute');

package/dist/config/skills-manifest.json

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

package/dist/core/codex-lb/desktop-bridge/http-forward.js

@@ -252,6 +252,15 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             upstream.once('response', (response) => {
                 const statusCode = response.statusCode || 502;
                 if (statusCode >= 400) {
+                    logHttpRejection({
+                        code: `bridge_upstream_status_${statusCode}`,
+                        transport: 'http',
+                        ...(req.method === undefined ? {} : { method: req.method }),
+                        ...(req.url === undefined ? {} : { url: req.url }),
+                        status: statusCode,
+                        provider_id: provider.provider_id,
+                        public_model: request.route.public_model,
+                    });
                     void readRedactedUpstreamError(response).then((body) => {
                         responseStarted = true;
                         const responseHeaders = rewriteResponseHeaders(response.headers, provider.base_url, authenticatedLocalBaseUrl);

package/dist/core/codex-lb/desktop-bridge/rejection-log.js

@@ -2,6 +2,10 @@ import { PACKAGE_VERSION } from '../../version.js';
 export const DESKTOP_BRIDGE_LOG_SCHEMA = 'sks.desktop-bridge-log.v2';
 export const REJECTION_LOG_BURST = 5;
 export const REJECTION_LOG_SUMMARY_INTERVAL_MS = 60_000;
+function safeCatalogId(value) {
+    const text = String(value ?? '').replace(/[\r\n\0]/g, '').trim().slice(0, 128);
+    return text.length > 0 ? text : null;
+}
 function safePathname(url) {
     const raw = String(url || '').trim();
     if (!raw.startsWith('/'))
@@ -62,6 +66,8 @@ export function createDesktopBridgeRejectionLogger(options = {}) {
         windows.set(code, window);
         const pathname = safePathname(event.url);
         const method = safeMethod(event.method);
+        const providerId = safeCatalogId(event.provider_id);
+        const publicModel = safeCatalogId(event.public_model);
         emit({
             event: 'sks.desktop_bridge.rejected',
             code,
@@ -69,6 +75,8 @@ export function createDesktopBridgeRejectionLogger(options = {}) {
             ...(method ? { method } : {}),
             ...(pathname ? { pathname } : {}),
             ...(Number.isInteger(event.status) ? { status: event.status } : {}),
+            ...(providerId ? { provider_id: providerId } : {}),
+            ...(publicModel ? { public_model: publicModel } : {}),
         });
     };
 }

package/dist/core/codex-lb/desktop-bridge/server.js

@@ -6,6 +6,7 @@ import { createDesktopBridgeRejectionLogger } from './rejection-log.js';
 import { assertAllowedOrigin, assertAllowedPath, assertLoopbackPeer, assertLoopbackListenHost, assertWebSocketUpgrade, prepareDesktopBridgeConfig, safeBridgeErrorCode, validatePreparedDesktopBridgeConfig, } from './security.js';
 import { createDesktopBridgePublicState, desktopBridgeListenOrigin, desktopBridgeStatePath, refreshDesktopBridgeState, removeDesktopBridgeStateIfOwned, writeDesktopBridgeState, } from './state.js';
 import { DesktopBridgeError } from './types.js';
+import { PACKAGE_VERSION } from '../../version.js';
 import { DESKTOP_BRIDGE_CLIENT_PATH_PREFIX, DESKTOP_BRIDGE_DIAGNOSTIC_HEALTH_PATH, DESKTOP_BRIDGE_DIAGNOSTIC_PATH, DESKTOP_BRIDGE_DIAGNOSTIC_PROTOCOL } from './types.js';
 import { forwardWebSocket } from './websocket-forward.js';
 function authenticateDesktopBridgeClient(req, input) {
@@ -316,6 +317,27 @@ export async function startPreparedDesktopBridge(input, options = {}) {
         void refreshDesktopBridgeState(statePath, state, new Date(), freshnessMs).catch(() => undefined);
     }, Math.max(1_000, Math.floor(freshnessMs / 3))) : null;
     heartbeat?.unref();
+    let skewCandidate = null;
+    let skewFired = false;
+    const versionCheck = options.versionSkew ? setInterval(() => {
+        void options.versionSkew.readInstalledVersion().then((installed) => {
+            if (skewFired)
+                return;
+            if (!installed || installed === PACKAGE_VERSION) {
+                skewCandidate = null;
+                return;
+            }
+            if (skewCandidate !== installed) {
+                skewCandidate = installed;
+                return;
+            }
+            skewFired = true;
+            if (versionCheck)
+                clearInterval(versionCheck);
+            options.versionSkew.onSkew(installed);
+        }).catch(() => undefined);
+    }, Math.max(1_000, options.versionSkew.intervalMs ?? 60_000)) : null;
+    versionCheck?.unref();
     let stopped = false;
     const handle = {
         server,
@@ -328,6 +350,8 @@ export async function startPreparedDesktopBridge(input, options = {}) {
             stopped = true;
             if (heartbeat)
                 clearInterval(heartbeat);
+            if (versionCheck)
+                clearInterval(versionCheck);
             await closeServer(server, sockets, () => activeRequests);
             destroyDesktopBridgeUpstreamAgents();
             if (statePath)

package/dist/core/codex-lb/desktop-bridge/websocket-forward.js

@@ -152,14 +152,10 @@ export async function forwardWebSocket(req, client, head, config, authenticatedL
         connected = true;
         clearTimeout(timer);
         upstream.setNoDelay(true);
-        upstream.setTimeout(config.idleTimeoutMs, () => {
-            logWebSocketRejection({
-                code: 'bridge_websocket_upstream_idle_timeout',
-                transport: 'websocket',
-                ...(req.url === undefined ? {} : { url: req.url }),
-            });
-            upstream.destroy(new DesktopBridgeError('bridge_websocket_upstream_idle_timeout'));
-        });
+        upstream.setKeepAlive(true, 30_000);
+        const clientSocket = client;
+        if (typeof clientSocket.setKeepAlive === 'function')
+            clientSocket.setKeepAlive(true, 30_000);
         const headers = buildProviderWebSocketHeaders(req.headers, { providerId: provider.provider_id, authTransport: provider.auth_transport, credential }, target.host);
         upstream.write([`${req.method || 'GET'} ${target.pathname}${target.search} HTTP/1.1`, ...serializeHeaders(headers), '', ''].join('\r\n'));
         if (head.length)

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

@@ -3,7 +3,7 @@ import { constants as fsConstants } from 'node:fs';
 import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { ensureDir, exists, runProcess, which, writeTextAtomic } from '../fsx.js';
+import { ensureDir, exists, packageRoot, runProcess, which, writeTextAtomic } from '../fsx.js';
 import { withFileLock } from '../locks/file-lock.js';
 import { loadCodexLbEnv } from './codex-lb-env.js';
 import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
@@ -352,7 +352,7 @@ export async function installAndStartDesktopBridgeService(options = {}) {
         return failedStatus(paths, settings, launchService(options.uid), 'settings_missing', 'desktop_bridge_sks_executable_missing');
     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'], stdoutPath: paths.stdout_log_path, stderrPath: paths.stderr_log_path });
+    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 });
     const run = options.run || runProcess;
     const ctl = options.launchctl || '/bin/launchctl';
     const service = launchService(options.uid);
@@ -421,11 +421,36 @@ 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');
+}
+async function installedPackageVersion() {
+    try {
+        const raw = await fsp.readFile(path.join(packageRoot(), 'package.json'), 'utf8');
+        const version = JSON.parse(raw).version;
+        return typeof version === 'string' && version.length > 0 ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
 export async function serveDesktopBridge(options = {}) {
     let handle = null;
     try {
         const runtime = await resolveDesktopBridgeRuntimeConfig(options);
-        handle = await startPreparedDesktopBridge(await preflightDesktopBridge(runtime.config), { statePath: runtime.paths.state_path });
+        const supervised = desktopBridgeIsSupervised();
+        handle = await startPreparedDesktopBridge(await preflightDesktopBridge(runtime.config), {
+            statePath: runtime.paths.state_path,
+            versionSkew: {
+                readInstalledVersion: installedPackageVersion,
+                onSkew: (installedVersion) => {
+                    process.stdout.write(`${JSON.stringify({ schema: 'sks.desktop-bridge-log.v2', event: 'sks.desktop_bridge.version_skew', running: PACKAGE_VERSION, installed: installedVersion, supervised, action: supervised ? 'restarting' : 'logged_only', secret_fields_redacted: true })}\n`);
+                    if (!supervised)
+                        return;
+                    void handle?.stop().catch(() => undefined).finally(() => process.exit(64));
+                },
+            },
+        });
         process.stdout.write(`${JSON.stringify({ schema: 'sks.desktop-bridge-log.v2', event: 'sks.desktop_bridge.started', pid: handle.state.pid, process_generation: handle.state.schema === DESKTOP_BRIDGE_STATE_SCHEMA ? handle.state.process_generation : null, provider_registry_generation: runtime.config.providerRegistry?.generation, route_policy_generation: runtime.config.routePolicy?.policy_generation, secret_fields_redacted: true })}\n`);
         await waitForShutdown(handle);
         return { schema: 'sks.desktop-bridge-serve.v1', ok: true, status: 'stopped', state: handle.state };

package/dist/core/triwiki/context-graph/paths.js

@@ -106,11 +106,3 @@ export function contextGraphExperimentLogPath(root) {
 export function contextPackPath(root) {
     return path.join(contextGraphDir(root), 'context-pack.json');
 }
-export function contextGraphArtifactPaths(root) {
-    return [
-        contextGraphSnapshotPath(root),
-        contextGraphMetaPath(root),
-        contextGraphPrevSnapshotPath(root),
-        contextGraphEventLogPath(root)
-    ];
-}

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

@@ -0,0 +1,46 @@
+import os from 'node:os';
+import path from 'node:path';
+import { exists, PACKAGE_VERSION, readJson, runProcess } from '../../fsx.js';
+export async function runDesktopBridgeRestageStage() {
+    const skip = (reason) => ({ ok: true, status: 'ok', actions: [reason], blockers: [], warnings: [] });
+    if (process.platform !== 'darwin')
+        return skip('desktop_bridge_restage_not_macos');
+    if (process.env.NODE_TEST_CONTEXT !== undefined)
+        return skip('desktop_bridge_restage_skipped_under_tests');
+    if (process.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)))
+        return skip('desktop_bridge_restage_no_launch_agent');
+    const state = await readJson(path.join(home, '.codex', 'sks', 'desktop-bridge-state.json'), 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);
+    }
+    catch {
+        return skip('desktop_bridge_restage_no_running_bridge');
+    }
+    if (runningVersion === PACKAGE_VERSION)
+        return skip('desktop_bridge_restage_already_current');
+    const uid = typeof process.getuid === 'function' ? process.getuid() : null;
+    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);
+    if (!kick || kick.code !== 0) {
+        return {
+            ok: true, status: 'ok',
+            actions: [],
+            blockers: [],
+            warnings: [`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}`],
+        blockers: [], warnings: []
+    };
+}

package/dist/core/update/update-migration-state.js

@@ -10,6 +10,7 @@ import { enforceRetention } from '../retention.js';
 import { COMMANDS } from '../../cli/command-registry.js';
 import { reconcileLegacyManagedGeneration } from '../init/legacy-generation-convergence.js';
 import { runConfigFastModeNormalizeStage } from './update-migration-state/fast-mode-config.js';
+import { runDesktopBridgeRestageStage } from './update-migration-state/desktop-bridge-restage.js';
 import { runSessionStateSplitStage } from './update-migration-state/session-state-split.js';
 import { runHookTrustRefreshStage, runOtherHarnessCleanupStage } from './update-migration-state/simple-stages.js';
 import { compareSemVer } from './semver.js';
@@ -258,6 +259,11 @@ const UPDATE_MIGRATION_STAGES = [
         id: 'receipt-rotation',
         min_from_version: '0.0.0',
         run: runReceiptRotationStage
+    },
+    {
+        id: 'desktop-bridge-restage',
+        min_from_version: '0.0.0',
+        run: runDesktopBridgeRestageStage
     }
 ];
 async function runCurrentPublicSurfaceReconcileStage(root) {
@@ -325,7 +331,7 @@ async function runCurrentPublicSurfaceReconcileStage(root) {
         }
     };
 }
-async function runUpdateMigrationStages(root, opts = {}) {
+export async function runUpdateMigrationStages(root, opts = {}) {
     const fromVersion = opts.fromVersion || null;
     const runs = [];
     for (const stage of UPDATE_MIGRATION_STAGES) {

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '9.0.0';
+export const PACKAGE_VERSION = '9.0.1';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "9.0.0",
+  "version": "9.0.1",
   "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",