sneakoscope 10.5.8 → 10.6.0

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.5.8**, prepared for npm publication.
+Current package: **SKS 10.6.0**, 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.5.8"
+version = "10.6.0"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

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

package/dist/config/skills-manifest.json

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

package/dist/core/agents/agent-orchestrator.js

@@ -663,13 +663,16 @@ export async function resolveAgentMissionPrompt(root, opts) {
         readJson(path.join(dir, 'route-context.json'), null),
         readJson(path.join(dir, 'mission.json'), null)
     ]);
-    return String(intake?.transformed_prompt
-        || routeContext?.transformed_prompt
-        || routeContext?.task
-        || routeContext?.prompt
-        || mission?.prompt
-        || direct
-        || 'Native agent run').trim();
+    const candidates = [
+        intake?.transformed_prompt,
+        routeContext?.transformed_prompt,
+        routeContext?.task,
+        routeContext?.prompt,
+        mission?.prompt,
+        direct,
+        'Native agent run'
+    ];
+    return candidates.find((value) => typeof value === 'string' && value.trim().length > 0).trim();
 }
 function normalizeMissionHardTimeoutMs(opts = {}, route = '') {
     const raw = Number(opts.hardTimeoutMs || opts.agentHardTimeoutMs || process.env.SKS_AGENT_HARD_TIMEOUT_MS || 0);

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

@@ -13,9 +13,15 @@ export const BRIDGE_COMPACTION_ENVELOPE_PREFIX = 'sks-bridge-compaction.v1.';
 const COMPACTION_ITEM_TYPES = new Set(['compaction', 'compaction_summary', 'context_compaction']);
 const MAX_SUMMARY_CHARS = 512 * 1024;
 const MAX_RETAINED_USER_MESSAGE_CHARS = 80_000;
+const SUMMARY_REASONING_EFFORT_CEILING = 'medium';
+const EFFORTS_ABOVE_SUMMARY_CEILING = new Set(['high', 'xhigh', 'max', 'ultra']);
 function isObject(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
+export function safeUpstreamErrorId(value) {
+    const text = String(value ?? '').trim();
+    return /^[A-Za-z0-9_.:-]{1,64}$/.test(text) ? text : null;
+}
 export function isCompactionTriggerItem(item) {
     return isObject(item) && item.type === 'compaction_trigger';
 }
@@ -56,6 +62,10 @@ export function expandBridgeCompactionItems(payload) {
         payload.input = input;
     return changed;
 }
+function carriesToolDefinitions(body) {
+    return (Array.isArray(body.tools) && body.tools.length > 0)
+        || (Array.isArray(body.input) && body.input.some((item) => isObject(item) && item.type === 'additional_tools'));
+}
 export function buildCompactionSummaryRequest(payload, upstreamModel) {
     const { type: _eventType, ...request } = payload;
     const history = Array.isArray(payload.input) ? payload.input.filter((item) => !isCompactionTriggerItem(item)) : [];
@@ -68,17 +78,110 @@ export function buildCompactionSummaryRequest(payload, upstreamModel) {
         ],
         stream: true,
     };
-    if (Array.isArray(body.tools) && body.tools.length > 0)
+    if (carriesToolDefinitions(body))
         body.tool_choice = 'none';
     else {
         delete body.tools;
         delete body.tool_choice;
     }
-    delete body.parallel_tool_calls;
+    body.parallel_tool_calls = false;
+    if (isObject(body.reasoning) && EFFORTS_ABOVE_SUMMARY_CEILING.has(String(body.reasoning.effort))) {
+        body.reasoning = { ...body.reasoning, effort: SUMMARY_REASONING_EFFORT_CEILING };
+    }
     delete body.previous_response_id;
     expandBridgeCompactionItems(body);
     return body;
 }
+function frameEvent(frame) {
+    try {
+        const event = JSON.parse(frame.toString('utf8'));
+        return isObject(event) ? event : null;
+    }
+    catch {
+        return null;
+    }
+}
+export class ResponsesContinuationChain {
+    maxBytes;
+    links = [];
+    bytes = 0;
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+    }
+    sent(create, frame) {
+        const previous = typeof create.previous_response_id === 'string' ? create.previous_response_id : null;
+        const last = this.links?.at(-1);
+        const link = { create: frame, outputs: [], responseId: null, settled: false };
+        if (!previous) {
+            this.links = [link];
+            this.bytes = frame.length;
+        }
+        else if (this.links && last?.settled && last.responseId === previous) {
+            this.links.push(link);
+            this.track(frame.length);
+        }
+        else {
+            this.links = null;
+        }
+    }
+    received(frame) {
+        const link = this.links?.at(-1);
+        if (!link || link.settled)
+            return;
+        if (frame.includes('"response.output_item.done"')) {
+            link.outputs.push(frame);
+            this.track(frame.length);
+        }
+        else if (frame.includes('"response.completed"')) {
+            const event = frameEvent(frame);
+            if (event?.type !== 'response.completed')
+                return;
+            link.settled = true;
+            link.responseId = isObject(event.response) && typeof event.response.id === 'string' ? event.response.id : null;
+        }
+        else if (frame.includes('"response.failed"') || frame.includes('"response.incomplete"') || frame.includes('"type":"error"')) {
+            const type = frameEvent(frame)?.type;
+            if (type === 'response.failed' || type === 'response.incomplete' || type === 'error') {
+                link.settled = true;
+                link.responseId = null;
+            }
+        }
+    }
+    fullInput(create) {
+        const delta = Array.isArray(create.input) ? create.input : [];
+        const previous = typeof create.previous_response_id === 'string' ? create.previous_response_id : null;
+        if (!previous)
+            return delta;
+        const last = this.links?.at(-1);
+        if (!this.links || !last?.settled || last.responseId !== previous)
+            return null;
+        const input = [];
+        for (const link of this.links) {
+            const sent = frameEvent(link.create);
+            if (!sent || !Array.isArray(sent.input))
+                return null;
+            input.push(...sent.input);
+            for (const frame of link.outputs) {
+                const event = frameEvent(frame);
+                if (event?.type === 'response.output_item.done' && isObject(event.item))
+                    input.push(event.item);
+            }
+        }
+        return [...input, ...delta];
+    }
+    track(size) {
+        this.bytes += size;
+        if (this.bytes > this.maxBytes)
+            this.links = null;
+    }
+}
+function summaryError(error, fallback) {
+    const record = isObject(error) ? error : {};
+    return {
+        code: safeUpstreamErrorId(record.code) ?? safeUpstreamErrorId(record.type) ?? fallback,
+        param: safeUpstreamErrorId(record.param),
+    };
+}
 function messageText(item) {
     if (!isObject(item) || item.type !== 'message' || (item.role !== undefined && item.role !== 'assistant'))
         return '';
@@ -97,10 +200,16 @@ export function parseProviderSummary(text) {
             const parsed = JSON.parse(trimmed);
             const response = isObject(parsed) && isObject(parsed.response) ? parsed.response : parsed;
             const summary = outputText(isObject(response) ? response.output : null).trim();
-            return { summary: summary || null, usage: isObject(response) && isObject(response.usage) ? response.usage : null, failed: !summary };
+            const failure = isObject(response) && isObject(response.error) ? summaryError(response.error, 'response_failed') : null;
+            return {
+                summary: summary || null,
+                usage: isObject(response) && isObject(response.usage) ? response.usage : null,
+                failed: !summary,
+                error: summary ? null : failure,
+            };
         }
         catch {
-            return { summary: null, usage: null, failed: true };
+            return { summary: null, usage: null, failed: true, error: null };
         }
     }
     const finished = [];
