sneakoscope 1.0.7 → 1.0.8

package/README.md

@@ -4,6 +4,8 @@ Fast legacy-free proof-first Codex trust layer with image-based Voxel TriWiki.
 
 Sneakoscope Codex (`sks`) is a Codex CLI/App harness that makes repeatable Codex work auditable.
 
+SKS **1.0.8** is the Codex 0.132 UX-Review Seal: Codex CLI `rust-v0.132.0` compatibility is explicit, `codex exec resume --output-schema` is the preferred structured-output path, and `$UX-Review this screenshot with gpt-image-2 callouts, then fix the issues` is a real visual trust loop from source screenshot fidelity to generated callout ingestion, issue ledger extraction, bounded safe fixes, recapture/re-review, Image Voxel relations, Wrongness, Completion Proof, and Trust Report gates.
+
 SKS **1.0.7** is the Ultimate Final Completion seal for the Codex trust harness: Computer Use live evidence is an opt-in, local-only macOS evidence path with explicit `probe_only`, `live_capture_attempted`, `live_capture_success`, and `live_capture_blocked` modes; `codex-lb setup` reports durable persistence versus `process_only_ephemeral` honestly; and docs/release readiness checks block mock/probe/live overclaims.
 
 SKS **1.0.6** is the final precision polish for the Codex trust harness: hook compatibility is classified as upstream schema plus an SKS zero-warning strict subset, `sks codex-lb setup` previews and applies the exact choices the user selected, and Computer Use has an optional live smoke surface for macOS capability/evidence status.
@@ -25,6 +27,34 @@ SKS does not try to clone every other harness. It focuses on one thing: making C
 ![Sneakoscope Codex Trust Layer](docs/assets/sneakoscope-architecture-pipeline.jpg)
 
 
