sneakoscope 8.6.5 → 8.7.0

package/README.md

@@ -22,7 +22,7 @@ Proof-first orchestration for Codex CLI, ChatGPT Desktop, AI coding agents, mult
 Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-This README documents package **SKS 8.6.5** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
+This README documents package **SKS 8.7.0** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
 
 Use the official latest stable SKS and Codex CLI releases. The Codex compatibility SSOT is always the **current latest stable** host; capability probes measure what that host can actually do. Product docs do not crown a fixed `0.x.y` string as SSOT (release pins and schema directories are measured artifacts for the current package, not a permanent product version claim). Menu Bar / Center induce updates to the latest stable build. Run `sks update-check` for what is installed and read the capability report for what is supported. Install SSOT is npm `sneakoscope@latest`; PATH `sks` and Menu Bar stamped generation must match that version or gates fail. It resolves managed SKS skills from the authoritative global install, preserves a runnable Naruto child slot when `max_threads=2`, and keeps Menu Bar repair transactional so stamped generations remain verifiable. Naruto uses stable opt-in multi-agent V2 when the host exposes it (Codex official multi-agent wrap-only; SKS does not reimplement a parallel runtime). Local code search is mode-separated (`sks search files|text|structure|symbol|context`); `context` is answered by the compiled TriWiki Context Graph (`context-graph.json` is exhaustive authority; `context-pack.json` and managed `AGENTS.md` are bounded projections) — see [docs/architecture/context-graph.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/architecture/context-graph.md) and [docs/PRODUCT-CONTRACT.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/PRODUCT-CONTRACT.md). See [CHANGELOG.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/CHANGELOG.md).
 

package/config/skills-hash-ledger.v1.json

@@ -389,20 +389,6 @@
         "16b2b813d202ca51d2ea4fe0da918eddf9494db7ab1356352d4188a5da3496b1"
       ]
     },
