sneakoscope 6.0.2 → 6.0.3

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

@@ -151,8 +151,8 @@ export function buildNarutoCloneRoster(opts = {}) {
         const cloneReadonly = readonly || !writeAllowed;
         const role = mapNarutoRoleToAgentRole(narutoRole);
         const allowedTools = writeAllowed ? ['read', 'search', 'edit', 'test'] : narutoRole === 'verifier' ? ['read', 'search', 'test'] : ['read', 'search'];
-        // Dynamic per-clone effort like team mode, capped at low/medium and always fast.
-        const effort = decideNarutoCloneEffort({ persona: { ...base, role, allowed_tools: allowedTools, read_only: cloneReadonly, write_policy: writeAllowed ? 'exclusive Naruto patch-envelope lease required' : 'read-only Naruto role' }, prompt: opts.prompt || '', agentId: id, readonly: cloneReadonly });
+        // Dynamic Naruto-only GPT-5.6 model/effort policy; there is no legacy low/medium cap.
+        const effort = decideNarutoCloneEffort({ persona: { ...base, role, naruto_role: narutoRole, allowed_tools: allowedTools, read_only: cloneReadonly, write_policy: writeAllowed ? 'exclusive Naruto patch-envelope lease required' : 'read-only Naruto role' }, prompt: opts.prompt || '', agentId: id, readonly: cloneReadonly });
         const persona = {
             ...base,
             id,

package/dist/core/agents/native-cli-session-swarm.js

@@ -13,6 +13,7 @@ import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
 import { appendAgentMessage } from './agent-message-bus.js';
 import { markLoopWorkerInterrupted, registerLoopActiveWorker } from '../loops/loop-interrupt-registry.js';
+import { readCodexLbModelCatalog } from '../codex-lb/codex-lb-env.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -26,11 +27,26 @@ class NativeCliSessionSwarmRecorder {
     writeLock = Promise.resolve();
     nextPaneToken = -1;
     visibleZellijReservations = new Set();
+    narutoModelCatalog = null;
     constructor(root, input) {
         this.root = root;
         this.input = input;
     }
     async initialize() {
+        if (/\$?naruto/i.test(this.input.route) && (this.input.backend === 'codex-sdk' || this.input.backend === 'zellij')) {
+            this.narutoModelCatalog = await readCodexLbModelCatalog().catch(() => ({
+                schema: 'sks.codex-lb-model-catalog.v1',
+                ok: false,
+                status: 'blocked',
+                models: [],
+                model_efforts: {},
+                blockers: ['codex_lb_model_catalog_unavailable']
+            }));
+            if (this.narutoModelCatalog?.ok !== true) {
+                const blockers = Array.isArray(this.narutoModelCatalog?.blockers) ? this.narutoModelCatalog.blockers.join(',') : 'unavailable';
+                throw new Error(`naruto_model_catalog_preflight_failed:${blockers}`);
+            }
+        }
         await this.persist();
     }
     async launchWorker(ctx) {
@@ -72,7 +88,8 @@ class NativeCliSessionSwarmRecorder {
             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,
-            recursion_guard_env: true
+            recursion_guard_env: true,
+            naruto_model_catalog: this.narutoModelCatalog
         };
         await writeJsonAtomic(path.join(this.root, intakeRel), intake);
         const cliPath = await resolveWorkerCliPath();

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

@@ -10,8 +10,8 @@ import { normalizeAgentPatchEnvelope } from './agent-patch-schema.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 { leanEngineeringCompactText, leanPolicyReference } from '../lean-engineering-policy.js';
-import { readLbHealth } from '../codex-lb/codex-lb-env.js';
-import { categoryForWorkerRole, modelRouteReason, routeModel } from '../provider/model-router.js';
+import { readCodexLbModelCatalog, readLbHealth } from '../codex-lb/codex-lb-env.js';
+import { categoryForWorkerRole, isNarutoGpt56Model, modelRouteReason, routeModel } from '../provider/model-router.js';
 export const NATIVE_WORKER_BACKEND_ROUTER_SCHEMA = 'sks.native-worker-backend-router.v1';
 export async function runNativeWorkerBackendRouter(input) {
     const root = path.resolve(input.agentRoot);
@@ -19,6 +19,7 @@ export async function runNativeWorkerBackendRouter(input) {
     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();
     let result;
@@ -27,7 +28,12 @@ export async function runNativeWorkerBackendRouter(input) {
     let proofLevel = 'blocked';
     let outputLastMessagePath = null;
     let modelRouting = null;
-    if (!input.guard?.ok) {
+    const narutoBackendBlocker = narutoWorkerBackendBlocker(backend, narutoRequest);
+    if (narutoBackendBlocker) {
+        const blocker = narutoBackendBlocker;
+        result = validateAgentWorkerResult(blockedResult(input, [blocker]));
+    }
+    else if (!input.guard?.ok) {
         result = validateAgentWorkerResult(blockedResult(input, ['native_cli_worker_recursion_guard_missing']));
     }
     else if (requestedBackend === 'codex-exec') {
@@ -96,104 +102,110 @@ export async function runNativeWorkerBackendRouter(input) {
     else if (backend === 'codex-sdk' || backend === 'zellij' || backend === 'local-llm') {
         const localPreferred = backend === 'local-llm';
         modelRouting = await resolveWorkerModelRouting(input);
-        const sdkTask = await runCodexTask({
-            route: String(input.intake.route || '$Agent'),
-            tier: 'worker',
-            missionId: String(input.intake.mission_id || input.intake.parent_mission_id || ''),
-            workItemId: String(input.slice?.id || ''),
-            slotId: String(input.agent.slot_id || input.agent.id || ''),
-            generationIndex: Number(input.agent.generation_index || 1),
-            sessionId: String(input.agent.session_id || ''),
-            cwd: String(input.intake.cwd || root),
-            prompt: buildWorkerPrompt(input.slice),
-            model: modelRouting.choice.model,
-            reasoningEffort: modelRouting.choice.reasoning,
-            modelReasoningEffort: modelRouting.choice.reasoning,
-            serviceTier: modelRouting.choice.serviceTier,
-            inputFiles: input.intake.input_files || [],
-            inputImages: input.intake.input_images || [],
-            outputSchemaId: CODEX_AGENT_WORKER_RESULT_SCHEMA_ID,
-            outputSchema: codexAgentWorkerResultSchema,
-            sandboxPolicy: hasWriteLease(input.slice, input.intake) ? 'workspace-write' : 'read-only',
-            requestedScopeContract: {
-                id: String(input.intake.lease_id || input.slice?.id || ''),
+        if (modelRouting.blockers.length) {
+            proofLevel = 'blocked';
+            result = validateAgentWorkerResult(blockedResult(input, modelRouting.blockers));
+        }
+        else {
+            const sdkTask = await runCodexTask({
                 route: String(input.intake.route || '$Agent'),
-                read_only: !hasWriteLease(input.slice, input.intake),
-                allowed_paths: writePaths(input.slice, input.intake),
-                write_paths: writePaths(input.slice, input.intake),
-                model_route_reason: modelRouting.reason,
+                tier: 'worker',
+                missionId: String(input.intake.mission_id || input.intake.parent_mission_id || ''),
+                workItemId: String(input.slice?.id || ''),
+                slotId: String(input.agent.slot_id || input.agent.id || ''),
+                generationIndex: Number(input.agent.generation_index || 1),
+                sessionId: String(input.agent.session_id || ''),
+                cwd: String(input.intake.cwd || root),
+                prompt: buildWorkerPrompt(input.slice),
+                model: modelRouting.choice.model,
+                reasoningEffort: modelRouting.choice.reasoning,
+                modelReasoningEffort: modelRouting.choice.reasoning,
+                serviceTier: modelRouting.choice.serviceTier,
+                inputFiles: input.intake.input_files || [],
+                inputImages: input.intake.input_images || [],
+                outputSchemaId: CODEX_AGENT_WORKER_RESULT_SCHEMA_ID,
+                outputSchema: codexAgentWorkerResultSchema,
+                sandboxPolicy: hasWriteLease(input.slice, input.intake) ? 'workspace-write' : 'read-only',
+                requestedScopeContract: {
+                    id: String(input.intake.lease_id || input.slice?.id || ''),
+                    route: String(input.intake.route || '$Agent'),
+                    read_only: !hasWriteLease(input.slice, input.intake),
+                    allowed_paths: writePaths(input.slice, input.intake),
+                    write_paths: writePaths(input.slice, input.intake),
+                    model_route_reason: modelRouting.reason,
+                    service_tier: modelRouting.choice.serviceTier,
+                    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
+                    } } : {}),
+                mutationLedgerRoot: path.join(root, input.workerDirRel),
+                zellijPaneId: await readZellijPaneId(root, input.workerDirRel),
+                reliabilityPolicy: {
+                    maxEmptyResultRetries: 1,
+                    timeoutClass: 'standard'
+                }
+            });
+            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';
+            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,
+                patch_envelope_path: sdkTask.patchEnvelopePath || null,
+                model: modelRouting.choice.model,
+                model_reasoning_effort: modelRouting.choice.reasoning,
                 service_tier: modelRouting.choice.serviceTier,
-                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
-                } } : {}),
-            mutationLedgerRoot: path.join(root, input.workerDirRel),
-            zellijPaneId: await readZellijPaneId(root, input.workerDirRel),
-            reliabilityPolicy: {
-                maxEmptyResultRetries: 1,
-                timeoutClass: 'standard'
-            }
-        });
-        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';
-        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,
-            patch_envelope_path: sdkTask.patchEnvelopePath || null,
-            model: modelRouting.choice.model,
-            model_reasoning_effort: modelRouting.choice.reasoning,
-            service_tier: modelRouting.choice.serviceTier,
-            model_route_reason: modelRouting.reason,
-            blockers: sdkTask.blockers
-        };
-        childReports = [sdkReport];
-        result = validateAgentWorkerResult({
-            ...sdkWorkerResult,
-            agent_id: workerOwnerId(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',
-            patch_envelopes: patchEnvelopes,
-            ...(patchEnvelopes.length ? {} : { no_patch_reason: buildNoPatchReason(input, sdkTask.backend || backend) }),
-            codex_child_report: sdkReport,
-            codex_sdk_thread: sdkReport,
-            model_authored_patch_envelopes: patchEnvelopes.length > 0,
-            fixture_patch_envelopes: false,
-            artifacts: [...new Set([
-                    ...(sdkWorkerResult?.artifacts || []),
-                    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)] : [])
-                ])],
-            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'] : [])
-                ]
-            }
-        });
+                model_route_reason: modelRouting.reason,
+                blockers: sdkTask.blockers
+            };
+            childReports = [sdkReport];
+            result = validateAgentWorkerResult({
+                ...sdkWorkerResult,
+                agent_id: workerOwnerId(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',
+                patch_envelopes: patchEnvelopes,
+                ...(patchEnvelopes.length ? {} : { no_patch_reason: buildNoPatchReason(input, sdkTask.backend || backend) }),
+                codex_child_report: sdkReport,
+                codex_sdk_thread: sdkReport,
+                model_authored_patch_envelopes: patchEnvelopes.length > 0,
+                fixture_patch_envelopes: false,
+                artifacts: [...new Set([
+                        ...(sdkWorkerResult?.artifacts || []),
+                        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)] : [])
+                    ])],
+                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'] : [])
+                    ]
+                }
+            });
+        }
     }
     else {
         const zellijRun = await runZellijAgent(input.agent, input.slice, {
@@ -262,24 +274,69 @@ export async function runNativeWorkerBackendRouter(input) {
         patchEnvelopes
     };
 }
-async function resolveWorkerModelRouting(input) {
-    const category = categoryForWorkerRole(String(input.agent?.role || input.slice?.role || input.slice?.type || input.agent?.persona_id || 'executor'));
-    const lbHealth = await readLbHealth().catch(() => null);
-    const explicitModel = String(process.env.SKS_WORKER_MODEL || process.env.SKS_AGENT_MODEL || '').trim();
-    const explicitReasoning = normalizeModelReasoning(process.env.SKS_WORKER_REASONING || process.env.SKS_WORKER_MODEL_REASONING || '');
-    const explicitTier = normalizeServiceTier(process.env.SKS_WORKER_SERVICE_TIER || process.env.SKS_SERVICE_TIER || '');
-    const routed = explicitModel
+export async function resolveWorkerModelRouting(input, deps = {}) {
+    const narutoOnly = Boolean(input.agent?.naruto_role) || /\$?naruto/i.test(String(input.intake?.route || ''));
+    const taskKindText = [
+        input.slice?.work_item_kind,
+        input.slice?.kind,
+        input.slice?.type,
+        input.slice?.title,
+        input.slice?.required_role,
+        input.slice?.role,
+        input.agent?.naruto_role,
+        input.agent?.role,
+        input.agent?.persona_id
+    ].map((value) => String(value || '')).join(' ');
+    const riskText = [taskKindText, input.slice?.risk, input.slice?.risk_focus, input.slice?.acceptance, input.slice?.parent_prompt, input.slice?.description, input.intake?.prompt].map((value) => String(value || '')).join(' ');
+    const category = categoryForWorkerRole(String(input.agent?.role || 'executor'), taskKindText);
+    const env = deps.env || process.env;
+    const lbHealth = Object.prototype.hasOwnProperty.call(deps, 'lbHealth') ? deps.lbHealth : await readLbHealth().catch(() => null);
+    const lbCatalog = narutoOnly
+        ? Object.prototype.hasOwnProperty.call(deps, 'lbCatalog')
+            ? deps.lbCatalog
+            : input.intake?.naruto_model_catalog || await readCodexLbModelCatalog().catch(() => null)
+        : null;
+    const explicitModel = String(env.SKS_WORKER_MODEL || env.SKS_AGENT_MODEL || '').trim();
+    const explicitReasoningRaw = String(env.SKS_WORKER_REASONING || env.SKS_WORKER_MODEL_REASONING || '').trim();
+    const explicitTierRaw = String(env.SKS_WORKER_SERVICE_TIER || env.SKS_SERVICE_TIER || '').trim();
+    const explicitReasoning = normalizeModelReasoning(explicitReasoningRaw);
+    const explicitTier = normalizeServiceTier(explicitTierRaw);
+    const explicitNarutoModelInvalid = narutoOnly && Boolean(explicitModel) && !isNarutoGpt56Model(explicitModel);
+    const explicitNarutoReasoningInvalid = narutoOnly && Boolean(explicitReasoningRaw) && !explicitReasoning;
+    const explicitNarutoTierInvalid = narutoOnly && Boolean(explicitTierRaw) && !explicitTier;
+    const routed = explicitModel && !narutoOnly
         ? {
             model: explicitModel,
             reasoning: explicitReasoning || normalizeModelReasoning(input.agent?.model_reasoning_effort) || 'medium',
             serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
         }
-        : await routeModel(category, { lbHealth, model: input.agent?.model || null });
+        : await routeModel(category, {
+            lbHealth,
+            ...(narutoOnly ? {
+                narutoOnly: true,
+                taskText: taskKindText,
+                riskText,
+                availableModels: lbCatalog?.models || [],
+                availableModelEfforts: lbCatalog?.model_efforts || {},
+                ...(explicitModel ? { model: explicitModel } : {})
+            } : { model: input.agent?.model || null })
+        });
+    const blockers = [
+        ...(narutoOnly && !lbCatalog?.ok ? (lbCatalog?.blockers || ['codex_lb_model_catalog_unavailable']) : []),
+        ...(explicitNarutoModelInvalid ? ['naruto_worker_model_outside_gpt_5_6_family'] : []),
+        ...(explicitNarutoReasoningInvalid ? ['naruto_reasoning_override_invalid'] : []),
+        ...(explicitNarutoTierInvalid ? ['naruto_service_tier_override_invalid'] : []),
+        ...(narutoOnly && explicitReasoning && explicitReasoning !== routed.reasoning ? ['naruto_reasoning_override_conflicts_with_policy'] : []),
+        ...(narutoOnly && explicitTier && explicitTier !== 'fast' ? ['naruto_service_tier_override_conflicts_with_policy'] : []),
+        ...(narutoOnly && !routed.model ? ['naruto_required_gpt_5_6_model_unavailable'] : [])
+    ];
     return {
         category,
         choice: routed,
         explicit: Boolean(explicitModel),
         lb_health: lbHealth,
+        lb_catalog: lbCatalog,
+        blockers: [...new Set(blockers)],
         reason: modelRouteReason(category, routed, {
             explicit: Boolean(explicitModel),
             quotaLow: lbHealth?.quota_low === true,
@@ -289,7 +346,7 @@ async function resolveWorkerModelRouting(input) {
 }
 function normalizeModelReasoning(value) {
     const text = String(value || '').toLowerCase();
-    return text === 'low' || text === 'medium' || text === 'high' || text === 'xhigh' ? text : null;
+    return text === 'low' || text === 'medium' || text === 'high' || text === 'xhigh' || text === 'max' || text === 'ultra' ? text : null;
 }
 function normalizeServiceTier(value) {
     const text = String(value || '').toLowerCase();
@@ -298,6 +355,8 @@ function normalizeServiceTier(value) {
 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({
@@ -310,6 +369,18 @@ async function maybeAutoSelectOllamaBackend(backend, input) {
     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 || ''));
+}
+export function narutoWorkerBackendBlocker(backend, narutoRequest = true) {
+    if (!narutoRequest)
+        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 === 'zellij' || value === 'ollama' || value === 'local-llm' ? value : null;
 }

package/dist/core/agents/parallel-write-fixture.js

@@ -175,24 +175,29 @@ async function runTypecheck(repoRoot) {
     return runCommand([localTsc, '-p', 'tsconfig.json', '--noEmit'], repoRoot);
 }
 async function cleanupWorktreesAndBranches(repoRoot, tmpRoot, workers, before, keepTmp) {
+    const removeResults = [];
     for (const worker of workers) {
-        await runCommand(['git', 'worktree', 'remove', '--force', path.join(tmpRoot, 'worktrees', worker.id)], repoRoot);
+        removeResults.push(await runCommand(['git', 'worktree', 'remove', '--force', path.join(tmpRoot, 'worktrees', worker.id)], repoRoot));
     }
-    await runCommand(['git', 'worktree', 'prune'], repoRoot);
+    const prune = await runCommand(['git', 'worktree', 'prune'], repoRoot);
+    const branchResults = [];
     for (const worker of workers) {
-        await runCommand(['git', 'branch', '-D', worker.branch], repoRoot);
+        branchResults.push(await runCommand(['git', 'branch', '-D', worker.branch], repoRoot));
     }
     const after = await runCommand(['git', 'worktree', 'list', '--porcelain'], repoRoot);
+    const branches = await runCommand(['git', 'branch', '--list', ...workers.map((worker) => worker.branch)], repoRoot);
     const status = await runCommand(['git', 'status', '--short'], repoRoot);
     if (!keepTmp)
-        await fsp.rm(tmpRoot, { recursive: true, force: true });
+        await fsp.rm(tmpRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
     const tmpRemoved = keepTmp ? false : !(await exists(tmpRoot));
+    const workerWorktreesRemoved = after.ok && workers.every((worker) => !after.stdout_tail.includes(worker.id));
+    const workerBranchesRemoved = branches.ok && branches.stdout_tail.trim().length === 0;
     return {
-        ok: workers.every((worker) => !after.stdout_tail.includes(worker.id) && !after.stdout_tail.includes(worker.branch)) && status.stdout_tail.trim().length === 0 && tmpRemoved,
+        ok: removeResults.every((result) => result.ok) && prune.ok && branchResults.every((result) => result.ok) && workerWorktreesRemoved && workerBranchesRemoved && status.ok && status.stdout_tail.trim().length === 0 && tmpRemoved,
         worktree_list_before_cleanup: before,
         worktree_list_after_cleanup: after.stdout_tail,
-        worker_worktrees_removed: workers.every((worker) => !after.stdout_tail.includes(worker.id)),
-        worker_branches_removed: workers.every((worker) => !after.stdout_tail.includes(worker.branch)),
+        worker_worktrees_removed: workerWorktreesRemoved,
+        worker_branches_removed: workerBranchesRemoved,
         parent_dirty_after_cleanup: status.stdout_tail.trim().length > 0,
         tmp_removed: tmpRemoved
     };
@@ -200,12 +205,12 @@ async function cleanupWorktreesAndBranches(repoRoot, tmpRoot, workers, before, k
 async function bestEffortCleanup(repoRoot, tmpRoot, keepTmp) {
     const before = await runCommand(['git', 'worktree', 'list', '--porcelain'], repoRoot);
     if (!keepTmp)
-        await fsp.rm(tmpRoot, { recursive: true, force: true });
+        await fsp.rm(tmpRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
     return {
-        ok: !keepTmp && !(await exists(tmpRoot)),
+        ok: false,
         worktree_list_before_cleanup: before.stdout_tail,
         worktree_list_after_cleanup: '',
-        worker_worktrees_removed: true,
+        worker_worktrees_removed: false,
         worker_branches_removed: false,
         parent_dirty_after_cleanup: false,
         tmp_removed: !keepTmp && !(await exists(tmpRoot))

package/dist/core/agents/runtime-proof-summary.js

@@ -15,6 +15,7 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
     const scheduler = await readJson(path.join(agentsDir, 'agent-scheduler-state.json'), null);
     const swarm = await readJson(path.join(agentsDir, 'agent-native-cli-session-swarm.json'), null);
     const telemetry = await readJson(path.join(dir, 'zellij', 'slot-telemetry.snapshot.json'), null);
+    const stopGate = await readJson(path.join(dir, 'stop-gate.json'), null);
     const governor = await readJson(path.join(agentsDir, 'naruto-concurrency-governor.json'), null);
     const messagesAll = await readAgentMessageBus(root, missionId, { max: 500 });
     const recentMessages = await readAgentMessageBus(root, missionId, { max: opts.maxMessages || 8 });
@@ -23,15 +24,17 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
     const failedMessages = messagesAll.filter((row) => row.event_type === 'worker_failed');
     const errorMessages = messagesAll.filter((row) => row.level === 'error');
     const telemetryAgeMs = telemetry?.updated_at ? Math.max(0, Date.now() - Date.parse(telemetry.updated_at)) : Number.MAX_SAFE_INTEGER;
+    const terminalProofAccepted = canonicalTerminalProofAccepted(stopGate, missionId);
     const visiblePanes = Number(parallel?.visible_panes ?? swarm?.zellij_pane_worker_sessions ?? telemetryVisiblePaneCount(telemetry) ?? 0);
     const targetActive = Number(scheduler?.target_active_slots ?? parallel?.target_active_slots ?? swarm?.target_active_slots ?? governor?.target_active_slots ?? 0);
     const headlessWorkers = Number(parallel?.headless_workers ?? swarm?.headless_overflow_worker_count ?? Math.max(0, targetActive - visiblePanes));
+    const parallelBlockers = parallel?.passed === false ? parallel.blockers || ['parallel_runtime_proof_failed'] : [];
     const blockers = [
         ...(!parallel ? ['parallel_runtime_proof_missing'] : []),
         ...(!scheduler ? ['agent_scheduler_state_missing'] : []),
-        ...(parallel?.passed === false ? parallel.blockers || ['parallel_runtime_proof_failed'] : []),
+        ...(terminalProofAccepted ? parallelBlockers.filter((blocker) => String(blocker) !== 'speedup_ratio_below_target') : parallelBlockers),
         ...(errorMessages.length ? ['agent_message_bus_error_blockers'] : []),
-        ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : []),
+        ...(telemetryAgeMs > 3000 && !terminalProofAccepted ? ['zellij_telemetry_stale'] : []),
         ...(zellijSummary?.blockers || [])
     ].map(String);
     const summary = {
@@ -76,6 +79,11 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
             duplicate_slot_anchor_count: Number(zellijSummary?.duplicate_slot_anchor_count || 0)
         },
         loops: loopSummary,
+        terminal_proof: {
+            accepted: terminalProofAccepted,
+            gate_file: terminalProofAccepted ? 'stop-gate.json' : null,
+            terminal_state: terminalProofAccepted ? String(stopGate?.terminal_state || 'completed') : null
+        },
         blockers
     };
     await writeJsonAtomic(path.join(agentsDir, 'runtime-proof-summary.json'), summary);
@@ -83,7 +91,8 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
 }
 export function renderRuntimeProofSummary(summary) {
     return [
-        `Parallel proof: ${summary.parallel.proof_passed ? 'passed' : 'blocked'}`,
+        `Parallel proof: ${summary.parallel.proof_passed ? 'passed' : summary.terminal_proof?.accepted ? 'terminal gate accepted' : 'blocked'}`,
+        `Canonical terminal proof: ${summary.terminal_proof?.accepted ? 'accepted' : 'not available'}`,
         `Active workers: ${summary.parallel.max_active_workers}`,
         `Unique PIDs: ${summary.parallel.unique_worker_pids}`,
         `Speedup: ${summary.parallel.speedup_ratio}x`,
@@ -102,6 +111,15 @@ export function renderRuntimeProofSummary(summary) {
         ...(summary.blockers.length ? [`Blockers: ${summary.blockers.join(', ')}`] : [])
     ].join('\n');
 }
+function canonicalTerminalProofAccepted(gate, missionId) {
+    const blockers = Array.isArray(gate?.blockers) ? gate.blockers : [];
+    return gate?.schema === 'sks.stop-gate.v1'
+        && String(gate?.mission_id || '') === missionId
+        && gate?.passed === true
+        && gate?.terminal === true
+        && String(gate?.terminal_state || '') === 'completed'
+        && blockers.length === 0;
+}
 function messageStatusLabel(row) {
     if (row.event_type === 'worker_completed')
         return '[done]';

package/dist/core/codex-app/codex-app-restart.js

@@ -1,15 +1,16 @@
 import { exists, runProcess, which } from '../fsx.js';
 export async function restartCodexApp(opts = {}) {
     const env = opts.env || process.env;
-    const appName = String(opts.appName || env.SKS_CODEX_APP_NAME || 'Codex');
+    const appName = String(opts.appName || env.SKS_CODEX_APP_NAME || 'ChatGPT');
+    const bundleId = String(opts.bundleId || env.SKS_CODEX_APP_BUNDLE_ID || 'com.openai.codex');
     if (opts.enabled === false || env.SKS_SKIP_CODEX_APP_RESTART === '1') {
         return skipped(appName, 'disabled');
     }
-    if (process.platform !== 'darwin')
+    if ((opts.platform || process.platform) !== 'darwin')
         return skipped(appName, 'not_macos');
     const run = opts.runProcessImpl || runProcess;
-    const osascript = await which('osascript').catch(() => null) || await exists('/usr/bin/osascript').then((ok) => ok ? '/usr/bin/osascript' : null).catch(() => null);
-    const open = await which('open').catch(() => null) || await exists('/usr/bin/open').then((ok) => ok ? '/usr/bin/open' : null).catch(() => null);
+    const osascript = opts.osascriptPath || await which('osascript').catch(() => null) || await exists('/usr/bin/osascript').then((ok) => ok ? '/usr/bin/osascript' : null).catch(() => null);
+    const open = opts.openPath || await which('open').catch(() => null) || await exists('/usr/bin/open').then((ok) => ok ? '/usr/bin/open' : null).catch(() => null);
     if (!osascript || !open) {
         return {
             schema: 'sks.codex-app-restart.v1',
@@ -22,25 +23,54 @@ export async function restartCodexApp(opts = {}) {
             ]
         };
     }
-    const quit = await run(osascript, ['-e', `tell application ${JSON.stringify(appName)} to quit`], { timeoutMs: 5000, maxOutputBytes: 8192 }).catch((err) => ({
+    const appTarget = bundleId ? `application id ${JSON.stringify(bundleId)}` : `application ${JSON.stringify(appName)}`;
+    const quit = await run(osascript, ['-e', `tell ${appTarget} to quit`], { timeoutMs: 5000, maxOutputBytes: 8192 }).catch((err) => ({
         code: 1,
         stdout: '',
         stderr: err?.message || String(err)
     }));
-    await sleep(Number(opts.delayMs ?? env.SKS_CODEX_APP_RESTART_DELAY_MS ?? 1200));
-    const launched = await run(open, ['-a', appName], { timeoutMs: 10000, maxOutputBytes: 8192 }).catch((err) => ({
+    const quitOk = quit.code === 0 || /not running|Can't get application|application isn't running/i.test(String(quit.stderr || quit.stdout || ''));
+    const exitTimeoutMs = Math.max(250, Number(opts.exitTimeoutMs ?? env.SKS_CODEX_APP_EXIT_TIMEOUT_MS ?? 5000));
+    const pollMs = Math.max(50, Number(opts.pollMs ?? 100));
+    let exited = !quitOk;
+    let attempts = 0;
+    const deadline = Date.now() + exitTimeoutMs;
+    while (quitOk && Date.now() < deadline) {
+        attempts += 1;
+        const probe = await run(osascript, ['-e', `${appTarget} is running`], { timeoutMs: 1000, maxOutputBytes: 1024 }).catch(() => null);
+        if (probe?.code === 0 && String(probe.stdout || '').trim().toLowerCase() === 'false') {
+            exited = true;
+            break;
+        }
+        await sleep(pollMs);
+    }
+    if (quitOk && !exited) {
+        return {
+            schema: 'sks.codex-app-restart.v1',
+            ok: false,
+            status: 'blocked',
+            app_name: appName,
+            bundle_id: bundleId,
+            quit: { ok: true, code: quit.code, error: null },
+            exit_wait: { ok: false, attempts, error: 'codex_app_exit_timeout' },
+            blockers: ['codex_app_exit_timeout']
+        };
+    }
+    await sleep(Number(opts.delayMs ?? env.SKS_CODEX_APP_RESTART_DELAY_MS ?? 150));
+    const launched = await run(open, bundleId ? ['-b', bundleId] : ['-a', appName], { timeoutMs: 10000, maxOutputBytes: 8192 }).catch((err) => ({
         code: 1,
         stdout: '',
         stderr: err?.message || String(err)
     }));
-    const quitOk = quit.code === 0 || /not running|Can't get application|application isn't running/i.test(String(quit.stderr || quit.stdout || ''));
     const openOk = launched.code === 0;
     return {
         schema: 'sks.codex-app-restart.v1',
         ok: quitOk && openOk,
         status: quitOk && openOk ? 'restarted' : 'blocked',
         app_name: appName,
+        bundle_id: bundleId,
         quit: { ok: quitOk, code: quit.code, error: quitOk ? null : String(quit.stderr || quit.stdout || '').trim() },
+        exit_wait: { ok: exited, attempts, error: exited ? null : 'codex_app_exit_timeout' },
         open: { ok: openOk, code: launched.code, error: openOk ? null : String(launched.stderr || launched.stdout || '').trim() },
         blockers: [
             ...(quitOk ? [] : ['codex_app_quit_failed']),