+## 1.0.8 Codex 0.132 UX-Review Seal
+
+1.0.8 makes UX-Review the representative SKS visual trust harness rather than a policy-only fixture. The CLI/App route now records source screenshot original-resolution metadata, requires real `gpt-image-2` generated callout images before verified UX claims, extracts visible callouts into `schemas/codex/image-ux-issue-ledger.schema.json`, plans bounded P0/P1-first fixes, and requires recapture/re-review before visual fix verification.
+
+```bash
+sks codex compatibility --json
+sks ux-review run --image ./screenshot.png --fix --json
+sks ux-review callouts --image ./screenshot.png --json
+sks ux-review extract-issues --generated-image ./generated-callouts.png --json
+sks ux-review fix latest --json
+sks ux-review recapture latest --json
+sks ux-review recheck latest --json
+sks ux-review status latest --json
+```
+
+Release checks now include:
+
+- `npm run codex:0.132-compat`
+- `npm run codex:output-schema-fixture`
+- `npm run image-fidelity:check`
+- `npm run ux-review:real-loop-fixture`
+- `npm run ux-review:no-text-fallback`
+- `npm run ux-review:image-voxel-relations`
+- `npm run memory-summary:rebuild-check`
+- `npm run loop-blocker:check`
+
+`gpt-image-2` output is local-only by default. Text-only critique is blocked, mock fixtures stay `verified_partial` or lower, screenshot binaries are not automatically published to shared TriWiki, and unavailable Codex/App image-generation capability is recorded as a blocker instead of being faked.
+
 ## 1.0.7 Ultimate Final Completion
 
 1.0.7 does not add a new route, skill, or competing harness. It closes the last trust gaps around live visual evidence, persistence truth, and release documentation.

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "1.0.7"
+version = "1.0.8"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

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

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 1.0.7"),
+        Some("--version") => println!("sks-rs 1.0.8"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.0.7';
+const FAST_PACKAGE_VERSION = '1.0.8';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--version' || args[0] === '-v' || args[0] === 'version') {

package/dist/build-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "typescript": true,
   "mjs_runtime_files": 0,
   "files": [
@@ -184,6 +184,8 @@
     "core/codex-adapter.js",
     "core/codex-app.d.ts",
     "core/codex-app.js",
+    "core/codex-compat/codex-0-132.d.ts",
+    "core/codex-compat/codex-0-132.js",
     "core/codex-compat/codex-compat-report.d.ts",
     "core/codex-compat/codex-compat-report.js",
     "core/codex-compat/codex-config-policy.d.ts",
@@ -206,6 +208,8 @@
     "core/codex-compat/codex-version-policy.js",
     "core/codex-compat/codex-version.d.ts",
     "core/codex-compat/codex-version.js",
+    "core/codex-exec-output-schema.d.ts",
+    "core/codex-exec-output-schema.js",
     "core/codex-lb-circuit.d.ts",
     "core/codex-lb-circuit.js",
     "core/codex-lb/codex-lb-env.d.ts",
@@ -370,14 +374,28 @@
     "core/hproof.js",
     "core/image-ux-review.d.ts",
     "core/image-ux-review.js",
+    "core/image-ux-review/callout-extraction.d.ts",
+    "core/image-ux-review/callout-extraction.js",
+    "core/image-ux-review/fix-loop.d.ts",
+    "core/image-ux-review/fix-loop.js",
+    "core/image-ux-review/fix-task-planner.d.ts",
+    "core/image-ux-review/fix-task-planner.js",
+    "core/image-ux-review/imagegen-adapter.d.ts",
+    "core/image-ux-review/imagegen-adapter.js",
+    "core/image-ux-review/recapture.d.ts",
+    "core/image-ux-review/recapture.js",
     "core/init.d.ts",
     "core/init.js",
     "core/language-preference.d.ts",
     "core/language-preference.js",
+    "core/loop-blocker.d.ts",
+    "core/loop-blocker.js",
     "core/managed-paths.d.ts",
     "core/managed-paths.js",
     "core/memory-governor.d.ts",
     "core/memory-governor.js",
+    "core/memory-summary.d.ts",
+    "core/memory-summary.js",
     "core/mission.d.ts",
     "core/mission.js",
     "core/mistake-memory.d.ts",

package/dist/commands/image-ux-review.d.ts

@@ -1,2 +1,321 @@
-export declare function run(command: any, args?: any): Promise<void>;
+export declare function run(command: any, args?: any): Promise<void | {
+    schema: string;
+    ok: any;
+    mission_id: any;
+    artifacts: {
+        policy: {
+            schema: string;
+            schema_version: number;
+            created_at: string;
+            contract_hash: any;
+            policy: string;
+            score_threshold: number;
+            minimum_delta_to_continue: number;
+            max_full_surface_passes: number;
+            max_screen_retries: number;
+            codex_compatibility: {
+                schema: string;
+                baseline: string;
+                required_version: string;
+                release_evidence: Readonly<{
+                    upstream: "openai/codex";
+                    tag: "rust-v0.132.0";
+                    tag_url: "https://github.com/openai/codex/releases/tag/rust-v0.132.0";
+                    local_detection: string[];
+                    official_model_doc: "https://developers.openai.com/api/docs/models/gpt-image-2";
+                }>;
+                capabilities: import("../core/codex-compat/codex-0-132.js").Codex0132Capability[];
+                ux_review_output_schema_preferred: boolean;
+                unknown_future_fields_policy: string;
+                hook_strict_subset_baseline: string;
+            };
+            output_schema: {
+                preferred_for_codex_0_132: boolean;
+                schemas: string[];
+            };
+            source_capture: {
+                required: boolean;
+                original_resolution_required: boolean;
+                local_only_default: boolean;
+                accepted_sources: string[];
+                privacy: string;
+            };
+            image_generation_review: {
+                required_for_gate: boolean;
+                model: string;
+                preferred_surface: string;
+                codex_app_imagegen_doc: string;
+                api_image_generation_doc: string;
+                gpt_image_2_model_doc: string;
+                required_policy: string;
+                output_artifact: string;
+                anti_substitution_rule: string;
+                prompt_contract: string[];
+                review_prompt_template: string;
+            };
+            extraction_policy: {
+                input_artifact: string;
+                output_artifact: string;
+                preferred_path: string;
+                fallback_cap: string;
+                required_issue_fields: string[];
+            };
+            remediation_policy: {
+                code_changes_allowed: string;
+                priority_order: string[];
+                patch_rule: string;
+                no_fallback: string;
+                repeated_blocker_stop_threshold: number;
+                db_destructive_operations_allowed: boolean;
+            };
+            evidence_artifacts: string[];
+        };
+        inventory: {
+            schema: string;
+            schema_version: number;
+            created_at: string;
+            contract_hash: any;
+            target: any;
+            task_signature: string;
+            capture_required: boolean;
+            source_screens: {
+                id: string;
+                source: any;
+                source_type: string;
+                capture_source: string;
+                status: string;
+                original_resolution: boolean;
+                width: null;
+                height: null;
+                sha256: null;
+                exif_orientation_normalized: string;
+                privacy: string;
+            }[];
+            capture_policy: string;
+            passed: boolean;
+            blockers: string[];
+        };
+        imagegen_request: {
+            schema: string;
+            created_at: string;
+            model: string;
+            surface: string;
+            privacy: string;
+            requests: any;
+            blocker_if_unavailable: {
+                schema: string;
+                status: string;
+                blocker: string;
+                surface: string;
+                model: string;
+                guidance: string;
+            };
+        };
+        generated_review_ledger: {
+            schema: string;
+            schema_version: number;
+            created_at: string;
+            contract_hash: any;
+            provider: {
+                model: string;
+                preferred_surface: string;
+                codex_app_imagegen_doc: string;
+                api_image_generation_doc: string;
+                gpt_image_2_model_doc: string;
+            };
+            required: boolean;
+            generated_review_images: any;
+            planned_reviews: any;
+            generated_count: any;
+            real_generated_count: any;
+            required_count: any;
+            text_only_count: any;
+            blockers: string[];
+            passed: boolean;
+            imagegen_blocker: {
+                schema: string;
+                status: string;
+                blocker: string;
+                surface: string;
+                model: string;
+                guidance: string;
+            } | null;
+            notes: string[];
+        };
+        issue_ledger: {
+            contract_hash: any;
+            output_schema: string;
+            scorecard: {
+                visual_review_completion: number;
+                issue_extraction_integrity: number;
+                p0_p1_resolution: number;
+                overall_score: number;
+            };
+            schema: string;
+            schema_version: number;
+            extraction_source: string;
+            extraction_method: string;
+            extracted_from_generated_callout: boolean;
+            issues: any;
+            blocking_issue_count: any;
+            p0_p1_zero: any;
+            blockers: string[];
+            passed: boolean;
+            validation: {
+                ok: boolean;
+                issues: string[];
+            };
+        };
+        fix_task_plan: {
+            schema: string;
+            tasks: any;
+            blockers: string[];
+            passed: boolean;
+            p0_p1_task_count: any;
+        };
+        fix_loop: {
+            schema: string;
+            max_full_surface_passes: number;
+            max_screen_retries: number;
+            priority_order: string[];
+            db_destructive_operations_allowed: boolean;
+            dirty_status_before_patch: any;
+            changed_files: any;
+            patch_commands: any;
+            patchable_tasks: any;
+            risky_tasks_blocked: any;
+            repeated_blocker: {
+                schema: string;
+                ok: boolean;
+                stop_required: boolean;
+                threshold: number;
+                repeated: {
+                    key: string;
+                    count: number;
+                }[];
+                status: string;
+            };
+            recapture_required: boolean;
+            no_op_patch_wrongness: boolean;
+            blockers: string[];
+            passed: boolean;
+            issue_status_policy: string;
+            result_status: string;
+            issue_count: any;
+        };
+        recapture_plan: {
+            schema: string;
+            changed_screens_only: boolean;
+            recapture_required: boolean;
+            recapture_source: string;
+            recaptured_screenshot_sha256: any;
+            recaptured_screenshot_dimensions: any;
+            before_after_relation_required: boolean;
+            gpt_image_2_re_review_required: boolean;
+            output_schema_recheck_required: boolean;
+            changed_screens_rechecked_or_not_applicable: boolean;
+            blockers: string[];
+            passed: boolean;
+        };
+        iteration_report: {
+            schema: string;
+            schema_version: number;
+            created_at: string;
+            contract_hash: any;
+            loop_policy: {
+                max_full_surface_passes: any;
+                max_screen_retries: any;
+                score_threshold: any;
+                minimum_delta_to_continue: any;
+                repeated_blocker_stop_threshold: any;
+            };
+            passes: {
+                pass: number;
+                type: string;
+                generated_review_images: any;
+                real_generated_review_images: any;
+                blocking_issue_count: any;
+                fix_tasks: any;
+                score: any;
+                status: string;
+            }[];
+            stopped: boolean;
+            stop_reason: string;
+            passed: boolean;
+        };
+        output_schema: import("../core/codex-exec-output-schema.js").CodexExecResumeOutputSchemaAvailability | {
+            ok: boolean;
+            status: string;
+            warnings: any[];
+        };
+        gate: {
+            passed: boolean;
+            schema: string;
+            schema_version: number;
+            created_at: string;
+            contract_hash: any;
+            real_source_screenshot_present: boolean;
+            computer_use_or_user_screenshot_source: any;
+            gpt_image_2_callout_generated: boolean;
+            generated_image_ingested: boolean;
+            callout_extraction_schema_valid: boolean;
+            issue_ledger_from_generated_callout: boolean;
+            p0_p1_zero_after_fix: boolean;
+            fix_loop_executed_or_not_needed: boolean;
+            changed_screens_rechecked: boolean;
+            image_voxel_relations_created: boolean;
+            wrongness_checked: boolean;
+            honest_mode_complete: boolean;
+            required_artifacts: string[];
+            blockers: any[];
+            verification_caps: {
+                text_only_review: string;
+                mock_fixture: string;
+                codex_less_than_0_132_fallback: string;
+            };
+            notes: string[];
+        };
+    };
+    proof: any;
+} | {
+    schema: string;
+    ok: boolean;
+    status: string;
+} | {
+    schema: string;
+    ok: any;
+    mission_id: any;
+    issue_ledger: {
+        contract_hash: any;
+        output_schema: string;
+        scorecard: {
+            visual_review_completion: number;
+            issue_extraction_integrity: number;
+            p0_p1_resolution: number;
+            overall_score: number;
+        };
+        schema: string;
+        schema_version: number;
+        extraction_source: string;
+        extraction_method: string;
+        extracted_from_generated_callout: boolean;
+        issues: any;
+        blocking_issue_count: any;
+        p0_p1_zero: any;
+        blockers: string[];
+        passed: boolean;
+        validation: {
+            ok: boolean;
+            issues: string[];
+        };
+    };
+    proof: any;
+} | {
+    schema: string;
+    ok: boolean;
+    mission_id: any;
+    gate: any;
+    issue_ledger: any;
+    generated_review_ledger: any;
+}>;
 //# sourceMappingURL=image-ux-review.d.ts.map

package/dist/commands/wiki.d.ts

@@ -15,7 +15,7 @@ export declare function run(_command: any, args?: any): Promise<void | {
     };
     active_records: {
         id: string;
-        kind: "incorrect_claim" | "overconfident_claim" | "stale_evidence" | "missing_evidence" | "test_failure" | "route_misclassification" | "scout_error" | "visual_anchor_error" | "image_bbox_error" | "db_safety_false_positive" | "db_safety_false_negative" | "hook_policy_mismatch" | "hook_semantic_mismatch" | "hook_strict_subset_misclassified" | "codex_lb_health_misread" | "codex_lb_missing_env_raw_message" | "codex_lb_setup_choice_drift" | "codex_lb_env_persistence_failure" | "computer_use_policy_misclassification" | "computer_use_live_smoke_mismatch" | "computer_use_external_block_overclaimed" | "mock_real_confusion" | "user_intent_misread" | "artifact_schema_error" | "trust_status_overclaim";
+        kind: "incorrect_claim" | "overconfident_claim" | "stale_evidence" | "missing_evidence" | "test_failure" | "route_misclassification" | "scout_error" | "visual_anchor_error" | "image_bbox_error" | "db_safety_false_positive" | "db_safety_false_negative" | "hook_policy_mismatch" | "hook_semantic_mismatch" | "hook_strict_subset_misclassified" | "codex_lb_health_misread" | "codex_lb_missing_env_raw_message" | "codex_lb_setup_choice_drift" | "codex_lb_env_persistence_failure" | "computer_use_policy_misclassification" | "computer_use_live_smoke_mismatch" | "computer_use_external_block_overclaimed" | "mock_real_confusion" | "user_intent_misread" | "artifact_schema_error" | "trust_status_overclaim" | "ux_review_text_only_fallback" | "gpt_image_2_callout_generation_failed" | "callout_extraction_schema_failed" | "callout_bbox_out_of_bounds" | "fix_loop_noop_patch" | "visual_fix_not_rechecked" | "post_fix_regression_detected" | "repeated_blocker_stop";
         severity: "high" | "low" | "medium" | "critical";
         route: string | null;
         claim: string;
@@ -26,6 +26,12 @@ export declare function run(_command: any, args?: any): Promise<void | {
     active_avoidance_rules: import("../core/triwiki-wrongness/wrongness-schema.js").WrongnessAvoidanceRule[];
     retrieval_policy: string;
 } | import("../core/git-hygiene/shared-memory-publish.js").SharedPublishResult | {
+    schema_version: number;
+    total: {};
+    active: {};
+    stale: boolean;
+    rebuild_recommended: boolean;
+} | {
     schema: string;
     target: any;
     mission_id: string | null;

package/dist/core/codex-compat/codex-0-132.d.ts

@@ -0,0 +1,46 @@
+export declare const CODEX_0_132_BASELINE_TAG = "rust-v0.132.0";
+export declare const CODEX_0_132_VERSION = "0.132.0";
+export type Codex0132CapabilityId = 'exec_resume_output_schema' | 'app_server_image_fidelity' | 'memory_summary_version_rebuild' | 'goal_continuation_blocker_stop' | 'tui_probe_batching' | 'remote_executor_standard_auth' | 'python_sdk_auth' | 'python_sdk_turn_result';
+export interface Codex0132Capability {
+    id: Codex0132CapabilityId;
+    priority: 'P0' | 'P1';
+    status: 'available' | 'integration_optional' | 'degraded_supported' | 'warning_only';
+    preferred?: boolean;
+    detector: string;
+    notes: string[];
+}
+export declare const CODEX_0_132_RELEASE_EVIDENCE: Readonly<{
+    upstream: "openai/codex";
+    tag: "rust-v0.132.0";
+    tag_url: "https://github.com/openai/codex/releases/tag/rust-v0.132.0";
+    local_detection: string[];
+    official_model_doc: "https://developers.openai.com/api/docs/models/gpt-image-2";
+}>;
+export declare function codex0132Capabilities(input?: {
+    version?: string | null;
+    available?: boolean;
+    execResumeHelp?: string;
+    execHelp?: string;
+}): Codex0132Capability[];
+export declare function codex0132Matrix(input?: {
+    version?: string | null;
+    available?: boolean;
+    execResumeHelp?: string;
+    execHelp?: string;
+}): {
+    schema: string;
+    baseline: string;
+    required_version: string;
+    release_evidence: Readonly<{
+        upstream: "openai/codex";
+        tag: "rust-v0.132.0";
+        tag_url: "https://github.com/openai/codex/releases/tag/rust-v0.132.0";
+        local_detection: string[];
+        official_model_doc: "https://developers.openai.com/api/docs/models/gpt-image-2";
+    }>;
+    capabilities: Codex0132Capability[];
+    ux_review_output_schema_preferred: boolean;
+    unknown_future_fields_policy: string;
+    hook_strict_subset_baseline: string;
+};
+//# sourceMappingURL=codex-0-132.d.ts.map

package/dist/core/codex-compat/codex-0-132.js

@@ -0,0 +1,105 @@
+import { compareSemverLike, parseCodexVersionText } from './codex-version-policy.js';
+export const CODEX_0_132_BASELINE_TAG = 'rust-v0.132.0';
+export const CODEX_0_132_VERSION = '0.132.0';
+export const CODEX_0_132_RELEASE_EVIDENCE = Object.freeze({
+    upstream: 'openai/codex',
+    tag: CODEX_0_132_BASELINE_TAG,
+    tag_url: 'https://github.com/openai/codex/releases/tag/rust-v0.132.0',
+    local_detection: [
+        'codex --version',
+        'codex exec --help',
+        'codex exec resume --help'
+    ],
+    official_model_doc: 'https://developers.openai.com/api/docs/models/gpt-image-2'
+});
+export function codex0132Capabilities(input = {}) {
+    const version = parseCodexVersionText(input.version) || input.version || null;
+    const available = input.available !== false && Boolean(version);
+    const meets = available && compareSemverLike(version, CODEX_0_132_VERSION) >= 0;
+    const resumeHelp = `${input.execResumeHelp || ''}\n${input.execHelp || ''}`;
+    const outputSchemaDetected = /--output-schema\b/.test(resumeHelp)
+        || /--output-schema\b/.test(input.execHelp || '');
+    const status = available
+        ? meets ? 'available' : 'degraded_supported'
+        : 'integration_optional';
+    const outputSchemaStatus = outputSchemaDetected || meets ? status : 'degraded_supported';
+    return [
+        {
+            id: 'exec_resume_output_schema',
+            priority: 'P0',
+            status: outputSchemaStatus,
+            preferred: outputSchemaStatus === 'available',
+            detector: 'Codex version >=0.132.0 or `codex exec resume --help` exposes --output-schema',
+            notes: [
+                'Preferred structured output path for Scout, UX-Review callout extraction, Completion Proof, and Wrongness outputs.',
+                outputSchemaDetected ? 'Local help text exposes --output-schema on exec resume.' : 'Help text did not expose --output-schema; fallback output is capped at verified_partial.'
+            ]
+        },
+        {
+            id: 'app_server_image_fidelity',
+            priority: 'P0',
+            status,
+            detector: 'Codex 0.132 baseline plus gpt-image-2 high-fidelity image input support',
+            notes: [
+                'UX-Review records original-resolution source metadata and generated/source dimension relations.',
+                'If the Codex App image surface is unavailable, SKS records imagegen_capability_missing and blocks verified visual claims.'
+            ]
+        },
+        {
+            id: 'memory_summary_version_rebuild',
+            priority: 'P0',
+            status,
+            detector: 'Codex 0.132 memory summary version/rebuild behavior mapped to SKS summary schema versions',
+            notes: ['TriWiki, Wrongness, and shared memory summaries carry schema versions and rebuild metadata.']
+        },
+        {
+            id: 'goal_continuation_blocker_stop',
+            priority: 'P0',
+            status,
+            detector: 'Codex 0.132 goal continuation usage-limit/repeated-blocker behavior',
+            notes: ['Goal, QA, Research, and UX-Review loops use the same repeated-blocker stop contract.']
+        },
+        {
+            id: 'tui_probe_batching',
+            priority: 'P0',
+            status,
+            detector: 'Codex 0.132 TUI startup terminal capability probe batching mapped to SKS doctor probes',
+            notes: ['Doctor probes expose batchable probe ids and timeout budgets.']
+        },
+        {
+            id: 'remote_executor_standard_auth',
+            priority: 'P1',
+            status: status === 'available' ? 'warning_only' : status,
+            detector: 'Codex 0.132 remote executor registration can use standard Codex auth',
+            notes: ['Recorded as a codex-lb/remote executor policy review item; no credential fallback is invented.']
+        },
+        {
+            id: 'python_sdk_auth',
+            priority: 'P1',
+            status: status === 'available' ? 'warning_only' : status,
+            detector: 'Codex 0.132 Python SDK first-class auth',
+            notes: ['P1 optional adapter skeleton only; SKS eval harness remains JS-first unless explicitly configured.']
+        },
+        {
+            id: 'python_sdk_turn_result',
+            priority: 'P1',
+            status: status === 'available' ? 'warning_only' : status,
+            detector: 'Codex 0.132 richer Python TurnResult',
+            notes: ['P1 optional timing/usage adapter target for future scout benchmarks.']
+        }
+    ];
+}
+export function codex0132Matrix(input = {}) {
+    const capabilities = codex0132Capabilities(input);
+    return {
+        schema: 'sks.codex-0-132-matrix.v1',
+        baseline: CODEX_0_132_BASELINE_TAG,
+        required_version: CODEX_0_132_VERSION,
+        release_evidence: CODEX_0_132_RELEASE_EVIDENCE,
+        capabilities,
+        ux_review_output_schema_preferred: capabilities.find((capability) => capability.id === 'exec_resume_output_schema')?.preferred === true,
+        unknown_future_fields_policy: 'warning_only_baseline_validation',
+        hook_strict_subset_baseline: 'rust-v0.131.0'
+    };
+}
+//# sourceMappingURL=codex-0-132.js.map