sneakoscope 2.0.2 → 2.0.4

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.2** is a P0 Codex App Fast UI and MAD Zellij worker-pane closure patch on top of the 2.0 execution layer. `sks --mad` now relies on launch-time Fast/high overrides instead of user-level Codex config rewrites, safe Fast UI repair runs through `sks doctor --fix`, provider badges read env/auth/config.toml consistently, and interactive MAD worker panes attach to the real Zellij session as scheduler slots spawn.
+SKS **2.0.4** is a P0 Codex App Fast UI and MAD Zellij worker-pane closure patch on top of the 2.0 execution layer. `sks --mad` now relies on launch-time Fast/high overrides instead of user-level Codex config rewrites, safe Fast UI repair runs through `sks doctor --fix`, provider badges read env/auth/config.toml consistently, and interactive MAD worker panes attach to the real Zellij session as scheduler slots spawn.
 
 What changed:
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.2"
+version = "2.0.4"
 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 2.0.2"),
+        Some("--version") => println!("sks-rs 2.0.4"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "2.0.2",
-  "source_digest": "b1e08c53f5899ea762b2bb7a06ea6fab73ddfccac076d17c276685f2a8e12beb",
-  "source_file_count": 1861,
-  "built_at_source_time": 1780562040816
+  "package_version": "2.0.4",
+  "source_digest": "bd67ddf989e2e0b702453d422e2cf991e8ca397d3d4afc14fdfa06b4610452c9",
+  "source_file_count": 1879,
+  "built_at_source_time": 1780569940553
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '2.0.2';
+const FAST_PACKAGE_VERSION = '2.0.4';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "2.0.2",
-  "package_version": "2.0.2",
+  "version": "2.0.4",
+  "package_version": "2.0.4",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 936,
-  "compiled_js_count": 936,
+  "compiled_file_count": 949,
+  "compiled_js_count": 949,
   "compiled_dts_count": 0,
-  "source_digest": "b1e08c53f5899ea762b2bb7a06ea6fab73ddfccac076d17c276685f2a8e12beb",
-  "source_file_count": 1861,
-  "source_files_hash": "c8eda2a67acc10058477afb1eb7963595dc9ba17273dd4fd396014d8862b277f",
-  "source_list_hash": "c8eda2a67acc10058477afb1eb7963595dc9ba17273dd4fd396014d8862b277f",
+  "source_digest": "bd67ddf989e2e0b702453d422e2cf991e8ca397d3d4afc14fdfa06b4610452c9",
+  "source_file_count": 1879,
+  "source_files_hash": "c43d09b591370ad58937365d6bbfca2be0b60fcf04a43fdbb9a56d9288752814",
+  "source_list_hash": "c43d09b591370ad58937365d6bbfca2be0b60fcf04a43fdbb9a56d9288752814",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -212,6 +212,10 @@
     "core/codex-control/codex-sdk-sandbox-policy.js",
     "core/codex-control/codex-task-runner.js",
     "core/codex-control/codex-thread-registry.js",
+    "core/codex-control/gpt-final-arbiter.js",
+    "core/codex-control/gpt-final-context-compressor.js",
+    "core/codex-control/gpt-final-proof-pack.js",
+    "core/codex-control/gpt-final-review-schema.js",
     "core/codex-control/schemas/agent-worker-result.schema.js",
     "core/codex-exec-output-schema.js",
     "core/codex-hooks/codex-hook-actual-discovery.js",
@@ -357,6 +361,8 @@
     "core/init.js",
     "core/json-schema-validator.js",
     "core/language-preference.js",
+    "core/local-llm/local-collaboration-policy.js",
+    "core/local-llm/local-llm-config.js",
     "core/loop-blocker.js",
     "core/mad-sks/audit-ledger.js",
     "core/mad-sks/authorization-manifest.js",
@@ -398,6 +404,8 @@
     "core/pipeline.js",
     "core/pipeline/active-context.js",
     "core/pipeline/agent-stage-policy.js",
+    "core/pipeline/final-gpt-patch-stage.js",
+    "core/pipeline/final-gpt-review-stage.js",
     "core/pipeline/pipeline-plan-writer.js",
     "core/pipeline/plan-schema.js",
     "core/pipeline/prompt-context-answer.js",
@@ -763,6 +771,8 @@
     "scripts/flagship-proof-graph-v4-check.js",
     "scripts/git-precommit-fixture-check.js",
     "scripts/goal-mode-official-default-check.js",
+    "scripts/gpt-final-arbiter-check.js",
+    "scripts/gpt-final-arbiter-performance-check.js",
     "scripts/gpt-image-2-real-file-smoke.js",
     "scripts/gpt-image-2-request-validator-check.js",
     "scripts/hooks-0.134-context-parity-check.js",
@@ -792,6 +802,9 @@
     "scripts/lib/real-codex-parallel-gate.js",
     "scripts/lib/real-codex-parallel-proof-fixture.js",
     "scripts/lib/valid-png-fixture.js",
+    "scripts/local-collab-gpt-final-availability-check.js",
+    "scripts/local-collab-no-local-only-final-check.js",
+    "scripts/local-collab-policy-check.js",
     "scripts/loop-blocker-check.js",
     "scripts/mad-preflight-blocks-unreadable-config-check.js",
     "scripts/mad-sks-actual-executor-blackbox.js",

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

@@ -49,6 +49,9 @@ import { writeNativeCliSessionProof } from './native-cli-session-proof.js';
 import { writeNoSubagentScalingPolicy } from './no-subagent-scaling-policy.js';
 import { runCodexTask } from '../codex-control/codex-control-plane.js';
 import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
+import { resolveLocalCollaborationPolicy, localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
+import { runFinalGptReviewStage } from '../pipeline/final-gpt-review-stage.js';
+import { selectFinalGptPatchSource } from '../pipeline/final-gpt-patch-stage.js';
 export async function runNativeAgentOrchestrator(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const prompt = String(opts.prompt || 'Native agent run');
@@ -369,15 +372,51 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     });
     const noSubagentScalingPolicy = await writeNoSubagentScalingPolicy(ledgerRoot, { nativeProof: nativeCliSessionProof });
     const fastModePropagation = await writeFastModePropagationProof(ledgerRoot, { policy: fastModePolicy, backend, results });
+    const localCollaborationPolicy = resolveLocalCollaborationPolicy();
+    await writeJsonAtomic(path.join(ledgerRoot, 'local-collaboration-policy.json'), localCollaborationPolicy);
+    const localParticipated = localCollaborationParticipated(results);
+    const candidatePatchEnvelopes = results.flatMap((result) => Array.isArray(result.patch_envelopes) ? result.patch_envelopes : []);
+    const gptFinalArbiter = localParticipated
+        ? await runFinalGptReviewStage({
+            schema: 'sks.gpt-final-arbiter-input.v1',
+            route,
+            mission_id: missionId,
+            local_mode: localCollaborationPolicy.mode,
+            local_outputs: results.map((result) => ({
+                worker_id: result.agent_id,
+                backend: result.backend_router_report?.selected_backend || result.backend || backend,
+                status: result.status,
+                summary: result.summary,
+                patch_envelopes: result.patch_envelopes || [],
+                proof: result.verification?.status || '',
+                blockers: result.blockers || [],
+                changed_files: result.changed_files || []
+            })),
+            candidate_diff: '',
+            candidate_patch_envelopes: candidatePatchEnvelopes,
+            verification_results: results.map((result) => result.verification || { status: result.status || 'unknown' }),
+            side_effect_report: { schema: 'sks.agent-side-effect-summary.v1', ok: true, route, mutation_owner: 'parent_agent_orchestrator' },
+            mutation_ledger: { parallel_write_policy: parallelWritePolicy, result_count: results.length },
+            rollback_plan: { verification_rollback_dag: strategyCompiled.verification_rollback_dag || null }
+        }, { cwd: root, mutationLedgerRoot: path.join(ledgerRoot, 'gpt-final-arbiter') })
+        : null;
+    const finalGptPatchStage = localParticipated
+        ? selectFinalGptPatchSource(gptFinalArbiter, candidatePatchEnvelopes)
+        : null;
+    const resultsForPatchSwarm = localParticipated && finalGptPatchStage?.ok === true && gptFinalArbiter?.result?.status === 'modified'
+        ? withFinalGptPatchEnvelopes(results, finalGptPatchStage.patch_envelopes)
+        : results;
     const patchSwarm = await runAgentPatchSwarmRuntime(root, ledgerRoot, {
         missionId,
         route,
         routeCommand,
         writeCapable,
-        results,
+        results: resultsForPatchSwarm,
         parallelWritePolicy,
         verificationRollbackDag: strategyCompiled.verification_rollback_dag,
-        dryRun: opts.dryRunPatches === true || opts.applyPatches !== true
+        dryRun: opts.dryRunPatches === true || opts.applyPatches !== true || (localParticipated && gptFinalArbiter?.ok !== true),
+        gptFinalArbiter,
+        finalGptPatchStage
     });
     const stale = await detectStaleAgentSessions(ledgerRoot);
     if (!stale.ok)
@@ -403,6 +442,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         ...(nativeCliSessionProof.ok ? [] : nativeCliSessionProof.blockers),
         ...(noSubagentScalingPolicy.ok ? [] : noSubagentScalingPolicy.blockers),
         ...(fastModePropagation.ok ? [] : fastModePropagation.blockers),
+        ...(localParticipated && gptFinalArbiter?.ok !== true ? gptFinalArbiter?.blockers || ['gpt_final_arbiter_not_ok'] : []),
+        ...(localParticipated && finalGptPatchStage?.ok === false ? finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
         ...(patchSwarm.ok ? [] : patchSwarm.blockers),
         ...(janitor.ok ? [] : janitor.blockers)
     ];
@@ -438,7 +479,10 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         fastModePolicy,
         fastModePropagation,
         triwikiContext,
-        selectedCoreSkill
+        selectedCoreSkill,
+        localCollaborationPolicy,
+        gptFinalArbiter,
+        finalGptPatchStage
     });
     await writeAgentCodexCockpitArtifacts(dir, { missionId, projectHash: namespace.root_hash });
     await setCurrent(root, { mission_id: missionId, mode: 'AGENT', phase: proof.ok ? 'AGENT_NATIVE_KERNEL_DONE' : 'AGENT_NATIVE_KERNEL_BLOCKED', native_agent_backend: backend, updated_at: nowIso() });
