sneakoscope 6.0.2 → 6.1.0

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

@@ -10,8 +10,9 @@ 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';
+import { codexTimeoutClassForRoute } from '../codex-control/codex-reliability-shield.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 +20,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 +29,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 +103,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: codexTimeoutClassForRoute(input.intake.route, '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 +275,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 +347,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 +356,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 +370,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/agents/work-partition/repo-inventory.js

@@ -1,9 +1,50 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-const IGNORE = new Set(['.git', 'node_modules', 'dist', 'target', '.sneakoscope', '.codex', '.agents', '.next', '.turbo']);
+const IGNORE = new Set([
+    '.agents', '.cache', '.claude', '.codex', '.git', '.git-worktrees', '.hg', '.mypy_cache', '.next', '.npm', '.nuxt',
+    '.nyc_output', '.parcel-cache', '.pnpm-store', '.pytest_cache', '.ruff_cache', '.sneakoscope', '.svelte-kit', '.svn',
+    '.tmp', '.turbo', '.venv', '.worktrees', '.yarn', '__pycache__', 'build', 'coverage', 'dist', 'logs', 'node_modules',
+    'out', 'target', 'temp', 'tmp', 'venv'
+]);
+const PRIORITY_DIRS = ['src', 'test', 'docs', 'schemas', 'scripts', 'crates', 'bin'];
+const REPRESENTATIVE_DIRS = ['src', 'test', 'docs'];
+const CORE_FILES = ['package.json', 'package-lock.json', 'README.md', 'CHANGELOG.md', 'LICENSE', 'tsconfig.json', 'release-gates.v2.json', 'runtime-required-scripts.json', 'AGENTS.md'];
 export async function collectRepoInventory(root, opts = {}) {
     const files = [];
-    await walk(root, root, files, opts.maxFiles || Number(process.env.SKS_AGENT_REPO_INVENTORY_MAX_FILES || 10000));
+    const seen = new Set();
+    const requestedMax = Number(opts.maxFiles ?? process.env.SKS_AGENT_REPO_INVENTORY_MAX_FILES ?? 10000);
+    const maxFiles = Number.isFinite(requestedMax) ? Math.max(1, Math.floor(requestedMax)) : 10000;
+    const add = (file) => {
+        if (files.length >= maxFiles || seen.has(file))
+            return;
+        seen.add(file);
+        files.push(file);
+    };
+    // Seed representative source/test/docs entries before any large tree can
+    // exhaust the cap, then expand the priority roots in a stable order.
+    for (const name of REPRESENTATIVE_DIRS) {
+        const representative = await firstFile(root, path.join(root, name));
+        if (representative)
+            add(representative);
+    }
+    for (const name of CORE_FILES) {
+        const full = path.join(root, name);
+        if ((await fs.stat(full).catch(() => null))?.isFile())
+            add(name);
+    }
+    for (const name of PRIORITY_DIRS)
+        await walk(root, path.join(root, name), files, seen, maxFiles);
+    for (const entry of await sortedEntries(root)) {
+        if (files.length >= maxFiles)
+            break;
+        if (IGNORE.has(entry.name) || PRIORITY_DIRS.includes(entry.name) || CORE_FILES.includes(entry.name))
+            continue;
+        const full = path.join(root, entry.name);
+        if (entry.isDirectory())
+            await walk(root, full, files, seen, maxFiles);
+        else if (entry.isFile())
+            add(entry.name);
+    }
     const classify = (re) => files.filter((file) => re.test(file));
     return {
         schema: 'sks.agent-repo-inventory.v1',
@@ -19,11 +60,10 @@ export async function collectRepoInventory(root, opts = {}) {
         files
     };
 }
-async function walk(root, dir, out, maxFiles) {
+async function walk(root, dir, out, seen, maxFiles) {
     if (out.length >= maxFiles)
         return;
-    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-    for (const entry of entries) {
+    for (const entry of await sortedEntries(dir)) {
         if (out.length >= maxFiles)
             return;
         if (IGNORE.has(entry.name))
@@ -31,9 +71,30 @@ async function walk(root, dir, out, maxFiles) {
         const full = path.join(dir, entry.name);
         const rel = path.relative(root, full).replace(/\\/g, '/');
         if (entry.isDirectory())
-            await walk(root, full, out, maxFiles);
-        else if (entry.isFile())
+            await walk(root, full, out, seen, maxFiles);
+        else if (entry.isFile() && !seen.has(rel)) {
+            seen.add(rel);
             out.push(rel);
+        }
     }
 }
+async function firstFile(root, dir) {
+    for (const entry of await sortedEntries(dir)) {
+        if (IGNORE.has(entry.name))
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isFile())
+            return path.relative(root, full).replace(/\\/g, '/');
+        if (entry.isDirectory()) {
+            const nested = await firstFile(root, full);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+async function sortedEntries(dir) {
+    return (await fs.readdir(dir, { withFileTypes: true }).catch(() => []))
+        .sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
 //# sourceMappingURL=repo-inventory.js.map

package/dist/core/code-structure.js

@@ -194,10 +194,11 @@ async function collectChangedScope(root, opts) {
 async function listSourceFiles(root, dir = root, out = []) {
     const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-        if (entry.name.startsWith('.') && !['.agents'].includes(entry.name)) {
-            if (SKIP_DIRS.has(entry.name))
-                continue;
-        }
+        // Hidden runtime/worktree directories can contain complete repository copies.
+        // Only .agents is a source-bearing project directory; all other hidden trees
+        // are state, caches, or external workspaces and must stay outside this scan.
+        if (entry.name.startsWith('.') && entry.name !== '.agents')
+            continue;
         const full = path.join(dir, entry.name);
         if (entry.isDirectory()) {
             if (!SKIP_DIRS.has(entry.name))