sneakoscope 8.1.2 → 8.2.0

package/dist/commands/mad-sks.js

@@ -1,11 +1,7 @@
 import { madHighCommand } from '../core/commands/mad-sks-command.js';
-import { maybePromptCodexUpdateForLaunch, maybePromptCodexLbSetupForLaunch, maybePromptSksUpdateForLaunch } from '../cli/install-helpers.js';
 import { PACKAGE_VERSION } from '../core/fsx.js';
 export async function run(_command, args = []) {
     return madHighCommand(['--mad-sks', ...args], {
-        maybePromptSksUpdateForLaunch,
-        maybePromptCodexUpdateForLaunch,
-        maybePromptCodexLbSetupForLaunch,
         packageVersion: PACKAGE_VERSION
     });
 }

package/dist/config/skills-manifest.json

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

package/dist/core/agents/agent-effort-policy.js

@@ -1,5 +1,5 @@
 import { codexModelEffortCapability } from '../codex-control/codex-model-capabilities.js';
-import { GLM_52_OPENROUTER_MODEL } from '../codex-app/openrouter-provider.js';
+import { OPENROUTER_DEFAULT_MODEL } from '../codex-app/openrouter-provider.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
 import { isNarutoGpt56Model } from '../provider/model-router.js';
 import { decideSubagentModel, subagentModelProfile } from '../subagents/model-policy.js';