@@ -478,10 +522,30 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         no_subagent_scaling_policy: noSubagentScalingPolicy,
         fast_mode_policy: fastModePolicy,
         fast_mode_propagation: fastModePropagation,
+        local_collaboration_policy: localCollaborationPolicy,
+        gpt_final_arbiter: gptFinalArbiter,
+        final_gpt_patch_stage: finalGptPatchStage,
         patch_swarm: patchSwarm,
         proof
     };
 }
+function withFinalGptPatchEnvelopes(results, patchEnvelopes = []) {
+    const byAgent = new Map();
+    for (const envelope of patchEnvelopes) {
+        const agentId = String(envelope?.agent_id || 'gpt-final-arbiter');
+        byAgent.set(agentId, [...(byAgent.get(agentId) || []), envelope]);
+    }
+    let assigned = false;
+    const next = results.map((result) => {
+        const envelopes = byAgent.get(String(result.agent_id || '')) || [];
+        if (envelopes.length)
+            assigned = true;
+        return { ...result, patch_envelopes: envelopes };
+    });
+    if (!assigned && patchEnvelopes.length && next[0])
+        next[0] = { ...next[0], patch_envelopes: patchEnvelopes };
+    return next;
+}
 async function legacyCodexExecBlockedRun(input) {
     const blockers = ['legacy_codex_exec_runtime_removed'];
     const ledgerRoot = path.join(input.dir, 'agents');
@@ -706,7 +770,9 @@ async function runAgentPatchSwarmRuntime(root, ledgerRoot, input) {
         verification: verificationResults.results.map((result) => result.status),
         parallelWritePolicy: input.parallelWritePolicy,
         conflictRebase,
-        verificationRollbackDag: input.verificationRollbackDag
+        verificationRollbackDag: input.verificationRollbackDag,
+        gptFinalArbiter: input.gptFinalArbiter,
+        finalGptPatchStage: input.finalGptPatchStage
     };
     const initialProof = buildAgentPatchProof(proofInput);
     await writeJsonAtomic(path.join(ledgerRoot, 'agent-patch-proof.json'), initialProof);

package/dist/core/agents/agent-patch-proof.js

@@ -50,6 +50,8 @@ export function buildAgentPatchProof(input = {}) {
         ...journalBlockers,
         ...rebaseBlockers,
         ...parallelGroupBlockers,
+        ...(input.gptFinalArbiter && input.gptFinalArbiter.ok !== true ? input.gptFinalArbiter.blockers || ['gpt_final_arbiter_not_ok'] : []),
+        ...(input.finalGptPatchStage && input.finalGptPatchStage.ok !== true ? input.finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
         ...applyResults.flatMap((applyResult) => applyResult.ok ? [] : (applyResult.violations || ['patch_apply_failed']))
     ].map(String);
     const changedFilesByAgent = changedFilesGroupedByAgent(applyResults);
@@ -71,6 +73,9 @@ export function buildAgentPatchProof(input = {}) {
         verification_node_coverage: strictWiring.verification_node_coverage,
         rollback_node_coverage: strictWiring.rollback_node_coverage,
         parallel_patch_apply_verified: hasParallelGroup,
+        gpt_final_arbiter: input.gptFinalArbiter ? 'gpt-final-arbiter/gpt-final-arbiter.json' : null,
+        gpt_final_status: input.gptFinalArbiter?.result?.status || null,
+        final_patch_source: input.finalGptPatchStage?.final_patch_source || null,
         patch_conflict_count: Number(input.merge?.conflicts?.length || 0),
         serial_bottleneck_count: Number(input.merge?.serial_conflicts?.length || 0),
         changed_files_by_agent: changedFilesByAgent,

package/dist/core/agents/agent-proof-evidence.js

@@ -8,6 +8,7 @@ import { assertAgentSessionGenerationsClosed } from './agent-session-generation.
 import { readZellijLaneSupervisor } from './zellij-lane-supervisor.js';
 import { writeFakeRealProofPolicyReport } from '../proof/fake-real-proof-policy.js';
 import { buildRuntimeTruthMatrix, writeRuntimeTruthMatrix } from '../proof/runtime-truth-matrix.js';
+import { evaluateLocalCollaborationFinalGate, localCollaborationParticipated, resolveLocalCollaborationPolicy } from '../local-llm/local-collaboration-policy.js';
 export async function writeAgentProofEvidence(root, input) {
     const lifecycle = await assertAllAgentSessionsClosed(root);
     const terminal = await assertAgentTerminalSessionsClosed(root);
@@ -28,6 +29,18 @@ export async function writeAgentProofEvidence(root, input) {
     const patchRollbackProof = await readJson(path.join(root, 'agent-patch-rollback-proof.json'), null);
     const patchProof = await readJson(path.join(root, 'agent-patch-proof.json'), null);
     const patchSwarm = input.patchSwarm || await readJson(path.join(root, 'agent-patch-swarm-runtime.json'), null);
+    const localCollaborationPolicy = input.localCollaborationPolicy || await readJson(path.join(root, 'local-collaboration-policy.json'), null) || resolveLocalCollaborationPolicy();
+    const gptFinalArbiter = input.gptFinalArbiter || await readJson(path.join(root, 'gpt-final-arbiter', 'gpt-final-arbiter.json'), null);
+    const localParticipated = localCollaborationParticipated(input.results || []) || Number(gptFinalArbiter?.local_outputs_count || 0) > 0;
+    const finalGptPatchStage = input.finalGptPatchStage || null;
+    const localFinalGate = gptFinalArbiter?.final_gate || evaluateLocalCollaborationFinalGate({
+        policy: localCollaborationPolicy,
+        localParticipated,
+        gptFinalStatus: gptFinalArbiter?.result?.status || null,
+        gptFinalAvailable: Boolean(gptFinalArbiter),
+        gptFinalBackend: gptFinalArbiter?.backend || null,
+        applyPatches: parallelWritePolicy?.apply_patches === true
+    });
     const nativeCliSessionProof = input.nativeCliSessionProof || await readJson(path.join(root, 'native-cli-session-proof.json'), null);
     const noSubagentScalingPolicy = input.noSubagentScalingPolicy || await readJson(path.join(root, 'no-subagent-scaling-policy.json'), null);
     const fastModePropagation = input.fastModePropagation || await readJson(path.join(root, 'fast-mode-propagation-proof.json'), null);
@@ -161,6 +174,9 @@ export async function writeAgentProofEvidence(root, input) {
         ...(patchSwarm && !patchApplyOk ? ['patch_apply_not_ok'] : []),
         ...(patchSwarm && !patchVerificationOk ? ['patch_verification_not_ok'] : []),
         ...(patchSwarm && !patchRollbackOk ? ['patch_rollback_not_ok'] : []),
+        ...(localParticipated && localFinalGate.ok !== true ? localFinalGate.blockers || ['gpt_final_arbiter_gate_not_ok'] : []),
+        ...(localParticipated && gptFinalArbiter?.ok !== true ? gptFinalArbiter?.blockers || ['gpt_final_arbiter_not_ok'] : []),
+        ...(localParticipated && finalGptPatchStage?.ok === false ? finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
         ...agentChangedFileLeaseViolations(input.results || [], input.partition?.leases || [])
     ];
     const evidence = {
@@ -197,6 +213,15 @@ export async function writeAgentProofEvidence(root, input) {
         parallel_write_apply_patches: parallelWritePolicy?.apply_patches === true,
         parallel_write_dry_run_patches: parallelWritePolicy?.dry_run_patches === true,
         parallel_write_max_write_agents: Number(parallelWritePolicy?.max_write_agents || 0),
+        local_collaboration_policy: 'local-collaboration-policy.json',
+        local_collaboration_mode: localCollaborationPolicy.mode || null,
+        local_collaboration_participated: localParticipated,
+        gpt_final_arbiter: gptFinalArbiter ? 'gpt-final-arbiter/gpt-final-arbiter.json' : null,
+        gpt_final_status: gptFinalArbiter?.result?.status || (localParticipated ? 'missing' : 'not_required_no_local_outputs'),
+        gpt_final_backend: gptFinalArbiter?.backend || null,
+        gpt_final_patch_source: finalGptPatchStage?.final_patch_source || (localParticipated ? 'blocked' : 'not_applicable'),
+        gpt_final_gate_ok: localFinalGate.ok === true,
+        gpt_final_gate: localFinalGate,
         patch_swarm_runtime: patchSwarm ? 'agent-patch-swarm-runtime.json' : null,
         patch_queue: patchSwarm ? 'agent-patch-queue.json' : null,
         patch_queue_events: patchSwarm ? 'agent-patch-queue-events.jsonl' : null,
@@ -329,6 +354,7 @@ export async function writeAgentProofEvidence(root, input) {
             'strategy-gate.json': strategyGate,
             'agent-patch-proof.json': patchProof,
             'agent-patch-swarm-runtime.json': patchSwarm,
+            'gpt-final-arbiter/gpt-final-arbiter.json': gptFinalArbiter,
             'native-cli-session-proof.json': nativeCliSessionProof,
             'no-subagent-scaling-policy.json': noSubagentScalingPolicy,
             'fast-mode-propagation-proof.json': fastModePropagation

package/dist/core/codex-control/codex-fake-sdk-adapter.js

@@ -1,4 +1,5 @@
 import { nowIso, randomId } from '../fsx.js';
+import { GPT_FINAL_ARBITER_RESULT_SCHEMA_ID } from './gpt-final-review-schema.js';
 export function fakeCodexSdkAllowed() {
     return process.env.NODE_ENV === 'test'
         || process.env.SKS_CODEX_SDK_FAKE === '1'
@@ -25,6 +26,25 @@ export async function runFakeCodexSdkTask(input) {
     };
 }
 function fakeStructuredOutput(input) {
+    if (input.outputSchemaId === GPT_FINAL_ARBITER_RESULT_SCHEMA_ID) {
+        const unsafe = /\b(truncate|delete all|drop table|credential)\b/i.test(input.prompt || '');
+        return {
+            schema: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID,
+            status: unsafe ? 'rejected' : 'approved',
+            summary: unsafe
+                ? 'Fake Codex SDK GPT final arbiter rejected an unsafe candidate for hermetic verification.'
+                : 'Fake Codex SDK GPT final arbiter approved the candidate for hermetic verification.',
+            gpt_review_findings: unsafe ? [{ severity: 'high', message: 'unsafe candidate rejected' }] : [],
+            accepted_patch_envelopes: unsafe ? [] : [],
+            modified_patch_envelopes: [],
+            rejected_patch_envelopes: unsafe ? [{ reason: 'unsafe candidate' }] : [],
+            required_followup_work: unsafe ? [{ blocker: 'unsafe_candidate_patch' }] : [],
+            verification_plan: ['schema validation', 'local collaboration final gate'],
+            rollback_notes: [],
+            blockers: unsafe ? ['unsafe_candidate_patch'] : [],
+            confidence: unsafe ? 'medium' : 'high'
+        };
+    }
     return {
         status: 'done',
         summary: `Fake Codex SDK task completed for ${input.workItemId || input.route}.`,

package/dist/core/codex-control/codex-output-schemas.js

@@ -1,4 +1,5 @@
 import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from './schemas/agent-worker-result.schema.js';
+import { GPT_FINAL_ARBITER_RESULT_SCHEMA_ID, gptFinalArbiterResultSchema } from './gpt-final-review-schema.js';
 export const CODEX_OUTPUT_SCHEMA_IDS = [
     CODEX_AGENT_WORKER_RESULT_SCHEMA_ID,
     'sks.patch-envelope-result.v1',
@@ -6,11 +7,14 @@ export const CODEX_OUTPUT_SCHEMA_IDS = [
     'sks.research-digest.v1',
     'sks.release-failure-analysis.v1',
     'sks.ux-ppt-review-result.v1',
-    'sks.core-skill-heldout-validation.v1'
+    'sks.core-skill-heldout-validation.v1',
+    GPT_FINAL_ARBITER_RESULT_SCHEMA_ID
 ];
 export function resolveCodexOutputSchema(schemaId, fallback) {
     if (schemaId === CODEX_AGENT_WORKER_RESULT_SCHEMA_ID)
         return codexAgentWorkerResultSchema;
+    if (schemaId === GPT_FINAL_ARBITER_RESULT_SCHEMA_ID)
+        return gptFinalArbiterResultSchema;
     if (fallback && typeof fallback === 'object')
         return fallback;
     return {

package/dist/core/codex-control/gpt-final-arbiter.js

@@ -0,0 +1,160 @@
+import path from 'node:path';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { validateJsonSchemaRecursive } from '../json-schema-validator.js';
+import { evaluateLocalCollaborationFinalGate, resolveLocalCollaborationPolicy } from '../local-llm/local-collaboration-policy.js';
+import { runCodexTask } from './codex-control-plane.js';
+import { GPT_FINAL_ARBITER_INPUT_SCHEMA, GPT_FINAL_ARBITER_RESULT_SCHEMA_ID, gptFinalArbiterResultSchema, normalizeGptFinalArbiterResult } from './gpt-final-review-schema.js';
+import { compressGptFinalContext } from './gpt-final-context-compressor.js';
+export const GPT_FINAL_ARBITER_RUN_SCHEMA = 'sks.gpt-final-arbiter-run.v1';
+export async function runGptFinalArbiter(input, opts = {}) {
+    const started = Date.now();
+    const cwd = path.resolve(opts.cwd || process.cwd());
+    const root = path.resolve(opts.mutationLedgerRoot || path.join(cwd, '.sneakoscope', 'tmp', 'gpt-final-arbiter', safeName(input.mission_id || 'mission')));
+    const policy = resolveLocalCollaborationPolicy({ mode: input.local_mode });
+    const compressed = compressGptFinalContext(input);
+    if (policy.local_only_draft) {
+        return finalize(root, input, policy, compressed, blockedResult('needs_gpt_final_review', 'Local-only draft mode cannot produce final accepted proof.'), started, opts);
+    }
+    if (opts.forceUnavailable || process.env.SKS_GPT_FINAL_ARBITER_UNAVAILABLE === '1') {
+        return finalize(root, input, policy, compressed, blockedResult('gpt_final_arbiter_unavailable', 'GPT final arbiter backend is unavailable.'), started, opts);
+    }
+    let codexTask = null;
+    let parsed = null;
+    try {
+        codexTask = await runCodexTask({
+            route: String(input.route || '$Pipeline'),
+            tier: 'orchestrator',
+            missionId: String(input.mission_id || ''),
+            workItemId: 'gpt-final-arbiter',
+            slotId: 'gpt-final-arbiter',
+            generationIndex: 1,
+            sessionId: `gpt-final-${safeName(input.mission_id || 'mission')}`,
+            cwd,
+            prompt: buildArbiterPrompt(input, compressed),
+            inputFiles: [],
+            inputImages: [],
+            outputSchemaId: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID,
+            outputSchema: gptFinalArbiterResultSchema,
+            sandboxPolicy: 'read-only',
+            requestedScopeContract: {
+                id: `gpt-final:${input.mission_id || 'mission'}`,
+                route: String(input.route || '$Pipeline'),
+                read_only: true,
+                allowed_paths: [],
+                write_paths: [],
+                user_confirmed_full_access: false,
+                mad_sks_authorized: process.env.SKS_MAD_SKS_ACTIVE === '1'
+            },
+            mutationLedgerRoot: root,
+            reliabilityPolicy: {
+                maxEmptyResultRetries: 1,
+                timeoutClass: 'standard'
+            }
+        });
+        parsed = parseFinalResponse(codexTask.finalResponse);
+    }
+    catch (error) {
+        return finalize(root, input, policy, compressed, blockedResult('gpt_final_arbiter_unavailable', error instanceof Error ? error.message : String(error)), started, opts);
+    }
+    const normalized = normalizeGptFinalArbiterResult(parsed);
+    const validation = validateJsonSchemaRecursive(normalized, gptFinalArbiterResultSchema);
+    const taskBlockers = Array.isArray(codexTask?.blockers) ? codexTask.blockers.map(String) : [];
+    const result = {
+        ...normalized,
+        blockers: [
+            ...normalized.blockers,
+            ...(codexTask?.ok === true ? [] : ['gpt_final_arbiter_unavailable']),
+            ...taskBlockers,
+            ...(validation.ok ? [] : ['gpt_final_result_schema_invalid', ...validation.issues.map((issue) => `schema:${issue}`)])
+        ]
+    };
+    return finalize(root, input, policy, compressed, result, started, opts, codexTask);
+}
+function finalize(root, input, policy, compressed, result, started, opts, codexTask) {
+    const latencyMs = Math.max(0, Date.now() - started);
+    const gate = evaluateLocalCollaborationFinalGate({
+        policy,
+        localParticipated: true,
+        gptFinalStatus: result.status,
+        gptFinalAvailable: !result.blockers.includes('gpt_final_arbiter_unavailable'),
+        gptFinalBackend: codexTask ? 'codex-sdk' : null,
+        applyPatches: false
+    });
+    const artifact = {
+        schema: GPT_FINAL_ARBITER_RUN_SCHEMA,
+        generated_at: nowIso(),
+        ok: gate.ok && result.blockers.length === 0,
+        input_schema: input.schema || GPT_FINAL_ARBITER_INPUT_SCHEMA,
+        route: input.route,
+        mission_id: input.mission_id,
+        local_mode: policy.mode,
+        backend: codexTask ? 'codex-sdk' : 'unavailable',
+        backend_family: codexTask ? 'remote-gpt' : 'none',
+        local_outputs_count: Array.isArray(input.local_outputs) ? input.local_outputs.length : 0,
+        proof_pack: compressed.proof_pack,
+        latency_budget: {
+            ...compressed.latency_budget,
+            latency_ms: latencyMs
+        },
+        result,
+        final_gate: gate,
+        codex_task: codexTask ? {
+            ok: codexTask.ok === true,
+            sdk_thread_id: codexTask.sdkThreadId || null,
+            sdk_run_id: codexTask.sdkRunId || null,
+            stream_event_count: codexTask.streamEventCount || 0,
+            structured_output_valid: codexTask.structuredOutputValid === true,
+            worker_result_path: codexTask.workerResultPath || null,
+            blockers: codexTask.blockers || []
+        } : null,
+        blockers: [
+            ...result.blockers,
+            ...gate.blockers,
+            ...compressed.blockers
+        ]
+    };
+    artifact.ok = artifact.blockers.length === 0 && (result.status === 'approved' || result.status === 'modified');
+    if (opts.writeArtifact !== false)
+        return writeArtifact(root, artifact);
+    return artifact;
+}
+async function writeArtifact(root, artifact) {
+    await writeJsonAtomic(path.join(root, 'gpt-final-arbiter.json'), artifact);
+    return artifact;
+}
+function blockedResult(blocker, summary) {
+    return normalizeGptFinalArbiterResult({
+        status: 'needs_more_work',
+        summary,
+        blockers: [blocker],
+        confidence: 'low',
+        required_followup_work: [{ blocker }]
+    });
+}
+function parseFinalResponse(value) {
+    if (typeof value !== 'string')
+        return value || {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+}
+function buildArbiterPrompt(input, compressed) {
+    return [
+        'You are the GPT Final Arbiter for an SKS local collaboration run.',
+        'Local model outputs are drafts only. Review the proof pack, candidate diff, patch envelopes, verification results, side effects, mutation ledger, and rollback plan.',
+        'Approve or modify only when the candidate is safe and supported. Reject unsafe local patches. Return only the requested structured JSON schema.',
+        JSON.stringify({
+            route: input.route,
+            mission_id: input.mission_id,
+            local_mode: input.local_mode,
+            proof_pack: compressed.proof_pack
+        })
+    ].join('\n');
+}
+function safeName(value) {
+    return String(value || 'unknown').replace(/[^a-zA-Z0-9_.-]+/g, '-').slice(0, 80);
+}
+//# sourceMappingURL=gpt-final-arbiter.js.map

package/dist/core/codex-control/gpt-final-context-compressor.js

@@ -0,0 +1,17 @@
+import { buildGptFinalLatencyBudgetReport, buildGptFinalProofPack } from './gpt-final-proof-pack.js';
+export function compressGptFinalContext(input, opts = {}) {
+    const proofPack = buildGptFinalProofPack(input, opts);
+    const latencyBudget = buildGptFinalLatencyBudgetReport({
+        workerCount: proofPack.worker_count,
+        tokenBudgetEstimate: proofPack.token_budget_estimate,
+        latencyMs: opts.latencyMs ?? null
+    });
+    return {
+        schema: 'sks.gpt-final-context-compressor.v1',
+        ok: latencyBudget.ok,
+        proof_pack: proofPack,
+        latency_budget: latencyBudget,
+        blockers: latencyBudget.ok ? [] : ['gpt_final_context_budget_exceeded']
+    };
+}
+//# sourceMappingURL=gpt-final-context-compressor.js.map