sneakoscope 8.1.2 → 8.2.0

package/dist/core/codex-lb/trusted-deep-evidence.js

@@ -1,314 +1,129 @@
 import { sha256 } from '../fsx.js';
 import { uniqueValues as unique } from '../text/strings.js';
-export const CODEX_LB_TRUSTED_DEEP_EVIDENCE_SCHEMA = 'sks.codex-lb-trusted-deep-evidence.v1';
-export const CODEX_LB_DEEP_EVIDENCE_TRUST_ANCHOR_SCHEMA = 'sks.codex-lb-deep-evidence-trust-anchor.v1';
-export const CODEX_LB_DEEP_EVIDENCE_TRUST_ANCHOR_SET_SCHEMA = 'sks.codex-lb-deep-evidence-trust-anchor-set.v1';
-export const CODEX_LB_DEEP_EVIDENCE_VALIDATION_SCHEMA = 'sks.codex-lb-deep-evidence-validation.v1';
-export const DEFAULT_CODEX_LB_DEEP_EVIDENCE_MAX_AGE_MS = 15 * 60 * 1000;
+export const CAPABILITY_TRUSTED_DEEP_EVIDENCE_SCHEMA = 'sks.capability-trusted-deep-evidence.v2';
+export const CAPABILITY_DEEP_EVIDENCE_TRUST_ANCHOR_SCHEMA = 'sks.capability-deep-evidence-trust-anchor.v2';
+export const CAPABILITY_DEEP_EVIDENCE_VALIDATION_SCHEMA = 'sks.capability-deep-evidence-validation.v2';
+export const DEFAULT_CAPABILITY_DEEP_EVIDENCE_MAX_AGE_MS = 15 * 60 * 1000;
 const DEFAULT_FUTURE_SKEW_MS = 60 * 1000;
 const SHA256_PATTERN = /^[a-f0-9]{64}$/i;
 const ID_PATTERN = /^[a-z0-9][a-z0-9._:/-]{2,127}$/i;