@@ -109,6 +218,7 @@ export function parseProviderSummary(text) {
     let usage = null;
     let completed = false;
     let failed = false;
+    let error = null;
     for (const block of text.split(/\r?\n\r?\n/)) {
         const data = block.split(/\r?\n/).filter((line) => line.startsWith('data:')).map((line) => line.slice(5).trimStart()).join('\n');
         if (!data || data === '[DONE]')
@@ -142,20 +252,41 @@ export function parseProviderSummary(text) {
                 }
                 break;
             case 'response.failed':
-            case 'response.incomplete':
+                failed = true;
+                error ??= summaryError(isObject(event.response) ? event.response.error : null, 'response_failed');
+                break;
+            case 'response.incomplete': {
+                failed = true;
+                const details = isObject(event.response) ? event.response.incomplete_details : null;
+                error ??= { code: 'response_incomplete', param: isObject(details) ? safeUpstreamErrorId(details.reason) : null };
+                break;
+            }
             case 'error':
                 failed = true;
+                error ??= summaryError(isObject(event.error) ? event.error : { code: event.code, param: event.param }, 'response_failed');
                 break;
             default:
                 break;
         }
     }
     const summary = (finished.join('\n\n') || completedOutput || deltas).trim();
-    return { summary: summary || null, usage, failed: failed || !completed || !summary };
+    return { summary: summary || null, usage, failed: failed || !completed || !summary, error };
 }
 export function summaryWithinBounds(summary) {
     return typeof summary === 'string' && summary.length > 0 && summary.length <= MAX_SUMMARY_CHARS;
 }
+export function summaryFailure(result, status) {
+    const named = result.error ? `:${result.error.code}${result.error.param ? `:${result.error.param}` : ''}` : '';
+    if (status >= 300) {
+        return {
+            code: status === 429 ? 'rate_limit_exceeded' : result.error?.code ?? 'bridge_upstream_request_failed',
+            logCode: `bridge_compaction_summary_status_${status}${named}`,
+        };
+    }
+    return result.error
+        ? { code: result.error.code, logCode: `bridge_compaction_summary_failed${named}` }
+        : { code: 'bridge_compaction_summary_unusable', logCode: 'bridge_compaction_summary_unusable' };
+}
 function wholeNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
 }

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

@@ -6,9 +6,9 @@ import { BRIDGE_OFFICIAL_ROUTE_ID } from '../bridge-contracts.js';
 import { buildOfficialPassthroughHeaders, buildProviderUpstreamHeaders, rewriteResponseHeaders } from './header-policy.js';
 import { createDesktopBridgeRejectionLogger } from './rejection-log.js';
 import { OPENROUTER_ONLY_REFUSAL_CODES, openRouterOnlyEnabled } from './exclusive-provider-guard.js';
-import { ensureDesktopBridgeRemoteTarget, isUnreachableUpstreamError, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode, singleBridgeHeader } from './security.js';
+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, sseEvent, summaryWithinBounds, } from './compaction-adapter.js';
+import { buildCompactionSummaryRequest, compactEndpointResult, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, safeUpstreamErrorId, sseEvent, summaryFailure, summaryWithinBounds, } from './compaction-adapter.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) {
@@ -48,10 +48,21 @@ function decodeBridgeRequestBody(body, encoding, maximum) {
         throw new DesktopBridgeError('bridge_responses_body_invalid_json');
     }
 }