@@ -231,13 +231,13 @@ export function decideAgentWorkerModel(input = {}) {
     const risky = HIGH_SIGNAL_RE.test(text) || XHIGH_SIGNAL_RE.test(text);
     const simple = SIMPLE_CODE_MOD_RE.test(simpleText) && !HIGH_SIGNAL_RE.test(simpleText) && !XHIGH_SIGNAL_RE.test(simpleText);
     if (glmMain) {
-        const glmEffort = glmWorkerEffort({ effort, risky, simple });
+        const openRouterEffort = openRouterWorkerEffort({ effort, risky, simple });
         return {
-            model: GLM_52_OPENROUTER_MODEL,
-            model_reasoning_effort: glmEffort,
-            model_tier: `glm-5.2-${glmEffort === 'none' ? 'minimal' : glmEffort}`,
-            model_profile: glmProfileForReasoning(glmEffort),
-            reason: `glm_52_${glmEffort}_worker`
+            model: OPENROUTER_DEFAULT_MODEL,
+            model_reasoning_effort: openRouterEffort,
+            model_tier: `glm-5.2-${openRouterEffort === 'none' ? 'minimal' : openRouterEffort}`,
+            model_profile: desktopBridgeOpenRouterProfile(openRouterEffort),
+            reason: `desktop_bridge_openrouter_${openRouterEffort}_worker`
         };
     }
     const modelEffort = risky || effort === 'high' || effort === 'xhigh'
@@ -259,11 +259,11 @@ function safeProfileSegment(value) {
 }
 function isGlmWorkerMode(mainModel) {
     const model = String(mainModel || '').trim().toLowerCase();
-    return model === GLM_52_OPENROUTER_MODEL
+    return model === OPENROUTER_DEFAULT_MODEL
         || model === 'glm-5.2'
         || model === 'glm5.2';
 }
-function glmWorkerEffort(input) {
+function openRouterWorkerEffort(input) {
     if (input.effort === 'xhigh')
         return 'xhigh';
     if (input.risky || input.effort === 'high')
@@ -272,16 +272,6 @@ function glmWorkerEffort(input) {
         return 'minimal';
     return 'low';
 }
-function glmProfileForReasoning(effort) {
-    if (effort === 'xhigh')
-        return 'sks-openrouter-xhigh';
-    if (effort === 'high')
-        return 'sks-openrouter-high';
-    if (effort === 'medium')
-        return 'sks-openrouter-medium';
-    if (effort === 'low')
-        return 'sks-openrouter-low';
-    if (effort === 'none')
-        return 'sks-openrouter-default';
-    return 'sks-openrouter-minimal';
+function desktopBridgeOpenRouterProfile(effort) {
+    return `desktop-bridge-openrouter-${effort}`;
 }

package/dist/core/agents/agent-recursion-guard.js

@@ -74,6 +74,32 @@ export function scanAgentTextForRecursion(text) {
         warning: violations.length ? 'agent_worker_recursion_attempt_blocked' : null
     };
 }
+export function agentWorkerHookRecursionDecision(state = {}, payload = {}, command = '') {
+    if (!agentWorkerHookContext(state, payload))
+        return null;
+    const guard = scanAgentTextForRecursion(command);
+    if (guard.ok)
+        return null;
+    return {
+        decision: 'block',
+        permissionDecision: 'deny',
+        reason: `Agent command recursion guard blocked nested SKS route command in Codex PreToolUse hook: ${guard.violations.join(', ')}`
+    };
+}
+export function agentWorkerHookContext(state = {}, payload = {}) {
+    const env = {
+        ...(payload.env || {}),
+        ...(payload.tool_input?.env || {}),
+        ...(payload.toolInput?.env || {}),
+        ...(payload.input?.env || {}),
+        ...(payload.tool?.input?.env || {})
+    };
+    void state;
+    return Boolean(String(env.SKS_AGENT_WORKER || '') === '1'
+        || String(env.SKS_DISABLE_ROUTE_RECURSION || '') === '1'
+        || payload.agent_worker === true
+        || payload.agentWorker === true);
+}
 export function assertNoAgentRecursion(text) {
     const result = scanAgentTextForRecursion(text);
     if (!result.ok)

package/dist/core/agents/agent-runner-codex-exec.js

@@ -4,7 +4,7 @@ import { managedProxyEnvForChild } from '../codex/managed-proxy-env.js';
 import { agentWorkerEnv, validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { fastModeEnv, resolveFastModePolicy } from './fast-mode-policy.js';
 import { buildCodexExecArgs } from '../codex/codex-cli-syntax-builder.js';
-import { codexLbRecoveryBlockedProcessResult, withCodexLbCliLaunchRecovery } from '../codex-control/codex-lb-launch-recovery.js';
+import { desktopBridgeLaunchBlockedProcessResult, withDesktopBridgeCliLaunchGuard } from '../codex-control/desktop-bridge-launch-guard.js';
 import { prepareCodexAppServerRuntimeEnv } from '../codex-control/codex-app-server-runtime-env.js';
 export function buildCodexExecAgentArgs(agent, prompt, opts = {}) {
     const resultFile = opts.resultFile || defaultCodexResultFile(agent, opts);
@@ -78,16 +78,14 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
     const runtimeEnv = await prepareCodexAppServerRuntimeEnv({ env: effectiveEnv });
     const proxyEnv = managedProxyEnvForChild(runtimeEnv);
     const execute = opts.runProcessImpl || runProcess;
-    const guarded = await withCodexLbCliLaunchRecovery({
+    const guarded = await withDesktopBridgeCliLaunchGuard({
         root: opts.cwd || process.cwd(),
         env: runtimeEnv,
-        cliArgs: command.args.slice(0, -1),
-        ...(typeof opts.recoveryFetch === 'function' ? { fetchImpl: opts.recoveryFetch } : {}),
-        ...(opts.recoveryTimeoutMs === undefined ? {} : { timeoutMs: opts.recoveryTimeoutMs })
-    }, () => execute(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...runtimeEnv, ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile }));
+        cliArgs: command.args.slice(0, -1)
+    }, (sanitizedEnv) => execute(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...sanitizedEnv, ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile }));
     const result = guarded.launched
         ? guarded.value
-        : codexLbRecoveryBlockedProcessResult(guarded.toolOutputRecovery);
+        : desktopBridgeLaunchBlockedProcessResult(guarded.desktopBridgeLaunchGuard);
     const report = await writeCodexProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, {
         project_hash: opts.projectHash || agent.project_hash || agent.root_hash || null,
         command: [opts.codexBin || 'codex', ...command.args],
@@ -113,7 +111,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
         stderr_bytes: result.stderrBytes,
         truncated: result.truncated,
         timed_out: result.timedOut,
-        codex_lb_tool_output_recovery: guarded.toolOutputRecovery,
+        desktop_bridge_launch_guard: guarded.desktopBridgeLaunchGuard,
         dry_run: false
     });
     if (result.code === 0) {
@@ -138,7 +136,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
             return { ...validated, status: 'blocked', blockers: [...validated.blockers, 'codex_exec_result_schema_invalid'] };
         }
     }
-    return validateAgentWorkerResult({ mission_id: opts.missionId || opts.mission_id || '', agent_id: agent.id, session_id: agent.session_id, persona_id: agent.persona_id || agent.id, task_slice_id: slice?.id || '', status: result.code === 0 ? 'done' : 'failed', backend: 'codex-exec', summary: result.stdout.slice(-1000) || result.stderr.slice(-1000), artifacts: [command.resultFile, report], blockers: result.code === 0 ? ['codex_exec_output_last_message_missing_or_invalid'] : [...(guarded.launched ? [] : guarded.toolOutputRecovery.blockers), 'codex_exec_exit_' + result.code], confidence: 'verified_partial', unverified: result.code === 0 ? ['codex-exec stdout fallback; resultFile JSON missing or invalid'] : [], writes: [], source_intelligence_refs: agent.source_intelligence_refs || null, goal_mode_ref: agent.goal_mode_ref || null, codex_child_report: { tool_output_recovery: guarded.toolOutputRecovery }, verification: { status: result.code === 0 ? 'partial' : 'failed', checks: ['codex-exec-exit-code', 'codex-exec-process-report', 'codex-exec-output-last-message'] } });
+    return validateAgentWorkerResult({ mission_id: opts.missionId || opts.mission_id || '', agent_id: agent.id, session_id: agent.session_id, persona_id: agent.persona_id || agent.id, task_slice_id: slice?.id || '', status: result.code === 0 ? 'done' : 'failed', backend: 'codex-exec', summary: result.stdout.slice(-1000) || result.stderr.slice(-1000), artifacts: [command.resultFile, report], blockers: result.code === 0 ? ['codex_exec_output_last_message_missing_or_invalid'] : [...(guarded.launched ? [] : guarded.desktopBridgeLaunchGuard.blockers), 'codex_exec_exit_' + result.code], confidence: 'verified_partial', unverified: result.code === 0 ? ['codex-exec stdout fallback; resultFile JSON missing or invalid'] : [], writes: [], source_intelligence_refs: agent.source_intelligence_refs || null, goal_mode_ref: agent.goal_mode_ref || null, codex_child_report: { desktop_bridge_launch_guard: guarded.desktopBridgeLaunchGuard }, verification: { status: result.code === 0 ? 'partial' : 'failed', checks: ['codex-exec-exit-code', 'codex-exec-process-report', 'codex-exec-output-last-message'] } });
 }
 function workerNoMcpDefault(agent, opts = {}, sandbox = 'read-only') {
     if (opts.noMcp !== undefined)

package/dist/core/architecture-hardening/contracts/contracts.js

@@ -1,6 +1,9 @@
 import { createHash } from 'node:crypto';
+import { BRIDGE_PROVIDER_IDS } from '../../codex-lb/bridge-contracts.js';
+import { canonicalizeBridgeModelId, normalizeBridgeUpstreamModelId } from '../../codex-lb/route-index.js';
 import { canonicalJson } from '../../json/canonical.js';
-export const ARCHITECTURE_HARDENING_CONTRACT_VERSION = 'sks.architecture-hardening.v1';
+export const ARCHITECTURE_HARDENING_CONTRACT_VERSION = 'sks.architecture-hardening.contracts.v2';
+export const MAX_AUDIT_PROJECTION_DEPTH = 32;
 export class ArchitectureContractError extends Error {
     code;
     constructor(code) {
@@ -9,185 +12,246 @@ export class ArchitectureContractError extends Error {
         this.code = code;
     }
 }
-const PROVIDER_MODES = new Set(['chatgpt-oauth', 'codex-lb', 'openrouter']);
-const CREDENTIAL_CLASSES = new Set(['codex-native-oauth', 'codex-lb-api-key', 'openrouter-api-key']);
+const HISTORICAL_SESSION_PIN_KEYS = [
+    'schema',
+    'session_id',
+    'mode',
+    'model',
+    'credential_class',
+    'allowed_models',
+    'lb_affinity_token_hash',
+    'child_policy_hash',
+    'catalog_version',
+    'parent_session_id'
+];
+const CURRENT_SESSION_PIN_KEYS = [
+    'thread_id',
+    'provider_id',
+    'public_model',
+    'upstream_model',
+    'catalog_generation',
+    'route_policy_generation',
+    'created_at'
+];
+const PROVIDERS = new Set(BRIDGE_PROVIDER_IDS);
 const PROHIBITED_AUDIT_FIELDS = new Set([
+    'account_id',
     'api_key',
-    'secret',
     'authorization',
-    'account_id',
-    'request_body',
+    'client_secret',
+    'cookie',
     'credential_fingerprint',
+    'password',
     'refresh_token',
+    'request_body',
+    'secret',
+    'set_cookie',
     'access_token'
 ]);
-const MAX_AUDIT_PROJECTION_DEPTH = 64;
-export function credentialClassForMode(mode) {
-    if (mode === 'chatgpt-oauth')
-        return 'codex-native-oauth';
-    if (mode === 'codex-lb')
-        return 'codex-lb-api-key';
-    return 'openrouter-api-key';
-}
-export function stableArchitectureHash(value) {
-    return createHash('sha256').update(canonicalJson(value)).digest('hex');
-}
-export function parseProviderPolicySnapshot(value) {
-    const row = objectRecord(value, 'provider_policy_invalid');
-    exactKeys(row, [
-        'schema', 'contract_version', 'mode', 'credential_class', 'allowed_models', 'child_policy_hash', 'catalog_version'
-    ], 'provider_policy_unknown_field');
-    if (row.schema !== 'sks.provider-policy-snapshot.v1')
-        fail('provider_policy_schema_invalid');
-    if (row.contract_version !== ARCHITECTURE_HARDENING_CONTRACT_VERSION)
-        fail('provider_policy_version_mismatch');
-    if (!PROVIDER_MODES.has(row.mode))
-        fail('provider_policy_mode_invalid');
-    if (!CREDENTIAL_CLASSES.has(row.credential_class))
-        fail('provider_policy_credential_class_invalid');
-    if (credentialClassForMode(row.mode) !== row.credential_class)
-        fail('provider_policy_credential_class_mismatch');
-    const models = stringArray(row.allowed_models, 'provider_policy_allowed_models_invalid');
-    if (models.length !== new Set(models).size || models.some((model) => !model.trim()))
-        fail('provider_policy_allowed_models_invalid');
-    if (!safeHash(row.child_policy_hash))
-        fail('provider_policy_child_hash_invalid');
-    if (!safeVersion(row.catalog_version))
-        fail('provider_policy_catalog_version_invalid');
-    return value;
-}
-export function validateArchitectureConfiguration(value) {
-    const row = objectRecord(value, 'architecture_configuration_invalid');
-    exactKeys(row, ['schema', 'policy', 'credential', 'catalog', 'features'], 'architecture_configuration_unknown_field');
-    if (row.schema !== 'sks.architecture-configuration.v1')
-        fail('architecture_configuration_schema_invalid');
-    parseProviderPolicySnapshot(row.policy);
-    validateCredentialReadiness(row.credential);
-    if (row.catalog !== null)
-        validateCatalogSnapshot(row.catalog);
-    if (!Array.isArray(row.features))
-        fail('architecture_configuration_features_invalid');
-    for (const feature of row.features)
-        validateFeatureCompatibility(feature);
-    assertSafeAuditProjection(value);
-    return value;
-}
-export function assertProviderPolicyCompatible(expected, actual) {
-    parseProviderPolicySnapshot(expected);
-    parseProviderPolicySnapshot(actual);
-    if (expected.mode !== actual.mode)
-        fail('provider_policy_mode_mismatch');
-    if (expected.credential_class !== actual.credential_class)
-        fail('provider_policy_credential_mismatch');
-    if (expected.child_policy_hash !== actual.child_policy_hash)
-        fail('provider_policy_child_mismatch');
-    if (expected.catalog_version !== actual.catalog_version)
-        fail('provider_policy_catalog_mismatch');
-    if (canonicalJson([...expected.allowed_models].sort()) !== canonicalJson([...actual.allowed_models].sort())) {
-        fail('provider_policy_model_allowlist_mismatch');
+export function decodeHistoricalSessionPinV1(value, context) {
+    const row = record(value);
+    if (!row || row.schema !== 'sks.session-pin.v1')
+        return decodeFailure('historical_session_pin_invalid');
+    if (!hasExactKeys(row, HISTORICAL_SESSION_PIN_KEYS))
+        return decodeFailure('historical_session_pin_unknown_field');
+    const provider = historicalProvider(row.mode);
+    if (!provider)
+        return decodeFailure('historical_session_pin_mode_unsupported');
+    if (row.credential_class !== credentialClassForProvider(provider)) {
+        return decodeFailure('historical_session_pin_credential_mismatch');
+    }
+    const sessionId = safeIdentifier(row.session_id);
+    const publicModel = canonicalizeBridgeModelId(row.model);
+    if (!sessionId || !publicModel)
+        return decodeFailure('historical_session_pin_model_invalid');
+    const allowedModels = canonicalModelArray(row.allowed_models);
+    if (!allowedModels || !allowedModels.includes(publicModel)) {
+        return decodeFailure('historical_session_pin_model_not_allowed');
+    }
+    if (!safeHash(row.child_policy_hash)
+        || (row.lb_affinity_token_hash !== null && !safeHash(row.lb_affinity_token_hash))) {
+        return decodeFailure('historical_session_pin_hash_invalid');
+    }
+    if (row.lb_affinity_token_hash !== null || row.parent_session_id !== null) {
+        return decodeFailure('historical_session_pin_semantics_unrepresentable');
     }
+    if (!validDecodeContext(context))
+        return decodeFailure('historical_session_pin_context_invalid');
+    if (provider !== context.current_provider_id)
+        return decodeFailure('historical_session_pin_provider_mismatch');
+    if (row.catalog_version !== context.current_catalog_generation) {
+        return decodeFailure('historical_session_pin_catalog_stale');
+    }
+    if (row.child_policy_hash !== context.expected_child_policy_hash) {
+        return decodeFailure('historical_session_pin_child_policy_mismatch');
+    }
+    const pin = {
+        thread_id: sessionId,
+        provider_id: provider,
+        public_model: publicModel,
+        upstream_model: context.current_upstream_model,
+        catalog_generation: context.current_catalog_generation,
+        route_policy_generation: context.current_route_policy_generation,
+        created_at: context.created_at
+    };
+    return validateCurrentProviderSessionPin(pin)
+        ? { ok: true, pin, blocker: null }
+        : decodeFailure('current_session_pin_invalid');
 }
-export function assertSafeAuditProjection(value) {
+export function validateCurrentProviderSessionPin(value) {
+    const row = record(value);
+    if (!row || !hasExactKeys(row, CURRENT_SESSION_PIN_KEYS))
+        return false;
+    const publicModel = canonicalizeBridgeModelId(row.public_model);
+    const upstreamModel = normalizeBridgeUpstreamModelId(row.upstream_model);
+    return Boolean(safeIdentifier(row.thread_id)
+        && PROVIDERS.has(String(row.provider_id))
+        && publicModel
+        && publicModel === row.public_model
+        && upstreamModel
+        && upstreamModel === row.upstream_model
+        && safeGeneration(row.catalog_generation)
+        && safeGeneration(row.route_policy_generation)
+        && validIso(row.created_at));
+}
+export function createSafeAuditProjection(value) {
     const ancestors = new WeakSet();
-    const visit = (current, depth) => {
-        if (depth > MAX_AUDIT_PROJECTION_DEPTH)
-            fail('audit_projection_depth_exceeded');
-        if (Array.isArray(current)) {
-            if (ancestors.has(current))
-                fail('audit_projection_cycle');
-            ancestors.add(current);
-            try {
-                for (const item of current)
-                    visit(item, depth + 1);
-            }
-            finally {
-                ancestors.delete(current);
+    return projectAuditValue(value, 0, ancestors);
+}
+export function assertSafeAuditProjection(value) {
+    createSafeAuditProjection(value);
+}
+export function stableArchitectureHash(value) {
+    const projection = createSafeAuditProjection(value);
+    return createHash('sha256').update(canonicalJson(projection)).digest('hex');
+}
+export function jsonRoundTrip(value) {
+    return JSON.parse(JSON.stringify(createSafeAuditProjection(value)));
+}
+function projectAuditValue(value, depth, ancestors) {
+    if (depth > MAX_AUDIT_PROJECTION_DEPTH)
+        fail('audit_projection_depth_exceeded');
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            fail('audit_projection_number_invalid');
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value !== 'object')
+        fail('audit_projection_value_unsupported');
+    if (ancestors.has(value))
+        fail('audit_projection_cycle');
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const ownKeys = Reflect.ownKeys(value);
+            if (ownKeys.some((key) => typeof key === 'symbol'
+                || (key !== 'length' && !/^(0|[1-9][0-9]*)$/.test(key)))) {
+                fail('audit_projection_array_property_unsupported');
             }
-            return;
-        }
-        if (!current || typeof current !== 'object')
-            return;
-        if (ancestors.has(current))
-            fail('audit_projection_cycle');
-        ancestors.add(current);
-        try {
-            for (const [key, item] of Object.entries(current)) {
-                if (PROHIBITED_AUDIT_FIELDS.has(key.toLowerCase()))
-                    fail('audit_projection_prohibited_field');
-                visit(item, depth + 1);
+            const projected = [];
+            for (let index = 0; index < value.length; index += 1) {
+                if (!Object.prototype.hasOwnProperty.call(value, index))
+                    fail('audit_projection_sparse_array');
+                projected.push(projectAuditValue(value[index], depth + 1, ancestors));
             }
+            return projected;
         }
-        finally {
-            ancestors.delete(current);
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            fail('audit_projection_object_unsupported');
+        if (Object.getOwnPropertySymbols(value).length > 0)
+            fail('audit_projection_symbol_key');
+        const projected = {};
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        for (const key of Object.keys(descriptors).sort()) {
+            const descriptor = descriptors[key];
+            if (!descriptor.enumerable)
+                continue;
+            if (!('value' in descriptor))
+                fail('audit_projection_accessor_unsupported');
+            if (isSensitiveAuditField(key))
+                fail('audit_projection_prohibited_field');
+            projected[key] = projectAuditValue(descriptor.value, depth + 1, ancestors);
         }
-    };
-    visit(value, 0);
+        return projected;
+    }
+    finally {
+        ancestors.delete(value);
+    }
 }
-export function jsonRoundTrip(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function validateCredentialReadiness(value) {
-    const row = objectRecord(value, 'credential_readiness_invalid');
-    exactKeys(row, ['status', 'reason_code'], 'credential_readiness_unknown_field');
-    const statuses = new Set(['ready', 'not_found', 'locked', 'access_denied', 'signing_mismatch', 'damaged', 'unavailable']);
-    if (!statuses.has(row.status))
-        fail('credential_readiness_status_invalid');
-    if (row.reason_code !== null && !safeReason(row.reason_code))
-        fail('credential_readiness_reason_invalid');
-    if ((row.status === 'ready') !== (row.reason_code === null))
-        fail('credential_readiness_reason_mismatch');
-}
-function validateCatalogSnapshot(value) {
-    const row = objectRecord(value, 'catalog_snapshot_invalid');
-    exactKeys(row, ['schema', 'version', 'models', 'checked_at'], 'catalog_snapshot_unknown_field');
-    if (row.schema !== 'sks.catalog-snapshot.v1' || !safeVersion(row.version))
-        fail('catalog_snapshot_invalid');
-    const models = stringArray(row.models, 'catalog_models_invalid');
-    if (models.some((model) => !model.trim()) || models.length !== new Set(models).size)
-        fail('catalog_models_invalid');
-    if (typeof row.checked_at !== 'string' || !Number.isFinite(Date.parse(row.checked_at)))
-        fail('catalog_checked_at_invalid');
-}
-function validateFeatureCompatibility(value) {
-    const row = objectRecord(value, 'feature_compatibility_invalid');
-    exactKeys(row, ['schema', 'feature', 'route', 'oauth_required', 'reason_code'], 'feature_compatibility_unknown_field');
-    if (row.schema !== 'sks.feature-compatibility.v1')
-        fail('feature_compatibility_schema_invalid');
-    if (!safeVersion(row.feature))
-        fail('feature_compatibility_feature_invalid');
-    if (!new Set(['direct-proxy', 'oauth-auxiliary', 'unavailable']).has(String(row.route)))
-        fail('feature_compatibility_route_invalid');
-    if (typeof row.oauth_required !== 'boolean')
-        fail('feature_compatibility_oauth_invalid');
-    if (row.reason_code !== null && !safeReason(row.reason_code))
-        fail('feature_compatibility_reason_invalid');
-}
-function objectRecord(value, code) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        fail(code);
-    return value;
-}
-function exactKeys(row, allowed, code) {
-    const known = new Set(allowed);
-    if (Object.keys(row).some((key) => !known.has(key)))
-        fail(code);
-    if (allowed.some((key) => !(key in row)))
-        fail(code);
-}
-function stringArray(value, code) {
-    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string'))
-        fail(code);
-    return value;
-}
-function safeReason(value) {
-    return typeof value === 'string' && /^[a-z][a-z0-9_]{2,99}$/.test(value);
-}
-function safeVersion(value) {
-    return typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(value);
+function isSensitiveAuditField(key) {
+    const normalized = key.trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    if (PROHIBITED_AUDIT_FIELDS.has(normalized))
+        return true;
+    return [...PROHIBITED_AUDIT_FIELDS].some((field) => normalized.endsWith(`_${field}`));
+}
+function validDecodeContext(context) {
+    return PROVIDERS.has(String(context.current_provider_id))
+        && normalizeBridgeUpstreamModelId(context.current_upstream_model) === context.current_upstream_model
+        && safeGeneration(context.current_catalog_generation)
+        && safeGeneration(context.current_route_policy_generation)
+        && safeHash(context.expected_child_policy_hash)
+        && validIso(context.created_at);
+}
+function historicalProvider(value) {
+    return value === 'codex-lb' || value === 'openrouter' ? value : null;
+}
+function credentialClassForProvider(provider) {
+    return provider === 'codex-lb' ? 'codex-lb-api-key' : 'openrouter-api-key';
+}
+function canonicalModelArray(value) {
+    if (!Array.isArray(value) || value.length > 10_000)
+        return null;
+    const models = [];
+    for (const entry of value) {
+        const model = canonicalizeBridgeModelId(entry);
+        if (!model || model !== entry || models.includes(model))
+            return null;
+        models.push(model);
+    }
+    return models;
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function hasExactKeys(row, expected) {
+    const keys = Object.keys(row);
+    const allowed = new Set(expected);
+    return keys.length === expected.length
+        && keys.every((key) => allowed.has(key))
+        && expected.every((key) => Object.prototype.hasOwnProperty.call(row, key));
+}
+function safeIdentifier(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    return text && text.length <= 240 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(text) ? text : null;
+}
+function safeGeneration(value) {
+    return typeof value === 'string'
+        && value.length > 0
+        && value.length <= 240
+        && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value);
 }
 function safeHash(value) {
     return typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
 }
+function validIso(value) {
+    return typeof value === 'string'
+        && Number.isFinite(Date.parse(value))
+        && new Date(value).toISOString() === value;
+}
+function decodeFailure(blocker) {
+    return { ok: false, pin: null, blocker };
+}
 function fail(code) {
     throw new ArchitectureContractError(code);
 }