-const PAYLOAD_KEYS = new Set([
-    'fixture',
-    'provider_identity_verified',
-    'picker_control_visible',
-    'picker_selected_model',
-    'configured_service_tier',
-    'request_service_tier',
-    'response_actual_service_tier',
-    'bridge_websocket_round_trip',
-    'image_route',
-    'image_request_tools_present',
-    'image_events',
-    'image_artifact_materialized',
-    'computer_events',
-    'computer_executor_completed',
-    'computer_output_submitted',
-    'computer_follow_up_completed',
-    'computer_session_affinity_preserved',
-    'browser_use_verified',
-    'voice_create_verified',
-    'voice_location_received',
-    'voice_location_rewritten',
-    'voice_websocket_upgraded',
-    'voice_server_event_seen',
-    'voice_clean_close',
-    'voice_owner_binding_verified',
-    'plugins_verified',
-    'auxiliary_routes_observed',
-    'auxiliary_events',
-    'auxiliary_output_events',
-    'auxiliary_request_body_hash_preserved',
-    'auxiliary_owner_affinity_verified',
-    'desktop_adoption_verified',
-    'desktop_adoption_source',
-    'oauth_bytes_unchanged_before_restart',
-    'oauth_semantic_identity_verified_after_restart',
-    'built_in_openai_provider_retained',
-    'fast_selector_visible',
-    'fast_effective_verified',
-    'text_response_verified',
-    'code_mcp_search_verified',
-    'files_transcribe_verified',
-    'memory_thread_goal_routes_verified',
-    'existing_thread_resumed',
-    'new_thread_created',
-    'disable_routing_verified',
-    'rollback_byte_exact_verified',
-    'app_restart_recovery_verified',
-    'mac_reboot_recovery_verified',
-    'remote_other_mac_runtime_verified',
-    'auth_mode_independence_verified',
-    'source_surface',
-    'desktop_build',
-    'codex_core_version',
-    'protocol_fixture_schema_hash',
-    'app_origin_observed'
-]);
-const BOOLEAN_PAYLOAD_KEYS = new Set([
-    'fixture',
-    'provider_identity_verified',
-    'picker_control_visible',
-    'bridge_websocket_round_trip',
-    'image_request_tools_present',
-    'image_artifact_materialized',
-    'computer_executor_completed',
-    'computer_output_submitted',
-    'computer_follow_up_completed',
-    'computer_session_affinity_preserved',
-    'browser_use_verified',
-    'voice_create_verified',
-    'voice_location_received',
-    'voice_location_rewritten',
-    'voice_websocket_upgraded',
-    'voice_server_event_seen',
-    'voice_clean_close',
-    'voice_owner_binding_verified',
-    'plugins_verified',
-    'auxiliary_request_body_hash_preserved',
-    'auxiliary_owner_affinity_verified',
-    'desktop_adoption_verified',
-    'oauth_bytes_unchanged_before_restart',
-    'oauth_semantic_identity_verified_after_restart',
-    'built_in_openai_provider_retained',
-    'fast_selector_visible',
-    'fast_effective_verified',
-    'text_response_verified',
-    'code_mcp_search_verified',
-    'files_transcribe_verified',
-    'memory_thread_goal_routes_verified',
-    'existing_thread_resumed',
-    'new_thread_created',
-    'disable_routing_verified',
-    'rollback_byte_exact_verified',
-    'app_restart_recovery_verified',
-    'mac_reboot_recovery_verified',
-    'remote_other_mac_runtime_verified',
-    'auth_mode_independence_verified'
-]);
-const NULLABLE_STRING_PAYLOAD_KEYS = new Set([
-    'picker_selected_model',
-    'configured_service_tier',
-    'request_service_tier',
-    'response_actual_service_tier',
-    'desktop_adoption_source',
-    'source_surface',
-    'desktop_build',
-    'codex_core_version',
-    'protocol_fixture_schema_hash',
-    'app_origin_observed'
-]);
-const ARRAY_PAYLOAD_KEYS = new Set([
-    'image_events',
-    'computer_events',
-    'auxiliary_routes_observed',
-    'auxiliary_events',
-    'auxiliary_output_events'
-]);
-export function validateCodexLbDesktopDeepEvidence(value, options) {
+export function validateCapabilityDeepEvidenceV2(value, options) {
     if (value == null)
-        return validation('available_unverified', ['codex_lb_deep_evidence_missing']);
+        return capabilityValidation(options, 'not_attempted', [], []);
     const blockers = [];
     if (!isRecord(value) || !hasExactKeys(value, ['schema', 'producer', 'created_at', 'target', 'payload', 'integrity'])) {
-        return validation('blocked', ['codex_lb_deep_evidence_schema_invalid']);
+        return capabilityValidation(options, 'blocked', ['capability_deep_evidence_schema_invalid'], []);
     }
-    if (value.schema !== CODEX_LB_TRUSTED_DEEP_EVIDENCE_SCHEMA)
-        blockers.push('codex_lb_deep_evidence_schema_invalid');
+    if (value.schema !== CAPABILITY_TRUSTED_DEEP_EVIDENCE_SCHEMA)
+        blockers.push('capability_deep_evidence_schema_invalid');
     const producer = parseProducer(value.producer, blockers, 'evidence');
-    const target = parseTarget(value.target, blockers, 'evidence');
+    const target = parseCapabilityTarget(value.target, blockers);
     const integrity = parseIntegrity(value.integrity, blockers);
-    const payload = parsePayload(value.payload, blockers);
+    const payload = isRecord(value.payload) ? value.payload : null;
+    if (!payload)
+        blockers.push('capability_deep_evidence_payload_invalid');
     const createdAt = typeof value.created_at === 'string' ? value.created_at : '';
     const createdAtMs = Date.parse(createdAt);
     if (!createdAt || !Number.isFinite(createdAtMs))
-        blockers.push('codex_lb_deep_evidence_created_at_invalid');
+        blockers.push('capability_deep_evidence_created_at_invalid');
     const expectedEndpoint = normalizeEndpoint(options.expectedEndpoint);
     const evidenceEndpoint = target ? normalizeEndpoint(target.endpoint) : null;
     if (!expectedEndpoint)
-        blockers.push('codex_lb_deep_evidence_expected_endpoint_invalid');
-    if (target && target.mode !== options.expectedMode)
-        blockers.push('codex_lb_deep_evidence_target_mode_mismatch');
-    if (target && (!evidenceEndpoint || evidenceEndpoint !== expectedEndpoint))
-        blockers.push('codex_lb_deep_evidence_target_endpoint_mismatch');
+        blockers.push('capability_deep_evidence_expected_endpoint_invalid');
+    if (target?.provider_id !== options.expectedProviderId)
+        blockers.push('capability_deep_evidence_provider_mismatch');
+    if (target?.scope !== options.expectedScope)
+        blockers.push('capability_deep_evidence_scope_mismatch');
+    if (target?.capability !== options.expectedCapability)
+        blockers.push('capability_deep_evidence_capability_mismatch');
+    if (target?.report_id !== options.expectedReportId)
+        blockers.push('capability_deep_evidence_report_mismatch');
+    if (target?.catalog_generation !== options.expectedCatalogGeneration)
+        blockers.push('capability_deep_evidence_generation_mismatch');
+    if (target && evidenceEndpoint !== expectedEndpoint)
+        blockers.push('capability_deep_evidence_endpoint_mismatch');
     const nowMs = normalizeNow(options.now);
-    const maxAgeMs = positiveFinite(options.maxAgeMs, DEFAULT_CODEX_LB_DEEP_EVIDENCE_MAX_AGE_MS);
+    const maxAgeMs = positiveFinite(options.maxAgeMs, DEFAULT_CAPABILITY_DEEP_EVIDENCE_MAX_AGE_MS);
     const futureSkewMs = positiveFinite(options.maxFutureSkewMs, DEFAULT_FUTURE_SKEW_MS);
-    if (Number.isFinite(createdAtMs) && createdAtMs < nowMs - maxAgeMs)
-        blockers.push('codex_lb_deep_evidence_stale');
-    if (Number.isFinite(createdAtMs) && createdAtMs > nowMs + futureSkewMs)
-        blockers.push('codex_lb_deep_evidence_created_at_in_future');
+    const stale = Number.isFinite(createdAtMs) && createdAtMs < nowMs - maxAgeMs;
+    if (Number.isFinite(createdAtMs) && createdAtMs > nowMs + futureSkewMs) {
+        blockers.push('capability_deep_evidence_created_at_in_future');
+    }
     let contentSha256 = null;
     if (producer && target && payload && createdAt && integrity) {
-        contentSha256 = codexLbDeepEvidenceContentSha256({
-            schema: CODEX_LB_TRUSTED_DEEP_EVIDENCE_SCHEMA,
+        contentSha256 = capabilityDeepEvidenceContentSha256V2({
+            schema: CAPABILITY_TRUSTED_DEEP_EVIDENCE_SCHEMA,
             producer,
             created_at: createdAt,
             target,
             payload
         });
         if (integrity.content_sha256 !== contentSha256)
-            blockers.push('codex_lb_deep_evidence_content_sha256_mismatch');
+            blockers.push('capability_deep_evidence_content_sha256_mismatch');
     }
     const anchor = integrity
         ? (options.trustAnchors || []).find((candidate) => candidate.anchor_id === integrity.trust_anchor_id)
         : null;
-    if (!anchor) {
-        blockers.push('codex_lb_deep_evidence_trust_anchor_missing');
-    }
-    else {
-        validateAnchor(anchor, producer, target, contentSha256, blockers);
-    }
+    if (!anchor)
+        blockers.push('capability_deep_evidence_trust_anchor_missing');
+    else
+        validateCapabilityAnchor(anchor, producer, target, contentSha256, blockers);
+    const common = {
+        producer_id: producer?.id || null,
+        created_at: createdAt || null,
+        content_sha256: contentSha256,
+        trust_anchor_id: integrity?.trust_anchor_id || null
+    };
     if (payload?.fixture === true) {
         return {
-            ...validation('available_unverified', unique([...blockers, 'codex_lb_deep_evidence_fixture_unverified'])),
-            producer_id: producer?.id || null,
-            created_at: createdAt || null,
-            content_sha256: contentSha256,
-            trust_anchor_id: integrity?.trust_anchor_id || null
+            ...capabilityValidation(options, 'not_attempted', [], ['capability_deep_evidence_fixture_unverified']),
+            ...common
         };
     }
-    if (blockers.length || !payload) {
+    if (blockers.length > 0 || !payload) {
         return {
-            ...validation('blocked', unique(blockers.length ? blockers : ['codex_lb_deep_evidence_invalid'])),
-            producer_id: producer?.id || null,
-            created_at: createdAt || null,
-            content_sha256: contentSha256,
-            trust_anchor_id: integrity?.trust_anchor_id || null
+            ...capabilityValidation(options, 'blocked', unique(blockers), []),
+            ...common
+        };
+    }
+    if (stale) {
+        return {
+            ...capabilityValidation(options, 'stale', ['capability_deep_evidence_stale'], []),
+            ...common
         };
     }
     return {
-        schema: CODEX_LB_DEEP_EVIDENCE_VALIDATION_SCHEMA,
-        state: 'verified',
+        ...capabilityValidation(options, 'verified', [], []),
+        ...common,
         trusted: true,
-        evidence: payload,
-        producer_id: producer.id,
-        created_at: createdAt,
-        content_sha256: contentSha256,
-        trust_anchor_id: integrity.trust_anchor_id,
-        blockers: [],
-        warnings: []
+        evidence: redactCapabilityEvidence(payload)
     };
 }
-export function codexLbDeepEvidenceContentSha256(content) {
+export function capabilityDeepEvidenceContentSha256V2(content) {
     return sha256(canonicalJson(content));
 }
-export function parseCodexLbDeepEvidenceTrustAnchorSet(value) {
-    if (!isRecord(value) || !hasExactKeys(value, ['schema', 'anchors'])) {
-        return {
-            schema: CODEX_LB_DEEP_EVIDENCE_TRUST_ANCHOR_SET_SCHEMA,
-            ok: false,
-            anchors: [],
-            blockers: ['codex_lb_deep_evidence_trust_anchor_set_invalid']
-        };
-    }
-    if (value.schema !== CODEX_LB_DEEP_EVIDENCE_TRUST_ANCHOR_SET_SCHEMA
-        || !Array.isArray(value.anchors)
-        || value.anchors.length === 0) {
-        return {
-            schema: CODEX_LB_DEEP_EVIDENCE_TRUST_ANCHOR_SET_SCHEMA,
-            ok: false,
-            anchors: [],
-            blockers: ['codex_lb_deep_evidence_trust_anchor_set_invalid']
-        };
-    }
-    const blockers = [];
-    const anchors = [];
-    const seen = new Set();
-    for (const [index, candidate] of value.anchors.entries()) {
-        const candidateBlockers = [];
-        validateAnchor(candidate, null, null, null, candidateBlockers);
-        const anchorId = isRecord(candidate) && typeof candidate.anchor_id === 'string'
-            ? candidate.anchor_id
-            : '';
-        if (anchorId && seen.has(anchorId))
-            candidateBlockers.push('codex_lb_deep_evidence_trust_anchor_duplicate');
-        if (anchorId)
-            seen.add(anchorId);
-        if (candidateBlockers.length) {
-            blockers.push(...candidateBlockers.map((blocker) => `${blocker}:${index}`));
-            continue;
-        }
-        anchors.push(candidate);
-    }
-    return {
-        schema: CODEX_LB_DEEP_EVIDENCE_TRUST_ANCHOR_SET_SCHEMA,
-        ok: blockers.length === 0 && anchors.length === value.anchors.length,
-        anchors: blockers.length === 0 ? anchors : [],
-        blockers: unique(blockers)
-    };
+export function redactCapabilityEvidence(value) {
+    return redactRecord(value);
 }
-function validateAnchor(anchor, producer, target, contentSha256, blockers) {
-    if (!isRecord(anchor) || !hasExactKeys(anchor, ['schema', 'anchor_id', 'producer', 'target', 'content_sha256'])) {
-        blockers.push('codex_lb_deep_evidence_trust_anchor_invalid');
-        return;
-    }
-    if (anchor.schema !== CODEX_LB_DEEP_EVIDENCE_TRUST_ANCHOR_SCHEMA)
-        blockers.push('codex_lb_deep_evidence_trust_anchor_invalid');
-    if (typeof anchor.anchor_id !== 'string' || !ID_PATTERN.test(anchor.anchor_id))
-        blockers.push('codex_lb_deep_evidence_trust_anchor_invalid');
-    const anchorProducer = parseProducer(anchor.producer, blockers, 'anchor');
-    const anchorTarget = parseTarget(anchor.target, blockers, 'anchor');
-    if (!SHA256_PATTERN.test(anchor.content_sha256))
-        blockers.push('codex_lb_deep_evidence_trust_anchor_hash_invalid');
-    if (contentSha256 && anchor.content_sha256 !== contentSha256)
-        blockers.push('codex_lb_deep_evidence_trust_anchor_hash_mismatch');
-    if (producer && anchorProducer && canonicalJson(producer) !== canonicalJson(anchorProducer))
-        blockers.push('codex_lb_deep_evidence_trust_anchor_producer_mismatch');
-    if (target && anchorTarget && (target.mode !== anchorTarget.mode
-        || normalizeEndpoint(target.endpoint) !== normalizeEndpoint(anchorTarget.endpoint)))
-        blockers.push('codex_lb_deep_evidence_trust_anchor_target_mismatch');
+export function redactCapabilityText(value) {
+    return redactString(value);
 }
 function parseProducer(value, blockers, scope) {
     if (!isRecord(value) || !hasExactKeys(value, ['id', 'version', 'run_id'])) {
-        blockers.push(`codex_lb_deep_evidence_${scope}_producer_invalid`);
+        blockers.push(`capability_deep_evidence_${scope}_producer_invalid`);
         return null;
     }
     for (const key of ['id', 'version', 'run_id']) {
         if (typeof value[key] !== 'string' || !ID_PATTERN.test(value[key])) {
-            blockers.push(`codex_lb_deep_evidence_${scope}_producer_invalid`);
+            blockers.push(`capability_deep_evidence_${scope}_producer_invalid`);
             return null;
         }
     }
     return value;
 }
-function parseTarget(value, blockers, scope) {
-    if (!isRecord(value) || !hasExactKeys(value, ['mode', 'endpoint'])) {
-        blockers.push(`codex_lb_deep_evidence_${scope}_target_invalid`);
-        return null;
-    }
-    if (!['desktop-native-bridge', 'desktop-dual-auth-compat', 'cli-provider', 'disabled'].includes(String(value.mode))) {
-        blockers.push(`codex_lb_deep_evidence_${scope}_target_invalid`);
-        return null;
-    }
-    if (typeof value.endpoint !== 'string' || !normalizeEndpoint(value.endpoint)) {
-        blockers.push(`codex_lb_deep_evidence_${scope}_target_invalid`);
-        return null;
-    }
-    return value;
-}
 function parseIntegrity(value, blockers) {
     if (!isRecord(value) || !hasExactKeys(value, ['algorithm', 'content_sha256', 'trust_anchor_id'])) {
-        blockers.push('codex_lb_deep_evidence_integrity_invalid');
+        blockers.push('capability_deep_evidence_integrity_invalid');
         return null;
     }
     if (value.algorithm !== 'sha256'
@@ -316,34 +131,85 @@ function parseIntegrity(value, blockers) {
         || !SHA256_PATTERN.test(value.content_sha256)
         || typeof value.trust_anchor_id !== 'string'
         || !ID_PATTERN.test(value.trust_anchor_id)) {
-        blockers.push('codex_lb_deep_evidence_integrity_invalid');
+        blockers.push('capability_deep_evidence_integrity_invalid');
         return null;
     }
     return value;
 }
-function parsePayload(value, blockers) {
-    if (!isRecord(value)) {
-        blockers.push('codex_lb_deep_evidence_payload_invalid');
+function parseCapabilityTarget(value, blockers) {
+    if (!isRecord(value) || !hasExactKeys(value, [
+        'provider_id',
+        'scope',
+        'capability',
+        'report_id',
+        'catalog_generation',
+        'endpoint'
+    ])) {
+        blockers.push('capability_deep_evidence_target_invalid');
         return null;
     }
-    const unknown = Object.keys(value).filter((key) => !PAYLOAD_KEYS.has(key));
-    if (unknown.length)
-        blockers.push('codex_lb_deep_evidence_payload_unknown_fields');
-    for (const [key, entry] of Object.entries(value)) {
-        if (BOOLEAN_PAYLOAD_KEYS.has(key) && typeof entry !== 'boolean')
-            blockers.push(`codex_lb_deep_evidence_payload_type_invalid:${key}`);
-        if (NULLABLE_STRING_PAYLOAD_KEYS.has(key) && entry !== null && typeof entry !== 'string')
-            blockers.push(`codex_lb_deep_evidence_payload_type_invalid:${key}`);
-        if (ARRAY_PAYLOAD_KEYS.has(key) && !Array.isArray(entry))
-            blockers.push(`codex_lb_deep_evidence_payload_type_invalid:${key}`);
-        if (key === 'image_route' && entry !== null && !['responses_tool', 'images_api'].includes(String(entry))) {
-            blockers.push('codex_lb_deep_evidence_payload_type_invalid:image_route');
-        }
-        if (key === 'auxiliary_routes_observed' && Array.isArray(entry) && entry.some((item) => typeof item !== 'string')) {
-            blockers.push('codex_lb_deep_evidence_payload_type_invalid:auxiliary_routes_observed');
+    const providerId = value.provider_id;
+    if (providerId !== 'codex-lb' && providerId !== 'openrouter') {
+        blockers.push('capability_deep_evidence_target_invalid');
+        return null;
+    }
+    if (value.scope !== `provider:${providerId}`) {
+        blockers.push('capability_deep_evidence_target_invalid');
+        return null;
+    }
+    for (const key of ['capability', 'report_id', 'catalog_generation']) {
+        if (typeof value[key] !== 'string' || !ID_PATTERN.test(value[key])) {
+            blockers.push('capability_deep_evidence_target_invalid');
+            return null;
         }
     }
-    return blockers.some((blocker) => blocker.startsWith('codex_lb_deep_evidence_payload_')) ? null : value;
+    if (typeof value.endpoint !== 'string' || !normalizeEndpoint(value.endpoint)) {
+        blockers.push('capability_deep_evidence_target_invalid');
+        return null;
+    }
+    return value;
+}
+function validateCapabilityAnchor(anchor, producer, target, contentSha256, blockers) {
+    if (!isRecord(anchor) || !hasExactKeys(anchor, ['schema', 'anchor_id', 'producer', 'target', 'content_sha256'])) {
+        blockers.push('capability_deep_evidence_trust_anchor_invalid');
+        return;
+    }
+    if (anchor.schema !== CAPABILITY_DEEP_EVIDENCE_TRUST_ANCHOR_SCHEMA)
+        blockers.push('capability_deep_evidence_trust_anchor_invalid');
+    if (!ID_PATTERN.test(anchor.anchor_id))
+        blockers.push('capability_deep_evidence_trust_anchor_invalid');
+    const anchorProducer = parseProducer(anchor.producer, blockers, 'anchor');
+    const anchorTarget = parseCapabilityTarget(anchor.target, blockers);
+    if (!SHA256_PATTERN.test(anchor.content_sha256))
+        blockers.push('capability_deep_evidence_trust_anchor_hash_invalid');
+    if (contentSha256 && anchor.content_sha256 !== contentSha256)
+        blockers.push('capability_deep_evidence_trust_anchor_hash_mismatch');
+    if (producer && anchorProducer && canonicalJson(producer) !== canonicalJson(anchorProducer)) {
+        blockers.push('capability_deep_evidence_trust_anchor_producer_mismatch');
+    }
+    if (target && anchorTarget && canonicalJson(target) !== canonicalJson(anchorTarget)) {
+        blockers.push('capability_deep_evidence_trust_anchor_target_mismatch');
+    }
+}
+function capabilityValidation(options, state, blockers, warnings) {
+    return {
+        schema: CAPABILITY_DEEP_EVIDENCE_VALIDATION_SCHEMA,
+        state,
+        trusted: false,
+        provider_id: options.expectedProviderId,
+        scope: options.expectedScope,
+        capability: options.expectedCapability,
+        report_id: options.expectedReportId,
+        catalog_generation: options.expectedCatalogGeneration,
+        endpoint: normalizeEndpoint(options.expectedEndpoint) || options.expectedEndpoint,
+        evidence: null,
+        producer_id: null,
+        created_at: null,
+        content_sha256: null,
+        trust_anchor_id: null,
+        blockers,
+        warnings
+    };
 }
 function normalizeEndpoint(value) {
     try {
@@ -382,22 +248,28 @@ function positiveFinite(value, fallback) {
 }
 function hasExactKeys(value, expected) {
     const actual = Object.keys(value).sort();
-    return actual.length === expected.length && actual.every((key, index) => key === [...expected].sort()[index]);
+    const sortedExpected = [...expected].sort();
+    return actual.length === sortedExpected.length && actual.every((key, index) => key === sortedExpected[index]);
 }
 function isRecord(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
-function validation(state, blockers) {
-    return {
-        schema: CODEX_LB_DEEP_EVIDENCE_VALIDATION_SCHEMA,
-        state,
-        trusted: false,
-        evidence: null,
-        producer_id: null,
-        created_at: null,
-        content_sha256: null,
-        trust_anchor_id: null,
-        blockers,
-        warnings: []
-    };
+function redactRecord(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+        if (/(?:authorization|api[_-]?key|token|secret|credential)/i.test(key))
+            return [key, '[REDACTED]'];
+        if (typeof entry === 'string')
+            return [key, redactString(entry)];
+        if (Array.isArray(entry))
+            return [key, entry.map((item) => (isRecord(item) ? redactRecord(item) : typeof item === 'string' ? redactString(item) : item))];
+        if (isRecord(entry))
+            return [key, redactRecord(entry)];
+        return [key, entry];
+    }));
+}
+function redactString(value) {
+    return value
+        .replace(/\b(?:sk|or|sess|key)-[A-Za-z0-9_-]{8,}\b/g, '[REDACTED]')
+        .replace(/Bearer\s+[A-Za-z0-9._~+/-]{8,}/gi, 'Bearer [REDACTED]')
+        .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|secret|credential)\s*[=:]\s*["']?)[A-Za-z0-9._~+/-]{8,}/gi, '$1[REDACTED]');
 }

package/dist/core/commands/basic-cli.js

@@ -34,7 +34,7 @@ export async function helpCommand(args = []) {
     for (const row of commandRows().filter((entry) => entry.maturity !== 'labs')) {
         console.log(`  ${row.usage.padEnd(58)} ${row.description}`);
     }
-    console.log('\nThree core promises: Completion Proof for serious routes, Image Voxel TriWiki for visual routes, and release-gated Codex App/codex-lb/hooks/Rust evidence.');
+    console.log('\nThree core promises: Completion Proof for serious routes, Image Voxel TriWiki for visual routes, and release-gated Codex App/Desktop Bridge/hooks/Rust evidence.');
 }
 export function commandsCommand(args = []) {
     const commands = commandRows();

package/dist/core/commands/check-command.js

@@ -4,7 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { flag } from '../../cli/args.js';
 import { printJson } from '../../cli/output.js';
 import { projectRoot } from '../fsx.js';
-import { evaluateGateProcessOutput } from './gate-result-contract.js';
+import { GATE_RESULT_CONTRACT, evaluateGateProcessOutput } from './gate-result-contract.js';
 const CHECK_SCHEMA = 'sks.check.v1';
 export async function checkCommand(args = []) {
     const root = await projectRoot();
@@ -44,14 +44,7 @@ export async function checkCommand(args = []) {
                 reason = 'invalid_json_output';
             }
         }
-        if (step.output_contract === 'sks.gate-result.v1') {
-            const gateEval = evaluateGateProcessOutput({ status: result.status, stdout, requiresContract: true });
-            ok = gateEval.ok;
-            reason = gateEval.reason;
-            contract = gateEval.contract;
-            gateResult = gateEval.gate_result;
-        }
-        else if (step.name.startsWith('release:')) {
+        if (step.output_contract === GATE_RESULT_CONTRACT) {
             const gateEval = evaluateGateProcessOutput({ status: result.status, stdout });
             ok = gateEval.ok;
             reason = gateEval.reason;
@@ -101,7 +94,7 @@ function buildCheckPlan(input) {
     }
     else {
         steps.push({ name: buildScript, command: 'npm', args: ['run', buildScript, '--silent'] });
-        steps.push({ name: `release:${tier}`, command: process.execPath, args: dagArgs(tier, input.changedSince, input.sla), output_contract: 'sks.gate-result.v1' });
+        steps.push({ name: `release:${tier}`, command: process.execPath, args: dagArgs(tier, input.changedSince, input.sla), output_contract: GATE_RESULT_CONTRACT });
     }
     return {
         tier,

package/dist/core/commands/gate-result-contract.js

@@ -1,4 +1,5 @@
-export const GATE_RESULT_CONTRACT = 'sks.gate-result.v1';
+export const GATE_RESULT_CONTRACT = 'sks.gate-result.v2';
+export const GATE_RESULT_CONTRACT_MODE = 'strict';
 export function parseGateResultFromStdout(stdout) {
     const lines = String(stdout || '').trim().split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     const last = lines.at(-1);
@@ -6,7 +7,10 @@ export function parseGateResultFromStdout(stdout) {
         return null;
     try {
         const parsed = JSON.parse(last);
-        if (parsed?.schema === GATE_RESULT_CONTRACT && typeof parsed.ok === 'boolean' && Array.isArray(parsed.blockers)) {
+        if (parsed?.schema === GATE_RESULT_CONTRACT
+            && parsed.contract_mode === GATE_RESULT_CONTRACT_MODE
+            && typeof parsed.ok === 'boolean'
+            && Array.isArray(parsed.blockers)) {
             return parsed;
         }
         return null;
@@ -15,22 +19,14 @@ export function parseGateResultFromStdout(stdout) {
         return null;
     }
 }
-export function evaluateGateProcessOutput({ status, stdout, requiresContract = false }) {
+export function evaluateGateProcessOutput({ status, stdout }) {
     const gateResult = parseGateResultFromStdout(stdout);
     if (!gateResult) {
-        if (requiresContract) {
-            return {
-                ok: false,
-                contract: GATE_RESULT_CONTRACT,
-                gate_result: null,
-                reason: 'gate_output_contract_violation'
-            };
-        }
         return {
-            ok: status === 0,
-            contract: 'legacy_exit_code_only',
+            ok: false,
+            contract: GATE_RESULT_CONTRACT,
             gate_result: null,
-            ...(status === 0 ? { reason: 'legacy_exit_code_only' } : {})
+            reason: 'gate_output_contract_violation'
         };
     }
     return {

package/dist/core/commands/intent-normalization/normalizer.js

@@ -24,7 +24,7 @@ export function normalizeIntentCommand(input) {
         canonicalCommand,
         targetHashes: input.targetHashes,
         policyVersion: input.policyVersion,
-        modeSnapshot: input.modeSnapshot,
+        runtimeSnapshot: input.runtimeSnapshot,
         evidenceState: input.evidenceState,
         ...(input.observedChangedPaths === undefined ? {} : { observedChangedPaths: input.observedChangedPaths }),
         ...(input.retryBudget === undefined ? {} : { retryBudget: input.retryBudget }),