+const encodedBodyRefusals = new Set();
+function keepsClientEncoding(route) {
+    return route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID
+        || (route.provider_id === 'codex-lb' && !encodedBodyRefusals.has(route.provider_id));
+}
+async function reencodeLikeClient(plain, encoding) {
+    const compress = zlib.zstdCompress;
+    if (encoding !== 'zstd' || !compress)
+        return null;
+    return new Promise((resolve) => compress(plain, (error, result) => resolve(error ? null : result)));
+}
 const RESPONSES_PATHS = ['/backend-api/codex/responses', '/api/v1/responses', '/v1/responses'];
 function modelBodyKind(req, pathname, config) {
     if (RESPONSES_PATHS.includes(pathname))
-        return 'responses';
+        return req.method === 'POST' ? 'responses' : null;
     return openRouterOnlyEnabled(config) && req.method === 'POST'
         && RESPONSES_PATHS.some((prefix) => pathname.startsWith(`${prefix}/`)) ? 'sub-endpoint' : null;
 }
@@ -91,14 +102,17 @@ export async function prepareDesktopBridgeRequest(req, config) {
     let body = null;
     let payload = null;
     let contentEncodingStripped = false;
+    let encoding = '';
+    let encodedBody = null;
     const bodyKind = modelBodyKind(req, pathname, config);
     if (bodyKind) {
         const maximum = config.maxRequestBodyBytes ?? DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES;
         body = await readBoundedBody(req, maximum);
-        const encoding = String(req.headers['content-encoding'] || '').trim().toLowerCase();
+        encoding = String(req.headers['content-encoding'] || '').trim().toLowerCase();
         let decoded = body;
         if (encoding && encoding !== 'identity') {
             decoded = decodeBridgeRequestBody(body, encoding, maximum);
+            encodedBody = body;
             contentEncodingStripped = true;
         }
         if (bodyKind === 'responses' || decoded.length > 0) {
@@ -134,8 +148,18 @@ export async function prepareDesktopBridgeRequest(req, config) {
     const compaction = bodyKind === 'responses' && requestsRemoteCompaction(payload)
         ? 'trigger'
         : bodyKind === 'sub-endpoint' && isCompactEndpoint(req, pathname) ? 'endpoint' : null;
+    let plainBody = null;
+    const answeredByBridge = Boolean(compaction) && route.provider_id !== BRIDGE_OFFICIAL_ROUTE_ID;
+    if (encodedBody && body && !answeredByBridge && keepsClientEncoding(route)) {
+        const upstreamBody = rewrite ? await reencodeLikeClient(body, encoding) : encodedBody;
+        if (upstreamBody) {
+            plainBody = body;
+            body = upstreamBody;
+            contentEncodingStripped = false;
+        }
+    }
     const credential = route.provider_id === BRIDGE_OFFICIAL_ROUTE_ID ? null : await resolveCredential(config, route);
-    return { body, route, credential, contentEncodingStripped, compaction, payload };
+    return { body, route, credential, contentEncodingStripped, plainBody, compaction, payload };
 }
 function connectTimeout(request, config) {
     request.once('socket', (socket) => {
@@ -172,14 +196,11 @@ function writeHttpBridgeError(res, error, req) {
     });
     res.end(JSON.stringify({ error: { type: 'sks_bridge_error', code, message: code } }));
 }
-function safeUpstreamErrorId(value) {
-    const text = String(value ?? '').trim();
-    return /^[A-Za-z0-9_.:-]{1,64}$/.test(text) ? text : null;
-}
-const TRANSIENT_UPSTREAM_STATUSES = new Set([500, 502, 503, 524]);
+const TRANSIENT_UPSTREAM_STATUSES = new Set([500, 502, 503, 520, 521, 522, 523, 524]);
 const TRANSIENT_UPSTREAM_IDENTIFIERS = new Set(['upstream_error', 'upstream_request_timeout']);
 export const TRANSIENT_UPSTREAM_REPLAY_LIMIT = 3;
 const TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS = [200, 400, 800];
+export const NO_ROUTE_REPLAY_BACKOFF_MS = [250, 500, 1_000, 2_000, 3_000, 4_000];
 function isTransientUpstreamIdentifier(value) {
     return Boolean(value && TRANSIENT_UPSTREAM_IDENTIFIERS.has(value));
 }
@@ -204,6 +225,7 @@ function redactedUpstreamClientMessage(statusCode, transient) {
         return 'temporary_upstream_failure';
     return 'bridge_upstream_request_failed';
 }
+const UNREADABLE_BODY_HINT = /json|pars(?:e|ing)|decod|encod|compress|utf-?8/i;
 async function readRedactedUpstreamError(response) {
     let total = 0;
     const chunks = [];
@@ -218,14 +240,15 @@ async function readRedactedUpstreamError(response) {
     }
     let upstreamCode = null;
     let upstreamType = null;
+    const text = Buffer.concat(chunks).toString('utf8');
     try {
-        const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        const parsed = JSON.parse(text);
         upstreamCode = safeUpstreamErrorId(parsed?.error?.code) ?? safeUpstreamErrorId(parsed?.detail);
         upstreamType = safeUpstreamErrorId(parsed?.error?.type);
     }
     catch {
     }
-    return { upstreamCode, upstreamType };
+    return { upstreamCode, upstreamType, unreadableBody: UNREADABLE_BODY_HINT.test(text.slice(0, 4096)) };
 }
 function buildRedactedUpstreamErrorBody(statusCode, upstreamCode, upstreamType, transient) {
     return Buffer.from(JSON.stringify({
@@ -259,6 +282,7 @@ export function destroyDesktopBridgeUpstreamAgents() {
     for (const agent of upstreamAgents.values())
         agent.destroy();
     upstreamAgents.clear();
+    encodedBodyRefusals.clear();
 }
 const STALE_CONNECTION_ERROR_CODES = new Set(['ECONNRESET', 'EPIPE', 'ECONNABORTED']);
 function isStalePooledSocketFailure(request, error) {
@@ -278,6 +302,8 @@ class StalePooledSocketFailure extends Error {
 }
 class UnreachableUpstreamFailure extends StalePooledSocketFailure {
 }
+class EncodedBodyRefusedFailure extends StalePooledSocketFailure {
+}
 export async function forwardHttp(req, res, config, prepared, authenticatedLocalBaseUrl = desktopBridgeListenOrigin(config)) {
     try {
         const request = prepared || await prepareDesktopBridgeRequest(req, config);
@@ -322,7 +348,9 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             delete headers['content-encoding'];
         const agent = upstreamAgent(remote.secure, `${remote.address}:${remote.port}`, config.idleTimeoutMs);
         const replayable = Buffer.isBuffer(request.body);
-        const attempt = (useFreshConnection, canReplay) => new Promise((resolve, reject) => {
+        let body = request.body;
+        let plainFallbackActive = false;
+        const attempt = (useFreshConnection, budget) => new Promise((resolve, reject) => {
             let responseStarted = false;
             let settled = false;
             const abort = () => { if (!res.writableEnded)
@@ -347,7 +375,7 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             res.once('close', abort);
             upstream.once('error', (error) => {
                 if (!responseStarted && isUnreachableUpstreamError(error)) {
-                    if (replayable && canReplay) {
+                    if (replayable && (isNoRouteUpstreamError(error) ? budget.noRoute : budget.transient)) {
                         finish(new UnreachableUpstreamFailure(error));
                         return;
                     }
@@ -361,8 +389,12 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             });
             upstream.once('response', (response) => {
                 const statusCode = response.statusCode || 502;
+                if (plainFallbackActive && statusCode < 400 && !official && !encodedBodyRefusals.has(provider.provider_id)) {
+                    encodedBodyRefusals.add(provider.provider_id);
+                    logHttpRejection({ code: 'bridge_upstream_encoded_body_refused', transport: 'http', ...(req.method === undefined ? {} : { method: req.method }), ...(req.url === undefined ? {} : { url: req.url }), provider_id: provider.provider_id });
+                }
                 if (official) {
-                    if (statusCode >= 400 && TRANSIENT_UPSTREAM_STATUSES.has(statusCode) && replayable && canReplay) {
+                    if (statusCode >= 400 && TRANSIENT_UPSTREAM_STATUSES.has(statusCode) && replayable && budget.transient) {
                         response.resume();
                         responseStarted = true;
                         finish(new StalePooledSocketFailure(new DesktopBridgeError('bridge_upstream_transient_mislabel')));
@@ -392,9 +424,15 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                     return;
                 }
                 if (statusCode >= 400) {
-                    void readRedactedUpstreamError(response).then(({ upstreamCode, upstreamType }) => {
+                    void readRedactedUpstreamError(response).then(({ upstreamCode, upstreamType, unreadableBody }) => {
+                        if (budget.plainFallback && (statusCode === 415
+                            || (unreadableBody && !upstreamType && !upstreamCode && (statusCode === 400 || statusCode === 422)))) {
+                            responseStarted = true;
+                            finish(new EncodedBodyRefusedFailure(new DesktopBridgeError(`bridge_upstream_encoded_body_refused_${statusCode}`)));
+                            return;
+                        }
                         const transientMislabel = isTransientUpstreamFailure(statusCode, upstreamType, upstreamCode);
-                        if (transientMislabel && replayable && canReplay) {
+                        if (transientMislabel && replayable && budget.transient) {
                             responseStarted = true;
                             finish(new StalePooledSocketFailure(new DesktopBridgeError(upstreamCode === 'upstream_request_timeout'
                                 ? 'bridge_upstream_request_timeout'
@@ -438,24 +476,46 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                 }
                 void pipeline(response, res).then(() => finish(), finish);
             });
-            if (request.body)
-                upstream.end(request.body);
+            if (body)
+                upstream.end(body);
             else
                 void pipeline(req, upstream).catch((error) => { if (!responseStarted)
                     finish(error); });
         });
-        let remainingReplays = replayable ? TRANSIENT_UPSTREAM_REPLAY_LIMIT : 0;
+        let transientReplays = replayable ? TRANSIENT_UPSTREAM_REPLAY_LIMIT : 0;
+        let noRouteWaits = replayable ? NO_ROUTE_REPLAY_BACKOFF_MS.length : 0;
         let useFreshConnection = false;
         for (;;) {
             try {
-                await attempt(useFreshConnection, remainingReplays > 0);
+                await attempt(useFreshConnection, {
+                    transient: transientReplays > 0,
+                    noRoute: noRouteWaits > 0,
+                    plainFallback: Boolean(request.plainBody) && !plainFallbackActive,
+                });
                 return;
             }
             catch (error) {
-                if (!(error instanceof StalePooledSocketFailure) || remainingReplays <= 0)
+                if (!(error instanceof StalePooledSocketFailure))
                     throw error;
-                remainingReplays -= 1;
-                if (error instanceof UnreachableUpstreamFailure) {
+                let backoffMs = 0;
+                if (error instanceof EncodedBodyRefusedFailure) {
+                    body = request.plainBody;
+                    plainFallbackActive = true;
+                    headers['content-length'] = String(body.length);
+                    delete headers['content-encoding'];
+                }
+                else if (error instanceof UnreachableUpstreamFailure) {
+                    const noRoute = isNoRouteUpstreamError(error.reason);
+                    if ((noRoute ? noRouteWaits : transientReplays) <= 0)
+                        throw error;
+                    if (noRoute) {
+                        backoffMs = NO_ROUTE_REPLAY_BACKOFF_MS[NO_ROUTE_REPLAY_BACKOFF_MS.length - noRouteWaits];
+                        noRouteWaits -= 1;
+                    }
+                    else {
+                        backoffMs = TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS[TRANSIENT_UPSTREAM_REPLAY_LIMIT - transientReplays];
+                        transientReplays -= 1;
+                    }
                     const staleAddress = remote.address;
                     await refreshDesktopBridgeRemoteTarget(remote, config.remoteLookup);
                     agent.destroy();
@@ -468,6 +528,10 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                     });
                 }
                 else {
+                    if (transientReplays <= 0)
+                        throw error;
+                    backoffMs = TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS[TRANSIENT_UPSTREAM_REPLAY_LIMIT - transientReplays];
+                    transientReplays -= 1;
                     if (!useFreshConnection) {
                         agent.destroy();
                         upstreamAgents.delete(`${remote.secure ? 'https' : 'http'}:${remote.address}:${remote.port}`);
@@ -480,9 +544,6 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                     });
                 }
                 useFreshConnection = true;
-                const backoffIndex = TRANSIENT_UPSTREAM_REPLAY_LIMIT - remainingReplays - 1;
-                const backoffMs = TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS[Math.max(0, backoffIndex)]
-                    ?? TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS[TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS.length - 1];
                 if (backoffMs)
                     await delay(backoffMs);
             }
@@ -496,8 +557,9 @@ const MAX_COMPACTION_SUMMARY_RESPONSE_BYTES = 32 * 1024 * 1024;
 const COMPACTION_KEEPALIVE_MS = 15_000;
 export async function requestProviderCompactionSummary(config, input, body, onAccepted = () => undefined) {
     const remote = input.provider.remote;
-    let remaining = TRANSIENT_UPSTREAM_REPLAY_LIMIT;
-    for (let attempt = 0;; attempt += 1) {
+    let transientReplays = TRANSIENT_UPSTREAM_REPLAY_LIMIT;
+    let noRouteWaits = NO_ROUTE_REPLAY_BACKOFF_MS.length;
+    for (;;) {
         await ensureDesktopBridgeRemoteTarget(remote, config.remoteLookup);
         const target = resolveDesktopBridgeTarget(input.requestUrl, remote);
         const headers = buildProviderUpstreamHeaders(input.clientHeaders, {
@@ -537,22 +599,31 @@ export async function requestProviderCompactionSummary(config, input, body, onAc
                 });
                 upstream.end(body);
             });
-            if (result.status < 300 || remaining <= 0)
+            if (result.status < 300 || transientReplays <= 0)
                 return result;
             const { upstreamCode, upstreamType } = upstreamErrorIds(result.body);
             if (!isTransientUpstreamFailure(result.status, upstreamType, upstreamCode))
                 return result;
+            await delay(TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS[TRANSIENT_UPSTREAM_REPLAY_LIMIT - transientReplays]);
+            transientReplays -= 1;
         }
         catch (error) {
-            if (remaining <= 0 || error instanceof DesktopBridgeError)
+            if (error instanceof DesktopBridgeError)
+                throw error;
+            const noRoute = isNoRouteUpstreamError(error);
+            if ((noRoute ? noRouteWaits : transientReplays) <= 0)
                 throw error;
             if (isUnreachableUpstreamError(error))
                 await refreshDesktopBridgeRemoteTarget(remote, config.remoteLookup);
+            if (noRoute) {
+                await delay(NO_ROUTE_REPLAY_BACKOFF_MS[NO_ROUTE_REPLAY_BACKOFF_MS.length - noRouteWaits]);
+                noRouteWaits -= 1;
+            }
+            else {
+                await delay(TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS[TRANSIENT_UPSTREAM_REPLAY_LIMIT - transientReplays]);
+                transientReplays -= 1;
+            }
         }
-        remaining -= 1;
-        const backoffMs = TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS[Math.min(attempt, TRANSIENT_UPSTREAM_REPLAY_BACKOFF_MS.length - 1)];
-        if (backoffMs)
-            await delay(backoffMs);
     }
 }
 function upstreamErrorIds(body) {
@@ -593,9 +664,10 @@ async function answerCompactionWithProviderSummary(req, res, config, input) {
     });
     try {
         const call = await requestProviderCompactionSummary(config, input, body, startStream);
+        const parsed = parseProviderSummary(call.body.toString('utf8'));
         if (call.status >= 300) {
             const { upstreamCode, upstreamType } = upstreamErrorIds(call.body);
-            log(upstreamCode ? `bridge_compaction_summary_status_${call.status}:${upstreamCode}` : `bridge_compaction_summary_status_${call.status}`, call.status);
+            log(summaryFailure(parsed, call.status).logCode, call.status);
             const transient = isTransientUpstreamFailure(call.status, upstreamType, upstreamCode);
             const clientStatus = transient ? 503 : call.status;
             const errorBody = buildRedactedUpstreamErrorBody(call.status, upstreamCode, upstreamType, transient);
@@ -606,12 +678,12 @@ async function answerCompactionWithProviderSummary(req, res, config, input) {
             res.end(errorBody);
             return;
         }
-        const parsed = parseProviderSummary(call.body.toString('utf8'));
         const summary = parsed.failed || !summaryWithinBounds(parsed.summary) ? null : parsed.summary;
         if (!summary) {
-            log('bridge_compaction_summary_unusable', call.status);
+            const failure = summaryFailure(parsed, call.status);
+            log(failure.logCode, call.status);
             if (streaming) {
-                res.end(sseEvent(compactionFailedEvent(responseId, publicModel, 'bridge_compaction_summary_unusable')));
+                res.end(sseEvent(compactionFailedEvent(responseId, publicModel, failure.code)));
             }
             else {
                 writeHttpBridgeError(res, new DesktopBridgeError('bridge_compaction_summary_unusable'), req);

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

@@ -6,7 +6,7 @@ import { buildOfficialPassthroughWebSocketHeaders, buildProviderWebSocketHeaders
 import { createDesktopBridgeRejectionLogger } from './rejection-log.js';
 import { assertDesktopBridgeRouteContext, ensureDesktopBridgeRemoteTarget, isUnreachableUpstreamError, refreshDesktopBridgeRemoteTarget, resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode } from './security.js';
 import { DEFAULT_DESKTOP_BRIDGE_MAX_REQUEST_BODY_BYTES, DesktopBridgeError } from './types.js';
-import { buildCompactionSummaryRequest, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, summaryWithinBounds, } from './compaction-adapter.js';
+import { buildCompactionSummaryRequest, compactionCreatedEvent, compactionFailedEvent, compactionResponseEvents, expandBridgeCompactionItems, newCompactionResponseId, parseProviderSummary, requestsRemoteCompaction, ResponsesContinuationChain, summaryFailure, summaryWithinBounds, } from './compaction-adapter.js';
 import { requestProviderCompactionSummary } from './http-forward.js';
 const MAX_PENDING_MESSAGES = 256;
 const CLOSE_GRACE_MS = 1_000;
@@ -53,6 +53,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
         const pending = [];
         let closeTimer = null;
         let handshakeTimer = null;
+        const chain = new ResponsesContinuationChain(maxBytes);
         const initialTimer = setTimeout(closeUnbound, config.websocketInitialCreateTimeoutMs ?? INITIAL_CREATE_TIMEOUT_MS);
         initialTimer.unref();
         const localSocket = socket;
@@ -118,8 +119,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             if (typeof model !== 'string' || !model.trim())
                 throw new DesktopBridgeError('bridge_websocket_model_required');
             const nextIdentity = resolveCodexSessionIdentity(req.headers, message.create);
-            if (bound && ((nextIdentity.thread_id && nextIdentity.thread_id !== identity.thread_id)
-                || (nextIdentity.session_id && nextIdentity.session_id !== identity.session_id))) {
+            if (bound && nextIdentity.thread_id && nextIdentity.thread_id !== identity.thread_id) {
                 throw new DesktopBridgeError('bridge_codex_session_identity_conflict');
             }
             identity = bound ? withLineage(identity, nextIdentity) : nextIdentity;
@@ -141,6 +141,7 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             }
             if (route.upstream_model !== model || expanded)
                 message.data = Buffer.from(JSON.stringify(create));
+            message.routed = create;
         }
         async function answerCompaction(create) {
             const route = bound;
@@ -150,7 +151,13 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             const credential = await config.resolveProviderCredential(provider.provider_id, provider.credential_generation);
             const responseId = newCompactionResponseId();
             const send = (event) => relay(client, Buffer.from(JSON.stringify(event)), false);
-            const body = Buffer.from(JSON.stringify(buildCompactionSummaryRequest(create, route.upstream_model)));
+            const input = chain.fullInput(create);
+            if (!input) {
+                logRejection({ code: 'bridge_compaction_history_unavailable', transport: 'websocket', provider_id: provider.provider_id, public_model: route.public_model, ...(req.url ? { url: req.url } : {}) });
+                send(compactionFailedEvent(responseId, route.public_model, 'bridge_compaction_history_unavailable'));
+                return;
+            }
+            const body = Buffer.from(JSON.stringify(buildCompactionSummaryRequest({ ...create, input }, route.upstream_model)));
             let accepted = false;
             try {
                 const call = await requestProviderCompactionSummary(config, { provider, credential, clientHeaders: req.headers, requestUrl: req.url || '/' }, body, () => {
@@ -161,15 +168,11 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
                 });
                 if (stopped)
                     return;
-                if (call.status >= 300) {
-                    logRejection({ code: `bridge_compaction_summary_status_${call.status}`, transport: 'websocket', ...(req.url ? { url: req.url } : {}) });
-                    send(compactionFailedEvent(responseId, route.public_model, call.status === 429 ? 'rate_limit_exceeded' : 'bridge_upstream_request_failed'));
-                    return;
-                }
                 const parsed = parseProviderSummary(call.body.toString('utf8'));
-                if (parsed.failed || !summaryWithinBounds(parsed.summary)) {
-                    logRejection({ code: 'bridge_compaction_summary_unusable', transport: 'websocket', ...(req.url ? { url: req.url } : {}) });
-                    send(compactionFailedEvent(responseId, route.public_model, 'bridge_compaction_summary_unusable'));
+                if (call.status >= 300 || parsed.failed || !summaryWithinBounds(parsed.summary)) {
+                    const failure = summaryFailure(parsed, call.status);
+                    logRejection({ code: failure.logCode, transport: 'websocket', status: call.status, provider_id: provider.provider_id, public_model: route.public_model, ...(req.url ? { url: req.url } : {}) });
+                    send(compactionFailedEvent(responseId, route.public_model, failure.code));
                     return;
                 }
                 const events = compactionResponseEvents(responseId, route.public_model, parsed.summary, parsed.usage);
@@ -244,8 +247,10 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
             peer.on('message', (data, binary) => {
                 if (stopped)
                     return;
+                const frame = bytes(data);
+                chain.received(frame);
                 try {
-                    relay(client, bytes(data), binary);
+                    relay(client, frame, binary);
                 }
                 catch (error) {
                     fail(error);
@@ -291,8 +296,11 @@ export function forwardResponsesWebSocket(req, socket, head, config) {
                         return;
                     if (message.compaction)
                         await answerCompaction(message.compaction);
-                    else
+                    else {
                         relay(upstream, message.data, message.binary);
+                        if (message.routed && bound?.provider_id !== BRIDGE_OFFICIAL_ROUTE_ID)
+                            chain.sent(message.routed, message.data);
+                    }
                     pending.shift();
                     pendingBytes -= message.originalBytes;
                 }

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

@@ -115,7 +115,7 @@ function codexMetadataObject(value, source) {
     }
     return parsed;
 }
-function oneCodexIdentity(values, kind) {
+function oneCodexIdentity(values) {
     const canonical = values
         .filter((value) => value !== undefined && value !== null && value !== '')
         .map(canonicalSessionId);
@@ -123,6 +123,17 @@ function oneCodexIdentity(values, kind) {
         throw new DesktopBridgeError('bridge_codex_session_identity_conflict');
     return canonical[0] || null;
 }
+function firstSessionId(values) {
+    for (const value of values) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        try {
+            return canonicalSessionId(value);
+        }
+        catch { }
+    }
+    return null;
+}
 export function resolveCodexSessionIdentity(headers, payload = null) {
     const turnMetadataValue = singleBridgeHeader(headers, 'x-codex-turn-metadata');
     const turnMetadata = turnMetadataValue === null ? null : codexMetadataObject(turnMetadataValue, 'header');
@@ -132,12 +143,12 @@ export function resolveCodexSessionIdentity(headers, payload = null) {
         singleBridgeHeader(headers, 'thread-id'),
         turnMetadata?.thread_id,
         clientMetadata?.thread_id,
-    ], 'thread');
-    const sessionId = oneCodexIdentity([
-        singleBridgeHeader(headers, 'session-id'),
-        turnMetadata?.session_id,
+    ]);
+    const sessionId = firstSessionId([
         clientMetadata?.session_id,
-    ], 'session');
+        turnMetadata?.session_id,
+        singleBridgeHeader(headers, 'session-id'),
+    ]);
     if (sessionId && !threadId)
         throw new DesktopBridgeError('bridge_codex_thread_id_missing');
     const nested = nestedTurnMetadata(clientMetadata);
@@ -348,8 +359,22 @@ export function assertDesktopBridgeRouteContext(request, config) {
     return route;
 }
 export async function resolveAndBindDesktopBridgeRouteContext(request, config) {
+    const pinsRead = config.providerSessionPins;
+    let steady = null;
+    try {
+        steady = assertDesktopBridgeRouteContext(request, config);
+    }
+    catch {
+        steady = null;
+    }
+    const steadyPin = steady?.session_pin;
+    if (steady && !steadyPin)
+        return steady;
+    const persisted = steadyPin ? pinsRead.find((entry) => entry.thread_id === steadyPin.thread_id) : undefined;
+    if (steady && steadyPin && persisted && sameSessionPin(persisted, steadyPin))
+        return steady;
     return withSessionPinMutation(config, async () => {
-        const route = assertDesktopBridgeRouteContext(request, config);
+        const route = steady && config.providerSessionPins === pinsRead ? steady : assertDesktopBridgeRouteContext(request, config);
         const pin = route.session_pin;
         if (!pin)
             return route;
@@ -455,7 +480,10 @@ export async function resolveDesktopBridgeRemoteTarget(raw, lookup = defaultLook
     if (!loopback && addresses.some((row) => FORBIDDEN_REMOTE_ADDRESSES.check(row.address, row.family === 4 ? 'ipv4' : 'ipv6'))) {
         throw new DesktopBridgeError('bridge_remote_dns_private_address');
     }
+    const avoided = options.avoidAddress ? addresses.find((row) => row.address === options.avoidAddress) : undefined;
     const selected = (options.preferAddress ? addresses.find((row) => row.address === options.preferAddress) : undefined)
+        ?? (avoided ? addresses.find((row) => row.family !== avoided.family) : undefined)
+        ?? (options.preferFamily ? addresses.find((row) => row.family === options.preferFamily && row.address !== options.avoidAddress) : undefined)
         ?? addresses.find((row) => row.address !== options.avoidAddress)
         ?? addresses[0];
     if (!selected)
@@ -498,6 +526,11 @@ export function isUnreachableUpstreamError(error) {
     const code = error?.code;
     return typeof code === 'string' && UNREACHABLE_UPSTREAM_ERROR_CODES.has(code);
 }
+const NO_ROUTE_UPSTREAM_ERROR_CODES = new Set(['ENETUNREACH', 'EHOSTUNREACH', 'ENETDOWN', 'EHOSTDOWN', 'EADDRNOTAVAIL', 'EAFNOSUPPORT']);
+export function isNoRouteUpstreamError(error) {
+    const code = error?.code;
+    return typeof code === 'string' && NO_ROUTE_UPSTREAM_ERROR_CODES.has(code);
+}
 export const REMOTE_REFRESH_COOLDOWN_MS = 5_000;
 export const REMOTE_TARGET_TTL_MS = 5 * 60_000;
 export async function refreshDesktopBridgeRemoteTarget(remote, lookup = defaultLookup, reason = 'unreachable') {
@@ -512,7 +545,7 @@ export async function refreshDesktopBridgeRemoteTarget(remote, lookup = defaultL
         let resolvedAt = state.resolvedAt;
         try {
             const fresh = await resolveDesktopBridgeRemoteTarget(remote.baseUrl, lookup, reason === 'stale'
-                ? { preferAddress: remote.address }
+                ? { preferAddress: remote.address, preferFamily: remote.family }
                 : reason === 'unreachable' ? { avoidAddress: remote.address } : {});
             const changed = remote.unresolved === true || fresh.address !== remote.address || fresh.family !== remote.family;
             remote.address = fresh.address;

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

@@ -291,6 +291,9 @@ export async function startPreparedDesktopBridge(input, options = {}) {
         if (!socket.destroyed)
             socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
     });
+    server.on('drop', () => {
+        logBridgeRejection({ code: 'bridge_connection_limit_reached', transport: 'http' });
+    });
     server.on('upgrade', (req, socket, head) => {
         try {
             assertLoopbackPeer(req.socket.remoteAddress);

package/dist/core/fsx.js

@@ -693,9 +693,72 @@ export async function terminateProcessTree(pid, child) {
     signalProcessTree(pid, 'SIGTERM', child);
     if (await waitForProcessTreeExit(pid, 1_000))
         return;
+    await killProcessGroupDescendants(pid);
     signalProcessTree(pid, 'SIGKILL', child);
     await waitForProcessTreeExit(pid, 1_500);
 }
+async function killProcessGroupDescendants(groupId) {
+    if (!groupId || process.platform === 'win32')
+        return;
+    const members = linuxProcessGroupMembers(groupId)
+        .filter((member) => member.pid !== groupId)
+        .sort((left, right) => right.depth - left.depth || right.pid - left.pid);
+    for (const member of members) {
+        try {
+            process.kill(member.pid, 'SIGKILL');
+        }
+        catch { }
+    }
+    if (members.length)
+        await new Promise((resolve) => setTimeout(resolve, 50));
+}
+function linuxProcessGroupMembers(groupId) {
+    if (process.platform !== 'linux')
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync('/proc');
+    }
+    catch {
+        return [];
+    }
+    const rows = [];
+    for (const entry of entries) {
+        if (!/^\d+$/.test(entry))
+            continue;
+        const stat = readLinuxProcessStat(Number(entry));
+        if (!stat || stat.pgrp !== groupId)
+            continue;
+        rows.push({ pid: stat.pid, ppid: stat.ppid });
+    }
+    const parents = new Map(rows.map((row) => [row.pid, row.ppid]));
+    return rows.map((row) => {
+        let depth = 0;
+        const seen = new Set();
+        let current = row.ppid;
+        while (parents.has(current) && !seen.has(current)) {
+            seen.add(current);
+            depth += 1;
+            current = parents.get(current);
+        }
+        return { pid: row.pid, depth };
+    });
+}
+function readLinuxProcessStat(pid) {
+    try {
+        const text = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const close = text.lastIndexOf(')');
+        if (close < 0)
+            return null;
+        const fields = text.slice(close + 1).trim().split(/\s+/);
+        const ppid = Number(fields[1]);
+        const pgrp = Number(fields[2]);
+        return Number.isInteger(ppid) && Number.isInteger(pgrp) ? { pid, ppid, pgrp } : null;
+    }
+    catch {
+        return null;
+    }
+}
 function signalProcessTree(pid, signal, child) {
     if (pid && process.platform !== 'win32') {
         try {

package/dist/core/version.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "10.5.8",
+  "version": "10.6.0",
   "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",
@@ -193,8 +193,8 @@
   "dependencies": {
     "@modelcontextprotocol/client": "2.3.1",
     "@modelcontextprotocol/server": "2.3.1",
-    "@openai/codex-sdk": "0.160.1",
-    "smol-toml": "^1.9.0",
+    "@openai/codex-sdk": "0.163.0",
+    "smol-toml": "^1.9.1",
     "typescript": "^6.0.3",
     "ws": "^8.22.0"
   },