-    {
-      "canonical_name": "sks-with-local-llm-off",
-      "trusted_sha256": [
-        "4609c43a671c649b2574aebf035e0e8200b29bb893d176567e92f14d2f3aa92c",
-        "86d3a860b438c91c2a5b4cc8ac9c8e7477008f9b689602ddcf14a9e3b759923d"
-      ]
-    },
-    {
-      "canonical_name": "sks-with-local-llm-on",
-      "trusted_sha256": [
-        "11da3f94d77b0f9fe76dee2e99d058cf1495fdc4eaf3e2fb6e43dae66f7d2cd3",
-        "27e1ff08b95428d6b623d06358d5d114ff02673a5c97d8f180dd75859682cd6c"
-      ]
-    },
     {
       "canonical_name": "sks-work",
       "trusted_sha256": [

package/crates/sks-core/Cargo.lock

@@ -259,7 +259,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "8.6.5"
+version = "8.7.0"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

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

package/dist/cli/command-manifest-lite.js

@@ -47,7 +47,6 @@ const COMMAND_MANIFEST_LITE_BASE = [
     { name: 'commit', summary: 'Create a simple git commit', maturity: 'stable' },
     { name: 'commit-and-push', summary: 'Create a simple git commit and push', maturity: 'stable' },
     { name: 'dfix', summary: 'Run DFix diagnose/plan/patch/verify loop', maturity: 'stable', mutatesRouteState: true },
-    { name: 'with-local-llm', summary: 'Enable or inspect local Ollama worker backend', maturity: 'beta' },
     { name: 'naruto', summary: 'Run the $sks-naruto Codex official subagent workflow', maturity: 'labs', mutatesRouteState: true },
     { name: 'stop-gate', summary: 'Check canonical stop-gate resolution for a route/mission', maturity: 'beta', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'route', summary: 'Inspect or close active route state', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },

package/dist/cli/command-registry.js

@@ -195,7 +195,6 @@ const COMMAND_DEFINITIONS = {
     commit: entry('stable', 'Create a simple git commit', 'dist/commands/commit.js', directCommand(() => import('../commands/commit.js'), 'dist/commands/commit.js')),
     'commit-and-push': entry('stable', 'Create a simple git commit and push', 'dist/commands/commit-and-push.js', directCommand(() => import('../commands/commit-and-push.js'), 'dist/commands/commit-and-push.js')),
     dfix: routeStateMutator(entry('stable', 'Run DFix diagnose/plan/patch/verify loop', 'dist/core/commands/dfix-command.js', commandArgsCommand(() => import('../core/commands/dfix-command.js'), 'dfixCommand', 'dist/core/commands/dfix-command.js')), ['dfix-gate.json']),
-    'with-local-llm': entry('beta', 'Enable or inspect local Ollama worker backend', 'dist/core/commands/local-model-command.js', argsCommand(() => import('../core/commands/local-model-command.js'), 'localModelCommand', 'dist/core/commands/local-model-command.js')),
     naruto: routeStateMutator(entry('labs', 'Run the $sks-naruto Codex official subagent workflow', 'dist/core/commands/naruto-command.js', argsCommand(() => import('../core/commands/naruto-command.js'), 'narutoCommand', 'dist/core/commands/naruto-command.js')), ['naruto-gate.json', 'stop-gate.json']),
     'stop-gate': readOnly(entry('beta', 'Check canonical stop-gate resolution for a route/mission', 'dist/core/commands/stop-gate-command.js', commandArgsCommand(() => import('../core/commands/stop-gate-command.js'), 'stopGateCommand', 'dist/core/commands/stop-gate-command.js'))),
     route: activeRouteDiagnostic(entry('beta', 'Inspect or close active route state', 'dist/core/commands/route-command.js', subcommand(() => import('../core/commands/route-command.js'), 'routeCommand', 'dist/core/commands/route-command.js', 'status'))),

package/dist/commands/doctor.js

@@ -15,7 +15,6 @@ import { inspectCodexConfigReadability } from '../core/codex/codex-config-readab
 import { inspectOAuthCallbackPortConflict, oauthCallbackDoctorGuidance } from '../core/codex/oauth-callback-port-diagnostic.js';
 import { inventoryCodexPermissionProfiles } from '../core/codex/codex-permission-profiles.js';
 import { resolveProviderContext } from '../core/provider/provider-context.js';
-import { readLocalModelConfig } from '../core/agents/ollama-worker-config.js';
 import { writeCodexCurrentAppCapabilityArtifacts } from '../core/codex-control/codex-current-app-capability.js';
 import { writeCodexPluginInventoryArtifacts, pluginAppTemplatePolicy } from '../core/codex-plugins/codex-plugin-json.js';
 import { writeMcpPluginInventoryArtifacts } from '../core/mcp/mcp-plugin-inventory.js';
@@ -59,6 +58,7 @@ export async function restartStaleDesktopBridgeRuntime(input) {
         ? { restarted: true, warnings: [`desktop_bridge_runtime_restarted:${running}:${PACKAGE_VERSION}`], blockers: [] }
         : { restarted: false, warnings: [], blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`] };
 }
+export const CATALOG_REPAIR_MAX_ATTEMPTS = 2;
 export function deferCommandAliasCleanupToMigrationReceipt(result) {
     const observedBlockers = Array.isArray(result?.blockers)
         ? result.blockers.map(String).filter(Boolean)
@@ -443,7 +443,6 @@ async function runDoctorJsonFastPath(args = [], root) {
         doctor_fix_transaction: null,
         doctor_fix_postcheck: null,
         postcheck: null,
-        local_model: null,
         agent_role_config: { schema: 'sks.agent-role-config-repair.v1', ok: true, apply: false, skipped: true, blockers: [] },
         codex_permission_profiles: { skipped: true, reason: 'doctor_json_fast_path_optional_diagnostics_skipped' },
         command_aliases: { schema: 'sks.command-alias-cleanup.v1', ok: true, skipped: true, reason: 'doctor_json_fast_path_no_write' },
@@ -668,7 +667,7 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
     const codexApp = deepDiagnostics
         ? await codexAppIntegrationStatus({ codex }).catch((err) => ({ ok: false, error: err.message }))
         : { ok: false, skipped: true, warnings: ['codex_app_optional_diagnostic_skipped'] };
-    const desktopBridge = await inspectDoctorDesktopBridgeStatus({
+    const desktopBridgeBeforeFix = await inspectDoctorDesktopBridgeStatus({
         processEnv: process.env
     }, { desktopBridgeStatusImpl: deps.desktopBridgeStatusImpl });
     const providerContext = deepDiagnostics
@@ -1033,11 +1032,12 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
                             rollback_evidence: 'combined_catalog_previous_generation_preserved'
                         };
                         try {
+                            const bridgeHome = path.resolve(process.env.HOME || os.homedir());
                             const restarted = await restartStaleDesktopBridgeRuntime({
-                                home: path.resolve(process.env.HOME || os.homedir()),
+                                home: bridgeHome,
                                 fix: doctorFix,
                             });
-                            const status = await desktopBridgeStatusV3({ home: root, env: process.env });
+                            const status = await desktopBridgeStatusV3({ home: bridgeHome, env: process.env });
                             const blockers = (status?.readiness?.blockers || []).map(String);
                             const stale = blockers.filter((blocker) => blocker.endsWith('_catalog_stale'));
                             if (!status?.management?.managed || stale.length === 0) {
@@ -1049,15 +1049,27 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
                                     blockers: restarted.blockers
                                 };
                             }
-                            const sync = await executeDesktopBridgeCommandV3({ operation: 'catalog.sync' }, { home: root, env: process.env });
-                            const synced = sync?.ok === true && sync?.execution?.ok === true;
+                            const attempts = [];
+                            let syncedAndVerified = false;
+                            for (let attempt = 1; attempt <= CATALOG_REPAIR_MAX_ATTEMPTS; attempt += 1) {
+                                const sync = await executeDesktopBridgeCommandV3({ operation: 'catalog.sync' }, { home: bridgeHome, env: process.env });
+                                const commandOk = sync?.ok === true && sync?.execution?.ok === true;
+                                const after = await desktopBridgeStatusV3({ home: bridgeHome, env: process.env });
+                                const stillStale = (after?.readiness?.blockers || [])
+                                    .map(String).filter((blocker) => blocker.endsWith('_catalog_stale'));
+                                if (commandOk && stillStale.length === 0) {
+                                    syncedAndVerified = true;
+                                    break;
+                                }
+                                attempts.push(`catalog_sync_attempt_${attempt}:${commandOk ? `still_stale:${stillStale.join(',')}` : (sync?.execution?.blockers || ['failed']).map(String).join(',')}`);
+                            }
                             return {
                                 ...base,
-                                ok: synced && restarted.blockers.length === 0,
-                                repaired: synced || restarted.restarted,
-                                warnings: restarted.warnings,
+                                ok: syncedAndVerified && restarted.blockers.length === 0,
+                                repaired: syncedAndVerified || restarted.restarted,
+                                warnings: [...restarted.warnings, ...(syncedAndVerified ? attempts : [])],
                                 blockers: [
-                                    ...(synced ? [] : (sync?.execution?.blockers || ['desktop_bridge_catalog_sync_failed']).map(String)),
+                                    ...(syncedAndVerified ? [] : ['desktop_bridge_catalog_still_stale_after_repair', ...attempts]),
                                     ...restarted.blockers
                                 ]
                             };
@@ -1092,7 +1104,11 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
         }))
         : null;
     const doctorFixPostcheck = doctorFix ? (await import('../core/doctor/doctor-repair-postcheck.js')).doctorRepairPostcheck(doctorFixTransaction) : null;
-    const localModel = await readLocalModelConfig().catch(() => null);
+    const desktopBridge = doctorFixTransaction
+        ? await inspectDoctorDesktopBridgeStatus({
+            processEnv: process.env
+        }, { desktopBridgeStatusImpl: deps.desktopBridgeStatusImpl })
+        : desktopBridgeBeforeFix;
     const permissionProfiles = await inventoryCodexPermissionProfiles(root, { writeReport: true });
     const startupRoleRepair = startupConfigRepair?.role_repair;
     const agentRoleConfigRepair = doctorFix && startupRoleRepair
@@ -1355,7 +1371,6 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
         require_legacy_global_hook_cleanup: requireLegacyGlobalHookCleanup,
         require_legacy_generation_convergence: doctorFix && !migrationReceiptOwnsReconcile,
         skills: skillsReconcile,
-        local_model: localModel,
         agent_role_config: agentRoleConfigRepair,
         repair: configRepair,
         codex_app_ui: codexAppUi,
@@ -1532,7 +1547,6 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
             required_blockers: doctorFixPostcheck.required_blockers || [],
             optional_warnings: doctorFixPostcheck.optional_warnings || []
         } : null,
-        local_model: localModel,
         agent_role_config: agentRoleConfigRepair,
         official_subagent_config: officialSubagentConfig,
         codex_permission_profiles: permissionProfiles,
@@ -1790,16 +1804,6 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
     if (!desktopBridge.ok)
         for (const action of desktopBridge.recovery_actions || [])
             console.log(`  action: ${action}`);
-    if (localModel) {
-        console.log('Local LLM:');
-        console.log(`  enabled: ${localModel.enabled ? 'yes' : 'no'}`);
-        console.log(`  status: ${localModel.status}`);
-        console.log(`  provider: ${localModel.provider}`);
-        console.log(`  model: ${localModel.model}`);
-        console.log(`  endpoint: ${localModel.base_url}`);
-        console.log(`  last smoke: ${localModel.last_smoke?.ok ? `ok ${localModel.last_smoke.latency_ms || 0}ms ${localModel.last_smoke.tokens_per_second || 0} tok/s` : 'missing'}`);
-        console.log('  final arbiter: GPT required');
-    }
     console.log(`Permissions: config profile and permission profile are tracked separately (${permissionProfiles.codex_config_profile_field}, ${permissionProfiles.codex_permission_profile_field})`);
     console.log('Ready:');
     console.log(`  cli_ready: ${ready.cli_ready ? 'yes' : 'no'}`);

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "8.6.5",
+  "package_version": "8.7.0",
   "skills": [
     {
       "canonical_name": "sks",
@@ -485,24 +485,6 @@
       ],
       "deprecated_aliases": []
     },
-    {
-      "canonical_name": "sks-with-local-llm-off",
-      "type": "official",
-      "content_sha256": "4609c43a671c649b2574aebf035e0e8200b29bb893d176567e92f14d2f3aa92c",
-      "hash_history": [
-        "86d3a860b438c91c2a5b4cc8ac9c8e7477008f9b689602ddcf14a9e3b759923d"
-      ],
-      "deprecated_aliases": []
-    },
-    {
-      "canonical_name": "sks-with-local-llm-on",
-      "type": "official",
-      "content_sha256": "11da3f94d77b0f9fe76dee2e99d058cf1495fdc4eaf3e2fb6e43dae66f7d2cd3",
-      "hash_history": [
-        "27e1ff08b95428d6b623d06358d5d114ff02673a5c97d8f180dd75859682cd6c"
-      ],
-      "deprecated_aliases": []
-    },
     {
       "canonical_name": "sks-work",
       "type": "official",

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

@@ -43,7 +43,6 @@ import { createNativeCliWorkerRuntimeRecorder } from './native-cli-worker-runtim
 import { writeNativeCliWorkerRuntimeProof } from './native-cli-worker-runtime-proof.js';
 import { writeNoSubagentScalingPolicy } from './no-subagent-scaling-policy.js';
 import { writeOfficialSubagentHelperPolicy } from './official-subagent-helper-policy.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';
 import { allocateWorkerWorktree, allocateWorkerWorktreesBatch } from '../git/git-worktree-manager.js';
@@ -334,7 +333,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         targetActiveSlots,
         backend,
         backendExplicit: opts.backendExplicit === true,
-        noOllama: opts.noOllama === true,
         route,
         fastModePolicy,
         projectRoot: root
@@ -496,20 +494,16 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const officialSubagentHelperPolicy = await writeOfficialSubagentHelperPolicy(ledgerRoot, { nativeProof: nativeCliWorkerRuntimeProof });
     const noSubagentScalingPolicy = await writeNoSubagentScalingPolicy(ledgerRoot, { nativeProof: nativeCliWorkerRuntimeProof, officialSubagentHelperPolicy });
     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 worktreeParticipated = candidatePatchEnvelopes.some((envelope) => envelope?.source === 'git-worktree-diff' || envelope?.git_worktree?.worktree_path)
         || results.some((result) => result?.git_worktree_diff || result?.git_worktree_checkpoint);
-    const gptFinalRequired = localParticipated || worktreeParticipated;
+    const gptFinalRequired = worktreeParticipated;
     const gptFinalArbiter = gptFinalRequired
         ? await runFinalGptReviewStage({
             schema: 'sks.gpt-final-arbiter-input.v1',
             route,
             mission_id: missionId,
-            local_mode: localCollaborationPolicy.mode,
-            local_outputs: results.map((result) => ({
+            candidate_outputs: results.map((result) => ({
                 worker_id: result.agent_id,
                 backend: result.backend_router_report?.selected_backend || result.backend || backend,
                 status: result.status,
@@ -607,7 +601,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         gitWorktreeRuntime,
         triwikiContext,
         selectedCoreSkill,
-        localCollaborationPolicy,
         gptFinalArbiter,
         finalGptPatchStage
     });
@@ -651,7 +644,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         fast_mode_policy: fastModePolicy,
         fast_mode_propagation: fastModePropagation,
         git_worktree_runtime: gitWorktreeRuntime,
-        local_collaboration_policy: localCollaborationPolicy,
         gpt_final_arbiter: gptFinalArbiter,
         final_gpt_patch_stage: finalGptPatchStage,
         patch_handoff: patchHandoff,
@@ -1089,7 +1081,7 @@ function sameTournamentGroupEntry(a, b) {
 function attachNarutoRuntimeProof(result, agent, slice) {
     const controlPlane = result?.codex_child_report || result?.codex_sdk_thread || result?.backend_router_report || null;
     const selectedBackend = String(result?.backend_router_report?.selected_backend || result?.backend || '');
-    const actualWorkerControlPlane = selectedBackend === 'codex-sdk' || selectedBackend === 'local-llm'
+    const actualWorkerControlPlane = selectedBackend === 'codex-sdk'
         ? Boolean(controlPlane?.sdk_thread_id || controlPlane?.worker_result_path || result?.codex_child_report?.worker_result_path)
         : false;
     result.naruto_runtime = {

package/dist/core/agents/agent-output-validator.js

@@ -34,7 +34,7 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
         task_slice_id: { type: 'string' },
         work_item_kind: { type: 'string' },
         status: { enum: ['done', 'blocked', 'failed'] },
-        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk', 'ollama', 'local-llm'] },
+        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk'] },
         summary: { type: 'string' },
         findings: { type: 'array', items: { type: 'string' } },
         proposed_changes: { type: 'array', items: { type: 'string' } },
@@ -93,7 +93,6 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
                     worker_process_id: { type: 'number' },
                     backend_child_process_id: { type: 'number' },
                     backend_sdk_thread_id: { type: 'string' },
-                    backend_ollama_request_id: { type: 'string' },
                     fast_mode: { type: 'boolean' },
                     service_tier: { enum: ['fast', 'standard'] },
                     lease_id: { type: 'string' },

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

@@ -17,7 +17,6 @@ export function normalizeAgentPatchEnvelope(input) {
         ...(hasFiniteNumber(input?.worker_process_id) ? { worker_process_id: Number(input.worker_process_id) } : {}),
         ...(hasFiniteNumber(input?.backend_child_process_id) ? { backend_child_process_id: Number(input.backend_child_process_id) } : {}),
         ...(input?.backend_sdk_thread_id ? { backend_sdk_thread_id: String(input.backend_sdk_thread_id) } : {}),
-        ...(input?.backend_ollama_request_id ? { backend_ollama_request_id: String(input.backend_ollama_request_id) } : {}),
         ...(input?.fast_mode === undefined ? {} : { fast_mode: Boolean(input.fast_mode) }),
         ...(input?.service_tier === 'fast' || input?.service_tier === 'standard' ? { service_tier: input.service_tier } : {}),
         ...(input?.lease_id ? { lease_id: String(input.lease_id) } : {}),
@@ -57,7 +56,7 @@ export function validateAgentPatchEnvelope(envelope) {
         violations.push('operations_missing');
     if (envelope.source && !['fixture', 'model_authored', 'process_generated', 'git-worktree-diff'].includes(envelope.source))
         violations.push('source_invalid');
-    if (envelope.source === 'model_authored' && !hasFiniteNumber(envelope.backend_child_process_id) && !envelope.backend_sdk_thread_id && !envelope.backend_ollama_request_id)
+    if (envelope.source === 'model_authored' && !hasFiniteNumber(envelope.backend_child_process_id) && !envelope.backend_sdk_thread_id)
         violations.push('model_authored_backend_proof_missing');
     if (envelope.source === 'fixture' && envelope.backend_child_process_id !== undefined)
         violations.push('fixture_backend_child_process_id_present');

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

@@ -7,7 +7,8 @@ import { assertAgentTerminalSessionsClosed } from './agent-terminal-session.js';
 import { assertAgentSessionGenerationsClosed } from './agent-session-generation.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';
+import { evaluateGptFinalGate } from '../codex-control/gpt-final-gate.js';
+import { gptFinalRequiredForPipeline } from '../pipeline/gpt-final-required.js';
 export async function writeAgentProofEvidence(root, input) {
     const lifecycle = await assertAllAgentSessionsClosed(root);
     const terminal = await assertAgentTerminalSessionsClosed(root);
@@ -26,22 +27,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 patchHandoff = input.patchHandoff || await readJson(path.join(root, 'agent-patch-handoff-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 narutoWorkGraph = await readJson(path.join(root, 'naruto-work-graph.json'), null);
     const narutoRoleDistribution = await readJson(path.join(root, 'naruto-role-distribution.json'), null);
     const narutoConcurrencyGovernor = await readJson(path.join(root, 'naruto-concurrency-governor.json'), null);
     const narutoActivePool = await readJson(path.join(root, 'naruto-active-pool.json'), null);
     const narutoVerificationDag = await readJson(path.join(root, 'naruto-verification-dag.json'), null);
-    const localParticipated = localCollaborationParticipated(input.results || []) || Number(gptFinalArbiter?.local_outputs_count || 0) > 0;
+    const gptFinalRequired = gptFinalRequiredForPipeline({ candidateResults: input.results || [] }).gpt_final_required;
     const finalGptPatchStage = input.finalGptPatchStage || null;
-    const localFinalGate = gptFinalArbiter?.final_gate || evaluateLocalCollaborationFinalGate({
-        policy: localCollaborationPolicy,
-        localParticipated,
+    const gptFinalGate = gptFinalArbiter?.final_gate || evaluateGptFinalGate({
+        required: gptFinalRequired,
         gptFinalStatus: gptFinalArbiter?.result?.status || null,
-        gptFinalAvailable: Boolean(gptFinalArbiter),
-        gptFinalBackend: gptFinalArbiter?.backend || null,
-        applyPatches: parallelWritePolicy?.apply_patches === true
+        gptFinalAvailable: Boolean(gptFinalArbiter)
     });
     const nativeCliWorkerRuntimeProof = input.nativeCliWorkerRuntimeProof || await readJson(path.join(root, 'native-cli-worker-runtime-proof.json'), null);
     const noSubagentScalingPolicy = input.noSubagentScalingPolicy || await readJson(path.join(root, 'no-subagent-scaling-policy.json'), null);
@@ -173,9 +170,9 @@ export async function writeAgentProofEvidence(root, input) {
         ...(patchHandoff && !patchApplyOk ? ['patch_apply_not_ok'] : []),
         ...(patchHandoff && !patchVerificationOk ? ['patch_verification_not_ok'] : []),
         ...(patchHandoff && !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'] : []),
+        ...(gptFinalRequired && gptFinalGate.ok !== true ? gptFinalGate.blockers || ['gpt_final_arbiter_gate_not_ok'] : []),
+        ...(gptFinalRequired && gptFinalArbiter?.ok !== true ? gptFinalArbiter?.blockers || ['gpt_final_arbiter_not_ok'] : []),
+        ...(gptFinalRequired && finalGptPatchStage?.ok === false ? finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
         ...(isNarutoRoute && !narutoWorkGraph ? ['naruto_work_graph_missing'] : []),
         ...(isNarutoRoute && narutoWorkGraph?.ok === false ? narutoWorkGraph.blockers || ['naruto_work_graph_not_ok'] : []),
         ...(isNarutoRoute && !narutoRoleDistribution ? ['naruto_role_distribution_missing'] : []),
@@ -236,15 +233,13 @@ 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_required: gptFinalRequired,
+        gpt_final_status: gptFinalArbiter?.result?.status || (gptFinalRequired ? 'missing' : 'not_required_no_worktree_candidates'),
         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,
+        gpt_final_patch_source: finalGptPatchStage?.final_patch_source || (gptFinalRequired ? 'blocked' : 'not_applicable'),
+        gpt_final_gate_ok: gptFinalGate.ok === true,
+        gpt_final_gate: gptFinalGate,
         naruto_work_graph: narutoWorkGraph ? 'naruto-work-graph.json' : null,
         naruto_total_work_items: Number(narutoWorkGraph?.total_work_items || 0),
         naruto_mixed_work_kinds: narutoWorkGraph?.mixed_work_kinds || [],

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

@@ -399,7 +399,7 @@ function transcriptGroupForChannel(channel) {
 function isWorkerExecutionSurface(rel, channel) {
     if (channel === 'stdout' || channel === 'stderr' || channel === 'agent_result')
         return true;
-    return /(?:^|\/)agent-worker-pipeline\.(?:ts|mjs|js)$/.test(rel) || /(?:^|\/)agent-runner-(?:process|ollama)\.(?:ts|mjs|js)$/.test(rel);
+    return /(?:^|\/)agent-worker-pipeline\.(?:ts|mjs|js)$/.test(rel) || /(?:^|\/)agent-runner-process\.(?:ts|mjs|js)$/.test(rel);
 }
 function classifyNonRecursivePipelinePath(file) {
     const normalized = normalizePath(file);

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

@@ -12,7 +12,7 @@ export const OFFICIAL_SUBAGENT_EXECUTION_STAGE_ID = 'official_subagent_execution
 export const MAX_AGENT_COUNT = 20;
 export const DEFAULT_AGENT_CONCURRENCY = DEFAULT_NARUTO_MAX_THREADS;
 export const HARD_AGENT_CONCURRENCY = HARD_NARUTO_MAX_THREADS;
-export const AGENT_BACKENDS = ['fake', 'process', 'codex-sdk', 'ollama', 'local-llm'];
+export const AGENT_BACKENDS = ['fake', 'process', 'codex-sdk'];
 export function normalizeAgentBackend(input) {
     const value = String(input || 'codex-sdk');
     return AGENT_BACKENDS.includes(value) ? value : null;

package/dist/core/agents/native-cli-worker-runtime.js

@@ -45,7 +45,6 @@ class NativeCliWorkerRuntimeRecorder {
             route: this.input.route,
             backend: this.input.backend,
             backend_explicit: this.input.backendExplicit === true,
-            no_ollama: this.input.noOllama === true || ctx.opts.noOllama === true,
             agent_root: this.root,
             main_repo_root: worktree?.main_repo_root || ctx.opts.cwd || packageRoot(),
             cwd: workerCwd,
@@ -58,9 +57,6 @@ class NativeCliWorkerRuntimeRecorder {
             patch_envelope_path: patchRel,
             service_tier: this.input.fastModePolicy.service_tier,
             fast_mode: this.input.fastModePolicy.fast_mode,
-            ollama_enabled: ctx.opts.ollamaEnabled === true || this.input.backend === 'ollama' || this.input.backend === 'local-llm',
-            ollama_model: ctx.opts.ollamaModel || null,
-            ollama_base_url: ctx.opts.ollamaBaseUrl || null,
             source_intelligence_refs: ctx.agent.source_intelligence_refs || null,
             goal_mode_ref: ctx.agent.goal_mode_ref || null,
             strategy_refs: ctx.slice?.strategy_refs || null,

package/dist/core/agents/native-cli-worker.js

@@ -206,7 +206,7 @@ export async function runNativeCliWorker(input = {}) {
         structured_output_valid: routed.report?.structured_output_valid === true,
         backend_router_report: routed.report,
         backend_child_process_ids: routed.report.child_process_ids,
-        backend_child_execution: routed.report.child_process_ids.length > 0 || Boolean(routed.report?.sdk_thread_id) || backend === 'fake' || backend === 'ollama',
+        backend_child_execution: routed.report.child_process_ids.length > 0 || Boolean(routed.report?.sdk_thread_id) || backend === 'fake',
         recursion_guard_env: process.env.SKS_DISABLE_ROUTE_RECURSION === '1',
         worker_env: process.env.SKS_AGENT_WORKER === '1',
         fast_mode_report: {

package/dist/core/agents/native-worker-backend-router.js

@@ -2,8 +2,6 @@ import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { buildFixturePatchEnvelopes } from './agent-runner-fake.js';
 import { runProcessAgent } from './agent-runner-process.js';
-import { classifyOllamaWorkerSlice, runOllamaAgent } from './agent-runner-ollama.js';
-import { resolveOllamaWorkerConfig } from './ollama-worker-config.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { normalizeAgentPatchEnvelope } from './agent-patch-schema.js';
 import { runCodexTask } from '../codex-control/codex-control-plane.js';
@@ -19,7 +17,6 @@ export async function runNativeWorkerBackendRouter(input) {
     const pathRoot = path.resolve(input.intake?.cwd || input.intake?.projectRoot || input.agentRoot);
     const requestedBackend = String(input.backend || '');
     let backend = normalizeBackend(requestedBackend);
-    backend = await maybeAutoSelectOllamaBackend(backend, input);
     const narutoRequest = isNarutoWorkerRequest(input);
     const reportRel = path.join(input.workerDirRel, 'worker-backend-router-report.json');
     const startedAt = nowIso();
@@ -74,31 +71,7 @@ export async function runNativeWorkerBackendRouter(input) {
             verification: { status: processRun.status === 'done' ? 'passed' : 'failed', checks: [...(processRun.verification?.checks || []), 'native-worker-backend-router', 'process-child-execution'] }
         });
     }
-    else if (backend === 'ollama') {
-        const ollamaRun = await runOllamaAgent(input.agent, input.slice, {
-            ...input.intake,
-            missionId: input.intake.mission_id || input.intake.parent_mission_id || '',
-            agentRoot: root,
-            workerDirRel: input.workerDirRel,
-            cwd: input.intake.cwd || root,
-            route: input.intake.route || '$Naruto',
-            fastMode: input.fastModePolicy.fast_mode,
-            serviceTier: input.fastModePolicy.service_tier
-        });
-        patchEnvelopes = Array.isArray(ollamaRun.patch_envelopes) ? ollamaRun.patch_envelopes : [];
-        proofLevel = ollamaRun.status === 'done' ? (patchEnvelopes.length ? 'model_authored' : 'ollama_worker_proven') : 'blocked';
-        result = validateAgentWorkerResult({
-            ...ollamaRun,
-            backend: 'ollama',
-            patch_envelopes: patchEnvelopes,
-            ...(patchEnvelopes.length ? {} : { no_patch_reason: buildNoPatchReason(input, backend) }),
-            model_authored_patch_envelopes: patchEnvelopes.length > 0,
-            fixture_patch_envelopes: false,
-            verification: { status: ollamaRun.status === 'done' ? 'passed' : 'failed', checks: [...(ollamaRun.verification?.checks || []), 'native-worker-backend-router', 'ollama-api-generate'] }
-        });
-    }
-    else if (backend === 'codex-sdk' || backend === 'local-llm') {
-        const localPreferred = backend === 'local-llm';
+    else if (backend === 'codex-sdk') {
         modelRouting = await resolveWorkerModelRouting(input);
         if (modelRouting.blockers.length) {
             proofLevel = 'blocked';
@@ -135,12 +108,7 @@ export async function runNativeWorkerBackendRouter(input) {
                     user_confirmed_full_access: false,
                     mad_sks_authorized: input.intake.mad_sks_authorized === true || process.env.SKS_MAD_SKS_ACTIVE === '1'
                 },
-                backendPreference: localPreferred ? ['local-llm', 'codex-sdk'] : ['codex-sdk'],
-                allowLocalLlm: localPreferred,
-                ...(localPreferred ? { localLlmPolicy: {
-                        mode: 'local_preferred',
-                        requiresGptFinal: true
-                    } } : {}),
+                backendPreference: ['codex-sdk'],
                 mutationLedgerRoot: path.join(root, input.workerDirRel),
                 reliabilityPolicy: {
                     maxEmptyResultRetries: 1,
@@ -150,14 +118,13 @@ export async function runNativeWorkerBackendRouter(input) {
             outputLastMessagePath = sdkTask.workerResultPath;
             const sdkWorkerResult = normalizeSdkWorkerResultPaths(await readJson(sdkTask.workerResultPath, null), input, pathRoot);
             patchEnvelopes = normalizeSdkPatchEnvelopes(sdkWorkerResult?.patch_envelopes || [], input, sdkTask.sdkThreadId, pathRoot);
-            proofLevel = sdkTask.ok ? (patchEnvelopes.length ? 'model_authored' : sdkTask.backend === 'local-llm' ? 'local_llm_worker_proven' : 'codex_sdk_thread_proven') : 'blocked';
+            proofLevel = sdkTask.ok ? (patchEnvelopes.length ? 'model_authored' : 'codex_sdk_thread_proven') : 'blocked';
             const sdkReport = {
                 schema: 'sks.codex-sdk-worker-adapter.v1',
                 backend: sdkTask.backend,
                 backend_family: sdkTask.backend_family,
                 sdk_thread_id: sdkTask.sdkThreadId,
                 sdk_run_id: sdkTask.sdkRunId,
-                local_llm_proof_path: sdkTask.localLlmProofPath || null,
                 stream_event_count: sdkTask.streamEventCount,
                 structured_output_valid: sdkTask.structuredOutputValid,
                 worker_result_path: sdkTask.workerResultPath,
@@ -175,7 +142,7 @@ export async function runNativeWorkerBackendRouter(input) {
                 session_id: input.agent.session_id,
                 persona_id: input.agent.persona_id || input.agent.id,
                 task_slice_id: input.slice?.id || '',
-                backend: sdkTask.backend === 'local-llm' ? 'local-llm' : 'codex-sdk',
+                backend: 'codex-sdk',
                 patch_envelopes: patchEnvelopes,
                 ...(patchEnvelopes.length ? {} : { no_patch_reason: buildNoPatchReason(input, sdkTask.backend || backend) }),
                 codex_child_report: sdkReport,
@@ -187,18 +154,16 @@ export async function runNativeWorkerBackendRouter(input) {
                         path.relative(root, sdkTask.workerResultPath),
                         path.join(input.workerDirRel, 'codex-control-proof.json'),
                         path.join(input.workerDirRel, 'codex-thread-registry.json'),
-                        sdkTask.backend === 'local-llm' ? path.join(input.workerDirRel, 'local-llm-events.jsonl') : path.join(input.workerDirRel, 'codex-sdk-events.jsonl'),
-                        ...(sdkTask.localLlmProofPath ? [path.relative(root, sdkTask.localLlmProofPath)] : [])
+                        path.join(input.workerDirRel, 'codex-sdk-events.jsonl')
                     ])],
                 blockers: [...(sdkWorkerResult?.blockers || []), ...sdkTask.blockers],
                 verification: {
                     status: sdkTask.ok ? 'passed' : 'failed',
                     checks: [
                         ...(sdkWorkerResult?.verification?.checks || []),
-                        sdkTask.backend === 'local-llm' ? 'local-llm-control-plane' : 'codex-sdk-control-plane',
-                        sdkTask.backend === 'local-llm' ? 'local-llm-event-stream' : 'codex-sdk-event-stream',
-                        sdkTask.backend === 'local-llm' ? 'local-llm-structured-output' : 'codex-sdk-structured-output',
-                        ...(sdkTask.backend === 'local-llm' ? ['gpt-final-required-before-acceptance'] : [])
+                        'codex-sdk-control-plane',
+                        'codex-sdk-event-stream',
+                        'codex-sdk-structured-output'
                     ]
                 }
             });
@@ -232,7 +197,6 @@ export async function runNativeWorkerBackendRouter(input) {
         sdk_run_id: childReports.find((report) => report?.sdk_run_id)?.sdk_run_id || null,
         stream_event_count: Number(childReports.find((report) => report?.stream_event_count)?.stream_event_count || 0),
         structured_output_valid: childReports.some((report) => report?.structured_output_valid === true),
-        ollama_request_ids: patchEnvelopes.map((envelope) => envelope.backend_ollama_request_id).filter(Boolean),
         blockers: result.blockers || []
     };
     await writeJsonAtomic(path.join(root, reportRel), report);
@@ -348,23 +312,6 @@ function normalizeServiceTier(value) {
     const text = String(value || '').toLowerCase();
     return text === 'standard' ? 'standard' : text === 'fast' || text === 'priority' ? 'fast' : null;
 }
-async function maybeAutoSelectOllamaBackend(backend, input) {
-    if (backend !== 'codex-sdk')
-        return backend;
-    if (isNarutoWorkerRequest(input))
-        return backend;
-    if (input.intake?.backend_explicit === true || input.intake?.no_ollama === true)
-        return backend;
-    const config = await resolveOllamaWorkerConfig({
-        ollamaEnabled: input.intake?.ollama_enabled === true,
-        model: input.intake?.ollama_model || null,
-        baseUrl: input.intake?.ollama_base_url || null
-    }).catch(() => null);
-    if (!config?.ok || config.enabled !== true || config.status !== 'verified')
-        return backend;
-    const policy = classifyOllamaWorkerSlice(input.slice, { route: input.intake?.route, agent: input.agent });
-    return policy.ok ? 'local-llm' : backend;
-}
 function isNarutoWorkerRequest(input) {
     return Boolean(input.agent?.naruto_role) || /\$?naruto/i.test(String(input.intake?.route || ''));
 }
@@ -373,12 +320,10 @@ export function narutoWorkerBackendBlocker(backend, narutoRequest = true) {
         return null;
     if (backend === 'process')
         return 'naruto_gpt_5_6_family_only_process_backend_forbidden';
-    if (backend === 'ollama' || backend === 'local-llm')
-        return 'naruto_gpt_5_6_family_only_local_backend_forbidden';
     return null;
 }
 function normalizeBackend(value) {
-    return value === 'fake' || value === 'process' || value === 'codex-sdk' || value === 'ollama' || value === 'local-llm' ? value : null;
+    return value === 'fake' || value === 'process' || value === 'codex-sdk' ? value : null;
 }
 function envelopeOpts(input, source, childPid) {
     return {

package/dist/core/codex-control/codex-control-proof.js

@@ -23,7 +23,6 @@ export async function writeCodexControlProof(root, input) {
         output_schema_id: input.task.outputSchemaId,
         worker_result_path: input.result.workerResultPath,
         patch_envelope_path: input.result.patchEnvelopePath || null,
-        local_llm_proof_path: input.result.localLlmProofPath || null,
         python_sdk_proof_path: input.result.pythonSdkProofPath || null,
         sandbox: input.sandbox || null,
         env: input.envProof || null,