sneakoscope 8.1.2 → 8.2.0

package/dist/core/codex-lb/probes/auxiliary-surfaces-probe.js

@@ -1,60 +1,44 @@
-import { probeEvidence } from './probe-evidence.js';
-const KNOWN_EVENT_TYPES = new Set([
-    'web_search_call',
-    'file_search_call',
-    'code_interpreter_call',
-    'mcp_list_tools',
-    'mcp_approval_request',
-    'response.completed',
-    'response.failed'
-]);
-export function runAuxiliarySurfacesProbe(input) {
-    const attempted = input.attempted === true || Boolean(input.inputEvents?.length);
-    const inputBytes = stableEventBytes(input.inputEvents || []);
-    const outputBytes = stableEventBytes(input.outputEvents || []);
-    const eventsPreserved = inputBytes === outputBytes;
-    const unknownEventTypes = (input.inputEvents || [])
-        .map(eventType)
-        .filter((type) => Boolean(type && !KNOWN_EVENT_TYPES.has(type)));
-    const blockers = [
-        ...(input.blockers || []),
-        ...(attempted && !eventsPreserved ? ['auxiliary_event_payload_changed'] : []),
-        ...(attempted && input.requestBodyHashPreserved === false ? ['auxiliary_request_body_hash_changed'] : []),
-        ...(input.level === 'deep' && attempted && input.sessionAffinityPreserved !== true
-            ? ['auxiliary_session_affinity_unverified']
-            : [])
-    ];
-    return probeEvidence({
-        advertised: input.routesAdvertised === true,
-        attempted,
-        verified: input.level === 'deep'
-            && eventsPreserved
-            && input.requestBodyHashPreserved === true
-            && input.sessionAffinityPreserved === true,
-        fixture: input.fixture,
-        source: input.level === 'deep' ? 'deep_probe' : attempted ? 'transport' : 'manifest',
-        unsupported: input.routesAdvertised === false && !attempted,
-        blockers,
-        warnings: unknownEventTypes.length > 0 ? ['unknown_event_type_observed'] : [],
+import { capabilityProbeResultV3 } from './probe-evidence.js';
+export function runAuxiliarySurfacesProbeV3(input) {
+    if (input.requestedLevel !== 'deep' || input.attempted !== true || input.fixture === true) {
+        return capabilityProbeResultV3({
+            ...input,
+            capability: 'auxiliary_surfaces',
+            scope: `provider:${input.providerId}`,
+            stage: 'preflight',
+            state: 'not_attempted',
+            source: input.advertised ? 'manifest' : 'config',
+            warnings: input.fixture ? ['auxiliary_fixture_not_live_evidence'] : [],
+            recoveryAction: 'run_deep_verification',
+            evidence: { advertised: input.advertised === true, fixture: input.fixture === true }
+        });
+    }
+    const blocker = input.eventPayloadsPreserved !== true
+        ? 'auxiliary_event_payload_changed'
+        : input.requestBodyHashPreserved !== true
+            ? 'auxiliary_request_body_hash_changed'
+            : input.ownerAffinityPreserved !== true
+                ? 'auxiliary_session_affinity_unverified'
+                : null;
+    return capabilityProbeResultV3({
+        ...input,
+        capability: 'auxiliary_surfaces',
+        scope: `provider:${input.providerId}`,
+        stage: blocker ? 'feature_response' : 'complete',
+        state: blocker ? 'blocked' : 'verified',
+        terminal: Boolean(blocker),
+        rootCause: blocker,
+        blockers: blocker ? [blocker] : [],
+        retryable: Boolean(blocker),
+        recoveryAction: blocker ? 'run_deep_verification' : null,
+        source: 'deep_probe',
         evidence: {
-            event_payloads_preserved: eventsPreserved,
-            unknown_event_types: [...new Set(unknownEventTypes)],
-            unknown_event_count: unknownEventTypes.length,
+            event_payloads_preserved: input.eventPayloadsPreserved === true,
             request_body_hash_preserved: input.requestBodyHashPreserved === true,
-            session_affinity_preserved: input.sessionAffinityPreserved === true,
-            fixture: input.fixture === true
+            owner_affinity_preserved: input.ownerAffinityPreserved === true
         }
-    }, input.checkedAt);
+    });
 }
 export function passthroughCodexDesktopEvent(event) {
     return event;
 }
-function stableEventBytes(events) {
-    return events.map((event) => JSON.stringify(event)).join('\n');
-}
-function eventType(event) {
-    if (!event || typeof event !== 'object' || Array.isArray(event))
-        return null;
-    const type = event.type;
-    return typeof type === 'string' && type.trim() ? type.trim() : null;
-}

package/dist/core/codex-lb/probes/bridge-probe.js

@@ -1,72 +1,133 @@
-import { probeEvidence } from './probe-evidence.js';
-export function runBridgeProbe(input) {
-    if (input.mode !== 'desktop-native-bridge') {
-        return probeEvidence({
-            skipped: true,
-            source: 'config',
-            evidence: {
-                required: false,
-                mode: input.mode,
-                reason: 'local_bridge_not_selected'
-            }
-        }, input.checkedAt);
-    }
-    const manifestSchema = String(input.manifest?.schema_version || '');
-    const manifestAvailable = manifestSchema === 'codex-lb.desktop-capabilities.v1';
-    const verified = input.transportAttempted === true
-        && input.httpRoundTrip === true
-        && input.websocketRoundTrip === true;
-    const blockers = [
-        ...(input.blockers || []),
-        ...(input.level !== 'shallow' && input.transportAttempted === true && input.httpRoundTrip !== true
-            ? ['desktop_bridge_http_transport_failed']
-            : []),
-        ...(input.level !== 'shallow' && input.transportAttempted === true && input.websocketRoundTrip !== true
-            ? ['desktop_bridge_websocket_transport_failed']
-            : [])
-    ];
-    return probeEvidence({
-        configured: input.configured,
-        advertised: manifestAvailable,
-        attempted: input.transportAttempted,
-        verified,
-        fixture: input.fixture,
-        source: verified ? 'transport' : manifestAvailable ? 'manifest' : 'config',
-        blockers,
-        warnings: input.processRunning && !input.transportAttempted
-            ? ['bridge_process_running_without_transport_evidence']
-            : [],
+import { capabilityProbeResultV3 } from './probe-evidence.js';
+export function runBridgeProbeV3(input) {
+    const runtime = capabilityProbeResultV3({
+        ...input,
+        capability: 'runtime',
+        scope: 'bridge',
+        stage: input.processRunning ? 'process' : 'preflight',
+        state: input.configured && input.processRunning ? 'verified' : 'not_attempted',
+        source: 'config',
+        recoveryAction: input.processRunning ? null : 'repair_bridge_service',
         evidence: {
-            mode: input.mode,
             configured: input.configured === true,
             process_running: input.processRunning === true,
-            capability_manifest_seen: manifestAvailable,
-            http_round_trip: input.httpRoundTrip === true,
-            websocket_round_trip: input.websocketRoundTrip === true
+            transport_verified: false
         }
-    }, input.checkedAt);
+    });
+    if (input.requestedLevel === 'shallow') {
+        return [
+            runtime,
+            notAttemptedBridgeTransport(input, 'http_health'),
+            notAttemptedBridgeTransport(input, 'websocket_transport')
+        ];
+    }
+    const http = input.httpProbe
+        ? capabilityProbeResultV3({
+            ...input,
+            capability: 'http_health',
+            scope: 'bridge',
+            stage: mapHttpStage(input.httpProbe.terminal_stage),
+            state: input.httpProbe.state,
+            terminal: Boolean(input.httpProbe.root_cause),
+            rootCause: input.httpProbe.root_cause,
+            blockers: input.httpProbe.blockers,
+            warnings: input.httpProbe.warnings,
+            retryable: input.httpProbe.state === 'blocked' || input.httpProbe.state === 'failed',
+            recoveryAction: recoveryFor(input.httpProbe.root_cause),
+            source: 'transport',
+            evidence: {
+                structured_probe_schema: input.httpProbe.schema,
+                terminal_stage: input.httpProbe.terminal_stage,
+                status_code: input.httpProbe.status_code,
+                latency_ms: input.httpProbe.latency_ms
+            }
+        })
+        : notAttemptedBridgeTransport(input, 'http_health');
+    const websocket = input.websocketProbe
+        ? websocketCapabilityResult(input, input.websocketProbe)
+        : notAttemptedBridgeTransport(input, 'websocket_transport');
+    if (input.processRunning && !input.httpProbe && !input.websocketProbe) {
+        runtime.warnings.push('bridge_process_running_without_transport_evidence');
+    }
+    return [runtime, http, websocket];
 }
-export function gatewayAuthTransportEvidence(input) {
-    const transport = input.transport || 'unknown';
-    const preferredBearer = transport === 'authorization-bearer-compat'
-        || transport === 'authorization-bearer';
-    const customHeader = transport === 'x-codex-lb-api-key';
-    return probeEvidence({
-        configured: input.configured,
-        attempted: input.observed,
-        verified: input.observed === true && (preferredBearer || customHeader),
-        fixture: input.fixture,
-        source: input.observed ? 'transport' : 'config',
-        blockers: [...(input.blockers || [])],
-        warnings: customHeader ? ['custom_x_codex_lb_api_key_transport_active'] : [],
+function websocketCapabilityResult(input, probe) {
+    const complete = probe.upgrade_verified
+        && probe.protocol_verified
+        && probe.frame_round_trip_verified
+        && probe.clean_close_verified;
+    const inconsistentVerified = probe.state === 'verified' && !complete;
+    return capabilityProbeResultV3({
+        ...input,
+        capability: 'websocket_transport',
+        scope: 'bridge',
+        stage: mapWebSocketStage(probe.terminal_stage),
+        state: inconsistentVerified ? 'degraded' : probe.state,
+        terminal: Boolean(probe.root_cause),
+        rootCause: probe.root_cause,
+        blockers: probe.blockers,
+        warnings: [
+            ...probe.warnings,
+            ...(inconsistentVerified ? ['websocket_structured_result_incomplete'] : [])
+        ],
+        retryable: probe.state === 'blocked' || probe.state === 'failed',
+        recoveryAction: recoveryFor(probe.root_cause),
+        source: 'transport',
         evidence: {
-            configured_gateway_auth_transport: transport,
-            preferred_custom_header: customHeader,
-            preferred_authorization_bearer: preferredBearer,
-            standard_authorization_bearer: transport === 'authorization-bearer',
-            legacy_authorization_bearer_compatibility: false,
-            silent_fallback: false,
-            observed: input.observed === true
+            structured_probe_schema: probe.schema,
+            terminal_stage: probe.terminal_stage,
+            status_code: probe.status_code,
+            negotiated_protocol: probe.negotiated_protocol,
+            upgrade_verified: probe.upgrade_verified,
+            protocol_verified: probe.protocol_verified,
+            frame_round_trip_verified: probe.frame_round_trip_verified,
+            clean_close_verified: probe.clean_close_verified,
+            latency_ms: probe.latency_ms
         }
-    }, input.checkedAt);
+    });
+}
+function notAttemptedBridgeTransport(input, capability) {
+    return capabilityProbeResultV3({
+        ...input,
+        capability,
+        scope: 'bridge',
+        stage: 'preflight',
+        state: 'not_attempted',
+        source: 'config',
+        recoveryAction: input.requestedLevel === 'shallow' ? null : 'retry_transport_probe',
+        evidence: { reason: input.requestedLevel === 'shallow' ? 'transport_not_requested' : 'transport_probe_not_run' }
+    });
+}
+function mapHttpStage(stage) {
+    if (stage === 'tcp_connect')
+        return 'tcp_connect';
+    if (stage === 'http_health')
+        return 'http_health';
+    return 'complete';
+}
+function mapWebSocketStage(stage) {
+    if (stage === 'tcp_connect')
+        return 'tcp_connect';
+    if (stage === 'websocket_upgrade')
+        return 'websocket_upgrade';
+    if (stage === 'frame_round_trip')
+        return 'frame_round_trip';
+    if (stage === 'clean_close')
+        return 'clean_close';
+    if (stage === 'complete')
+        return 'complete';
+    return 'websocket_protocol';
+}
+function recoveryFor(rootCause) {
+    if (!rootCause)
+        return null;
+    if (rootCause === 'desktop_bridge_not_running')
+        return 'repair_bridge_service';
+    if (rootCause === 'desktop_bridge_tcp_connect_failed')
+        return 'restart_bridge_and_retry';
+    if (rootCause === 'desktop_bridge_websocket_upgrade_failed')
+        return 'inspect_bridge_logs_and_retry_transport';
+    if (rootCause === 'desktop_bridge_websocket_protocol_mismatch')
+        return 'update_bridge_or_codex_protocol';
+    return 'retry_transport_probe';
 }

package/dist/core/codex-lb/probes/catalog-probe.js

@@ -1,139 +1,39 @@
-import { normalizeCodexLbToolCatalog, shouldBindLocalModelCatalog } from '../codex-lb-tool-catalog.js';
-import { uniqueValues as unique } from '../../text/strings.js';
-import { probeEvidence } from './probe-evidence.js';
-export function runCatalogProbe(input) {
-    const manifestModels = manifestFlag(input.manifest, 'routes', 'models');
-    const hasCatalogPayload = Boolean(input.catalog);
-    const normalized = hasCatalogPayload ? normalizeCodexLbToolCatalog(input.catalog) : null;
-    const rows = normalized?.catalog?.models || [];
-    const advertisedSpeedTiers = unique(rows.flatMap((row) => tierNames(row?.additional_speed_tiers)));
-    const advertisedServiceTiers = unique(rows.flatMap((row) => tierNames(row?.service_tiers)));
-    const fastAdvertised = advertisedSpeedTiers.some((tier) => tier === 'fast' || tier === 'priority')
-        || advertisedServiceTiers.includes('priority');
-    const nativeReplacementBound = input.mode === 'desktop-native-bridge' && input.localCatalogBound === true;
-    const catalogBlockers = [
-        ...(input.blockers || []),
-        ...(nativeReplacementBound ? ['native_bridge_local_catalog_replacement_forbidden'] : []),
-        ...(normalized && !normalized.ok ? normalized.blockers : []),
-        ...(input.level !== 'shallow' && !hasCatalogPayload && manifestModels !== true
-            ? ['codex_lb_model_catalog_unavailable']
-            : [])
-    ];
-    const catalog = probeEvidence({
-        configured: input.localCatalogBound === true,
-        advertised: manifestModels === true,
-        attempted: hasCatalogPayload,
-        verified: normalized?.ok === true,
-        fixture: input.fixture,
-        source: hasCatalogPayload ? 'transport' : manifestModels === true ? 'manifest' : 'config',
-        blockers: catalogBlockers,
+import { capabilityProbeResultV3, uniqueStrings } from './probe-evidence.js';
+export function runCatalogProbeV3(input) {
+    const state = input.catalog.state === 'verified'
+        ? 'verified'
+        : input.catalog.state === 'degraded'
+            ? 'degraded'
+            : input.catalog.state === 'failed'
+                ? 'blocked'
+                : input.catalog.state === 'stale'
+                    ? 'stale'
+                    : input.catalog.state === 'syncing'
+                        ? 'running'
+                        : 'not_attempted';
+    const rootCause = state === 'blocked'
+        ? uniqueStrings(input.catalog.blockers)[0] || 'catalog_sync_failed'
+        : null;
+    return capabilityProbeResultV3({
+        ...input,
+        capability: 'catalog_sync',
+        scope: `provider:${input.catalog.provider_id}`,
+        stage: state === 'verified' ? 'complete' : 'catalog_sync',
+        state,
+        terminal: state === 'blocked',
+        rootCause,
+        blockers: input.catalog.blockers,
+        warnings: input.catalog.warnings,
+        retryable: state === 'blocked' || state === 'stale',
+        recoveryAction: input.catalog.recovery_action,
+        source: 'transport',
         evidence: {
-            contract: normalized?.contract || null,
-            model_count: normalized?.model_count || 0,
-            unknown_fields_preserved: normalized?.contract === 'codex-model-catalog-pass-through.v2',
-            local_catalog_binding_allowed: shouldBindLocalModelCatalog(input.mode),
-            local_catalog_bound: input.localCatalogBound === true,
-            manifest_models_route: manifestModels
+            lifecycle_schema: input.catalog.schema,
+            source: input.catalog.source,
+            generation: input.catalog.generation,
+            digest: input.catalog.digest,
+            model_count: input.catalog.model_count,
+            expires_at: input.catalog.expires_at
         }
-    }, input.checkedAt);
-    const cliPlane = input.mode === 'cli-provider';
-    const cliPickerVerified = cliPlane
-        && input.level !== 'shallow'
-        && normalized?.ok === true
-        && rows.length > 0;
-    const pickerVerified = cliPickerVerified || (input.level === 'deep'
-        && input.pickerControlVisible === true
-        && Boolean(input.pickerSelectedModel));
-    const modelPicker = probeEvidence({
-        advertised: Boolean(normalized?.ok),
-        attempted: input.level === 'deep' || cliPickerVerified,
-        verified: pickerVerified,
-        fixture: input.fixture,
-        source: cliPlane
-            ? hasCatalogPayload ? 'transport' : 'manifest'
-            : input.level === 'deep' ? 'desktop_ui' : hasCatalogPayload ? 'transport' : 'manifest',
-        blockers: [
-            ...(input.blockers || []),
-            ...(!cliPlane && input.level === 'deep' && input.pickerControlVisible === false
-                ? ['codex_desktop_model_picker_not_visible']
-                : [])
-        ],
-        warnings: !cliPlane && input.level !== 'deep' && normalized?.ok
-            ? ['desktop_model_picker_not_deep_verified']
-            : [],
-        evidence: {
-            catalog_advertised: normalized?.ok === true,
-            desktop_picker_verified: pickerVerified,
-            picker_control_visible: input.pickerControlVisible ?? null,
-            picker_selected_model: input.pickerSelectedModel || null
-        }
-    }, input.checkedAt);
-    const configuredTier = normalizeTier(input.configuredServiceTier);
-    const requestTier = normalizeTier(input.requestServiceTier);
-    const responseTier = normalizeTier(input.responseActualServiceTier);
-    const fastConfigured = configuredTier === 'fast';
-    const fastRequested = requestTier === 'fast' || requestTier === 'priority';
-    const fastEffective = responseTier === 'priority' || responseTier === 'fast';
-    const fastVerified = (cliPlane ? cliPickerVerified : pickerVerified)
-        && fastAdvertised && fastRequested && fastEffective;
-    const fastBlockers = [
-        ...(input.blockers || []),
-        ...(!cliPlane && input.level === 'deep' && input.pickerControlVisible === false ? ['fast_picker_control_not_visible'] : []),
-        ...(input.level === 'deep' && fastRequested && !fastEffective ? ['fast_service_tier_not_effective'] : []),
-        ...(cliPlane && input.level !== 'shallow' && fastRequested && hasCatalogPayload && !fastEffective
-            ? ['fast_service_tier_not_effective']
-            : [])
-    ];
-    const fastMode = probeEvidence({
-        configured: fastConfigured,
-        advertised: fastAdvertised,
-        attempted: Boolean(input.requestServiceTier || input.responseActualServiceTier),
-        verified: fastVerified,
-        fixture: input.fixture,
-        unsupported: Boolean(hasCatalogPayload && normalized?.ok && !fastAdvertised),
-        source: fastVerified
-            ? cliPlane ? 'transport' : 'deep_probe'
-            : input.requestServiceTier || input.responseActualServiceTier
-                ? 'transport'
-                : fastAdvertised
-                    ? 'manifest'
-                    : 'config',
-        blockers: fastBlockers,
-        warnings: fastConfigured && !fastAdvertised ? ['fast_configured_but_not_catalog_advertised'] : [],
-        evidence: {
-            configured_service_tier: configuredTier,
-            advertised_additional_speed_tiers: advertisedSpeedTiers,
-            advertised_service_tiers: advertisedServiceTiers,
-            picker_control_visible: input.pickerControlVisible ?? null,
-            request_service_tier: requestTier,
-            request_priority_mapping: fastRequested ? 'priority' : null,
-            response_actual_service_tier: responseTier,
-            configured: fastConfigured,
-            advertised: fastAdvertised,
-            effective: fastEffective
-        }
-    }, input.checkedAt);
-    return { catalog, model_picker: modelPicker, fast_mode: fastMode };
-}
-function manifestFlag(manifest, section, key) {
-    const row = manifest?.[section];
-    if (!row || typeof row !== 'object' || Array.isArray(row))
-        return null;
-    const value = row[key];
-    return typeof value === 'boolean' ? value : null;
-}
-function tierNames(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.map((entry) => normalizeTier(typeof entry === 'string'
-        ? entry
-        : entry && typeof entry === 'object'
-            ? entry.id ?? entry.name
-                ?? entry.service_tier
-                ?? entry.tier
-            : null)).filter((entry) => Boolean(entry));
-}
-function normalizeTier(value) {
-    const tier = String(value || '').trim().toLowerCase();
-    return tier || null;
+    });
 }

package/dist/core/codex-lb/probes/computer-use-probe.js

@@ -1,42 +1,44 @@
-import { probeEvidence } from './probe-evidence.js';
-export function runComputerUseProbe(input) {
-    const callEventSeen = (input.events || []).some(isComputerCallEvent);
-    const attempted = input.attempted === true || Boolean(input.events?.length);
-    const blockers = [
-        ...(input.blockers || []),
-        ...(attempted && input.toolAdvertised === false ? ['computer_tool_not_advertised'] : []),
-        ...(attempted && !callEventSeen ? ['computer_call_event_filtered'] : []),
-        ...(input.level === 'deep' && attempted && input.localExecutorCompleted !== true ? ['computer_executor_unavailable'] : []),
-        ...(input.level === 'deep' && attempted && input.outputSubmitted !== true ? ['computer_output_rejected'] : []),
-        ...(input.level === 'deep' && attempted && input.sessionAffinityPreserved !== true ? ['computer_session_affinity_lost'] : []),
-        ...(input.level === 'deep' && attempted && input.followUpCompleted !== true ? ['computer_follow_up_incomplete'] : [])
-    ];
-    return probeEvidence({
-        advertised: input.toolAdvertised === true,
-        attempted,
-        verified: input.level === 'deep'
-            && callEventSeen
-            && input.localExecutorCompleted === true
-            && input.outputSubmitted === true
-            && input.followUpCompleted === true
-            && input.sessionAffinityPreserved === true,
-        fixture: input.fixture,
-        source: input.level === 'deep' ? 'deep_probe' : attempted ? 'transport' : 'manifest',
-        unsupported: input.toolAdvertised === false && !attempted,
-        blockers,
-        warnings: callEventSeen && input.level !== 'deep'
-            ? ['computer_call_transport_seen_without_real_executor_loop']
-            : [],
-        evidence: {
-            tool_advertised: input.toolAdvertised === true,
-            call_event_seen: callEventSeen,
-            local_executor_completed: input.localExecutorCompleted === true,
-            output_submitted: input.outputSubmitted === true,
-            follow_up_completed: input.followUpCompleted === true,
-            session_affinity_preserved: input.sessionAffinityPreserved === true,
-            fixture: input.fixture === true
-        }
-    }, input.checkedAt);
+import { capabilityProbeResultV3 } from './probe-evidence.js';
+export function runComputerUseProbeV3(input) {
+    if (input.requestedLevel !== 'deep' || input.attempted !== true || input.fixture === true) {
+        return capabilityProbeResultV3({
+            ...input,
+            capability: 'computer_use',
+            scope: `provider:${input.providerId}`,
+            stage: 'preflight',
+            state: 'not_attempted',
+            source: input.advertised ? 'manifest' : 'config',
+            warnings: input.fixture ? ['computer_fixture_not_live_evidence'] : [],
+            recoveryAction: 'run_deep_verification',
+            evidence: { advertised: input.advertised === true, fixture: input.fixture === true }
+        });
+    }
+    const failure = firstComputerFailure(input);
+    if (failure) {
+        return capabilityProbeResultV3({
+            ...input,
+            capability: 'computer_use',
+            scope: `provider:${input.providerId}`,
+            stage: failure.stage,
+            state: 'blocked',
+            terminal: true,
+            rootCause: failure.blocker,
+            blockers: [failure.blocker],
+            retryable: true,
+            recoveryAction: 'run_deep_verification',
+            source: 'deep_probe',
+            evidence: computerEvidence(input)
+        });
+    }
+    return capabilityProbeResultV3({
+        ...input,
+        capability: 'computer_use',
+        scope: `provider:${input.providerId}`,
+        stage: 'complete',
+        state: 'verified',
+        source: 'deep_probe',
+        evidence: computerEvidence(input)
+    });
 }
 export function isComputerCallEvent(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -48,3 +50,25 @@ export function isComputerCallEvent(value) {
     return Boolean(item && typeof item === 'object' && !Array.isArray(item)
         && /computer_call/i.test(String(item.type || '')));
 }
+function firstComputerFailure(input) {
+    if (input.callEventSeen !== true)
+        return { stage: 'feature_response', blocker: 'computer_call_event_filtered' };
+    if (input.localExecutorCompleted !== true)
+        return { stage: 'feature_response', blocker: 'computer_executor_unavailable' };
+    if (input.outputSubmitted !== true)
+        return { stage: 'feature_request', blocker: 'computer_output_rejected' };
+    if (input.followUpCompleted !== true)
+        return { stage: 'feature_response', blocker: 'computer_follow_up_incomplete' };
+    if (input.sessionAffinityPreserved !== true)
+        return { stage: 'feature_response', blocker: 'computer_session_affinity_lost' };
+    return null;
+}
+function computerEvidence(input) {
+    return {
+        call_event_seen: input.callEventSeen === true,
+        local_executor_completed: input.localExecutorCompleted === true,
+        output_submitted: input.outputSubmitted === true,
+        follow_up_completed: input.followUpCompleted === true,
+        session_affinity_preserved: input.sessionAffinityPreserved === true
+    };
+}