sneakoscope 10.6.0 → 10.6.2

package/README.md

@@ -17,7 +17,7 @@
 Sneakoscope Codex (`sks`) is an open-source local tool for the Codex CLI and Codex desktop app. It adds a macOS control center, bounded agent workflows, repository context, and evidence checks for SKS releases.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-Current package: **SKS 10.6.0**, prepared for npm publication.
+Current package: **SKS 10.6.2**, prepared for npm publication.
 [Release notes](https://github.com/mandarange/Sneakoscope-Codex/releases/tag/v10.5.8)
 · [Changelog](CHANGELOG.md). Install the latest stable release from npm.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/config/skills-manifest.json

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

package/dist/core/codex-lb/desktop-bridge/capacity-retry-advice.js

@@ -0,0 +1,89 @@
+import { Transform } from 'node:stream';
+export const MODEL_CAPACITY_ERROR_CODE = 'server_is_overloaded';
+export const MODEL_CAPACITY_RETRY_AFTER_SECONDS = 5;
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function carriesRetryAfter(headers) {
+    return isObject(headers) && Object.keys(headers).some((name) => name.toLowerCase() === 'retry-after');
+}
+export function adviseModelCapacityRetry(event) {
+    const error = event.type === 'response.failed' ? (isObject(event.response) ? event.response.error : null)
+        : event.type === 'error' ? event.error
+            : null;
+    if (!isObject(error) || error.code !== MODEL_CAPACITY_ERROR_CODE)
+        return false;
+    if (event.type === 'error' && carriesRetryAfter(event.headers))
+        return false;
+    const headers = error.headers ?? {};
+    if (!isObject(headers) || carriesRetryAfter(headers))
+        return false;
+    error.headers = { ...headers, 'Retry-After': String(MODEL_CAPACITY_RETRY_AFTER_SECONDS) };
+    return true;
+}
+export function modelCapacityAdvisedFrame(frame) {
+    if (!frame.includes(MODEL_CAPACITY_ERROR_CODE))
+        return null;
+    let event;
+    try {
+        event = JSON.parse(frame.toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+    return isObject(event) && adviseModelCapacityRetry(event) ? Buffer.from(JSON.stringify(event)) : null;
+}
+export function isAdvisableEventStream(headers) {
+    const encoding = String(headers['content-encoding'] || 'identity').trim().toLowerCase();
+    return /^text\/event-stream\b/i.test(String(headers['content-type'] || '')) && encoding === 'identity';
+}
+function adviseSseEvents(events, onAdvised) {
+    if (!events.includes(MODEL_CAPACITY_ERROR_CODE))
+        return events;
+    const parts = events.toString('utf8').split(/(\r?\n\r?\n)/);
+    let changed = false;
+    for (let index = 0; index < parts.length; index += 2) {
+        const block = parts[index];
+        if (!block.includes(MODEL_CAPACITY_ERROR_CODE))
+            continue;
+        const lines = block.split(/\r?\n/);
+        const data = lines.filter((line) => line.startsWith('data:')).map((line) => line.slice(5).replace(/^ /, '')).join('\n');
+        let event;
+        try {
+            event = JSON.parse(data);
+        }
+        catch {
+            continue;
+        }
+        if (!isObject(event) || !adviseModelCapacityRetry(event))
+            continue;
+        const newline = block.includes('\r\n') ? '\r\n' : '\n';
+        parts[index] = [...lines.filter((line) => !line.startsWith('data:')), `data: ${JSON.stringify(event)}`].join(newline);
+        changed = true;
+    }
+    if (!changed)
+        return events;
+    onAdvised();
+    return Buffer.from(parts.join(''));
+}
+export function modelCapacityAdvisingSse(onAdvised) {
+    let carry = Buffer.alloc(0);
+    return new Transform({
+        transform(chunk, _encoding, done) {
+            const data = carry.length ? Buffer.concat([carry, chunk]) : chunk;
+            const lf = data.lastIndexOf('\n\n');
+            const crlf = data.lastIndexOf('\r\n\r\n');
+            const end = Math.max(lf === -1 ? -1 : lf + 2, crlf === -1 ? -1 : crlf + 4);
+            if (end === -1) {
+                carry = data;
+                done();
+                return;
+            }
+            carry = data.subarray(end);
+            done(null, adviseSseEvents(data.subarray(0, end), onAdvised));
+        },
+        flush(done) {
+            done(null, carry.length ? adviseSseEvents(carry, onAdvised) : null);
+        },
+    });
+}

package/dist/core/codex-lb/desktop-bridge/compaction-adapter.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { adviseModelCapacityRetry } from './capacity-retry-advice.js';
 export const CODEX_SUMMARIZATION_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
 
 Include:
@@ -331,10 +332,12 @@ export function compactionResponseEvents(responseId, publicModel, summary, usage
     };
 }
 export function compactionFailedEvent(responseId, publicModel, code) {
-    return {
+    const event = {
         type: 'response.failed',
         response: { ...responseBase(responseId, publicModel), status: 'failed', error: { code, message: code } },
     };
+    adviseModelCapacityRetry(event);
+    return event;
 }
 export function sseEvent(event) {
     return `event: ${String(event.type)}\ndata: ${JSON.stringify(event)}\n\n`;

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

@@ -9,6 +9,7 @@ import { OPENROUTER_ONLY_REFUSAL_CODES, openRouterOnlyEnabled } from './exclusiv
 import { ensureDesktopBridgeRemoteTarget, isNoRouteUpstreamError, isUnreachableUpstreamError, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode, singleBridgeHeader } from './security.js';
 import { desktopBridgeListenOrigin } from './state.js';
 import { buildCompactionSummaryRequest, compactEndpointResult, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, safeUpstreamErrorId, sseEvent, summaryFailure, summaryWithinBounds, } from './compaction-adapter.js';
+import { isAdvisableEventStream, modelCapacityAdvisingSse } from './capacity-retry-advice.js';
 import { DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES, DesktopBridgeError, DesktopBridgeRequestBodyTooLargeError } from './types.js';
 const MAX_UPSTREAM_ERROR_BODY_BYTES = 1024 * 1024;
 function decodeBridgeRequestBody(body, encoding, maximum) {
@@ -466,15 +467,26 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                     return;
                 }
                 responseStarted = true;
+                const advising = isAdvisableEventStream(response.headers) ? modelCapacityAdvisingSse(() => logHttpRejection({
+                    code: 'bridge_upstream_model_capacity_retry_advised',
+                    transport: 'http',
+                    ...(req.method === undefined ? {} : { method: req.method }),
+                    ...(req.url === undefined ? {} : { url: req.url }),
+                    provider_id: provider.provider_id,
+                    public_model: request.route.public_model,
+                })) : null;
                 try {
-                    res.writeHead(statusCode, rewriteResponseHeaders(response.headers, upstreamBaseUrl, authenticatedLocalBaseUrl));
+                    const responseHeaders = rewriteResponseHeaders(response.headers, upstreamBaseUrl, authenticatedLocalBaseUrl);
+                    if (advising)
+                        delete responseHeaders['content-length'];
+                    res.writeHead(statusCode, responseHeaders);
                 }
                 catch (error) {
                     response.destroy(error instanceof Error ? error : undefined);
                     finish(error);
                     return;
                 }
-                void pipeline(response, res).then(() => finish(), finish);
+                void (advising ? pipeline(response, advising, res) : pipeline(response, res)).then(() => finish(), finish);
             });
             if (body)
                 upstream.end(body);

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

@@ -8,6 +8,7 @@ import { assertDesktopBridgeRouteContext, ensureDesktopBridgeRemoteTarget, isUnr
 import { DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES, DesktopBridgeError } from './types.js';
 import { buildCompactionSummaryRequest, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, ResponsesContinuationChain, summaryFailure, summaryWithinBounds, } from './compaction-adapter.js';
 import { requestProviderCompactionSummary } from './http-forward.js';
+import { modelCapacityAdvisedFrame } from './capacity-retry-advice.js';
 const MAX_PENDING_MESSAGES = 256;
 const CLOSE_GRACE_MS = 1_000;
 const INITIAL_CREATE_TIMEOUT_MS = 60 * 60_000;
@@ -47,6 +48,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
         let boundBaseUrl = null;
         let boundCredentialGeneration = null;
         let boundCredentialFingerprint = null;
+        let routedModel = null;
         let stopped = false;
         let processing = false;
         let pendingBytes = 0;
@@ -129,6 +131,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             if (stopped || client.readyState !== WebSocket.OPEN)
                 return;
             assertBinding(route);
+            routedModel = route.public_model;
             if (!bound) {
                 bound = route;
                 await connect(route);
@@ -247,7 +250,12 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             peer.on('message', (data, binary) => {
                 if (stopped)
                     return;
-                const frame = bytes(data);
+                let frame = bytes(data);
+                const advised = official || binary ? null : modelCapacityAdvisedFrame(frame);
+                if (advised) {
+                    frame = advised;
+                    logRejection({ code: 'bridge_upstream_model_capacity_retry_advised', transport: 'websocket', provider_id: route.provider_id, public_model: routedModel ?? route.public_model, ...(req.url ? { url: req.url } : {}) });
+                }
                 chain.received(frame);
                 try {
                     relay(client, frame, binary);

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '10.6.0';
+export const PACKAGE_VERSION = '10.6.2';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "10.6.0",
+  "version": "10.6.2",
   "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",
@@ -199,9 +199,9 @@
     "ws": "^8.22.0"
   },
   "devDependencies": {
-    "@types/node": "^24.19.1",
+    "@types/node": "^24.19.2",
     "@types/ws": "^8.18.2",
-    "jsdom": "30.1.2",
+    "jsdom": "30.1.3",
     "mermaid": "12.1.0"
   }
 }