sneakoscope 2.0.15 → 2.0.17

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

@@ -126,18 +126,33 @@ export async function runNativeCliWorker(input = {}) {
     });
     await writeJsonAtomic(path.join(workerDir, 'worker-recursion-guard.json'), guard);
     let noPatchReason = null;
-    const routed = await runNativeWorkerBackendRouter({
+    const progressTelemetry = startWorkerProgressTelemetry({
         agentRoot,
-        workerDirRel,
-        resultRel,
-        patchRel,
+        heartbeatRel,
+        intake,
         agent,
         slice,
-        intake: { ...intake, ...input },
         backend,
-        fastModePolicy: policy,
-        guard
+        serviceTier: policy.service_tier
     });
+    let routed;
+    try {
+        routed = await runNativeWorkerBackendRouter({
+            agentRoot,
+            workerDirRel,
+            resultRel,
+            patchRel,
+            agent,
+            slice,
+            intake: { ...intake, ...input },
+            backend,
+            fastModePolicy: policy,
+            guard
+        });
+    }
+    finally {
+        progressTelemetry.stop();
+    }
     const patchEnvelopes = routed.patchEnvelopes;
     if (patchEnvelopes.length) {
         await writeJsonAtomic(path.resolve(agentRoot, patchRel), {
@@ -330,6 +345,39 @@ export async function runNativeCliWorker(input = {}) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function startWorkerProgressTelemetry(input) {
+    const parsed = Number(process.env.SKS_ZELLIJ_WORKER_PROGRESS_MS || 2000);
+    const intervalMs = Math.max(500, Number.isFinite(parsed) ? Math.floor(parsed) : 2000);
+    let tick = 0;
+    const timer = setInterval(() => {
+        tick += 1;
+        const progress = { done: tick, total: 0, label: 'backend running' };
+        appendJsonl(path.resolve(input.agentRoot, input.heartbeatRel), {
+            schema: 'sks.native-cli-worker-heartbeat.v1',
+            ts: nowIso(),
+            event: 'progress',
+            pid: process.pid,
+            session_id: input.agent.session_id,
+            slot_id: input.agent.slot_id || null,
+            generation_index: input.agent.generation_index || null,
+            progress
+        }).catch(() => undefined);
+        workerTelemetry(input.agentRoot, input.intake, input.agent, input.slice, {
+            eventType: 'task_progress',
+            status: 'running',
+            backend: input.backend,
+            serviceTier: input.serviceTier,
+            artifacts: [input.heartbeatRel],
+            progress,
+            logTail: `backend running ${tick}`
+        }).catch(() => undefined);
+    }, intervalMs);
+    return {
+        stop() {
+            clearInterval(timer);
+        }
+    };
+}
 function parseNativeCliWorkerArgs(args) {
     return {
         intake: readOption(args, '--intake', ''),
@@ -389,6 +437,7 @@ async function workerTelemetry(agentRoot, intake, agent, slice, input) {
         worktree_path: agent.worktree?.path || slice.worktree?.path || intake.worktree?.path || null,
         task_title: String(slice.description || slice.title || slice.id || 'worker task'),
         current_file: firstString([slice.write_paths?.[0], slice.readonly_paths?.[0], slice.input_files?.[0]]) || null,
+        ...(input.progress ? { progress: input.progress } : {}),
         artifact_paths: input.artifacts || [],
         log_tail: input.logTail || '',
         blockers: input.blockers || []

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

@@ -0,0 +1,276 @@
+import path from 'node:path';
+import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+export const PARALLEL_RUNTIME_EVENT_SCHEMA = 'sks.parallel-runtime-event.v1';
+export const PARALLEL_RUNTIME_PROOF_SCHEMA = 'sks.parallel-runtime-proof.v1';
+export function parallelRuntimeEventPath(root, missionId) {
+    return path.join(inferAgentsDir(root, missionId), 'parallel-runtime.events.jsonl');
+}
+export function parallelRuntimeProofPath(root, missionId) {
+    return path.join(inferAgentsDir(root, missionId), 'parallel-runtime-proof.json');
+}
+export async function appendParallelRuntimeEvent(root, missionId, event) {
+    const row = normalizeParallelRuntimeEvent(missionId, event);
+    const file = parallelRuntimeEventPath(root, missionId);
+    await ensureDir(path.dirname(file));
+    await appendJsonlBounded(file, row);
+    return row;
+}
+export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
+    const events = await readParallelRuntimeEvents(root, missionId);
+    const sorted = events.sort((a, b) => a.ms - b.ms);
+    const firstMs = sorted[0]?.ms || Date.now();
+    const lastMs = sorted[sorted.length - 1]?.ms || firstMs;
+    const workerActive = new Set();
+    const processActive = new Set();
+    const modelActive = new Set();
+    const workerStarts = new Map();
+    const workerDurations = [];
+    const workerPids = new Set();
+    const modelIds = new Set();
+    const overlapWindows = [];
+    let maxWorkers = 0;
+    let maxProcesses = 0;
+    let maxModels = 0;
+    let previousMs = firstMs;
+    let firstBatchLaunchSpanMs = 0;
+    const batchStart = new Map();
+    const batchCompleted = new Map();
+    for (const event of sorted) {
+        if (event.ms > previousMs) {
+            overlapWindows.push({
+                start_ms: previousMs - firstMs,
+                end_ms: event.ms - firstMs,
+                active_workers: workerActive.size,
+                active_model_calls: modelActive.size
+            });
+            previousMs = event.ms;
+        }
+        const workerKey = event.session_id || event.slot_id || (event.pid == null ? '' : `pid:${event.pid}`);
+        const processKey = event.pid == null ? workerKey : `pid:${event.pid}`;
+        if (event.event_type === 'batch_dispatch_started' && event.batch_id)
+            batchStart.set(event.batch_id, event.ms);
+        if (event.event_type === 'batch_dispatch_completed' && event.batch_id) {
+            batchCompleted.set(event.batch_id, event.ms);
+            const started = batchStart.get(event.batch_id);
+            if (started != null && firstBatchLaunchSpanMs === 0)
+                firstBatchLaunchSpanMs = Math.max(0, event.ms - started);
+        }
+        if (event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned') {
+            if (workerKey) {
+                workerActive.add(workerKey);
+                if (!workerStarts.has(workerKey))
+                    workerStarts.set(workerKey, event.ms);
+            }
+            if (event.event_type === 'worker_process_spawned' && processKey)
+                processActive.add(processKey);
+            if (event.pid != null)
+                workerPids.add(event.pid);
+        }
+        if (event.event_type === 'worker_completed' || event.event_type === 'worker_failed') {
+            if (workerKey) {
+                workerActive.delete(workerKey);
+                const started = workerStarts.get(workerKey);
+                if (started != null)
+                    workerDurations.push(Math.max(0, event.ms - started));
+            }
+            if (processKey)
+                processActive.delete(processKey);
+        }
+        if (event.event_type === 'model_call_started') {
+            const id = event.model_call_id || event.session_id || `model:${event.ms}:${modelActive.size}`;
+            modelActive.add(id);
+            modelIds.add(id);
+        }
+        if (event.event_type === 'model_call_completed') {
+            const id = event.model_call_id || event.session_id || '';
+            if (id)
+                modelActive.delete(id);
+        }
+        maxWorkers = Math.max(maxWorkers, workerActive.size);
+        maxProcesses = Math.max(maxProcesses, processActive.size);
+        maxModels = Math.max(maxModels, modelActive.size);
+    }
+    const requestedWorkers = positiveInt(opts.requestedWorkers, workerStarts.size || workerPids.size || maxWorkers);
+    const targetActiveSlots = positiveInt(opts.targetActiveSlots, requestedWorkers);
+    const proofMode = opts.proofMode || 'production';
+    const allowMissingPids = proofMode === 'in-process-fixture' && opts.allowMissingPids === true;
+    const requireWorkerPids = opts.requireWorkerPids ?? (proofMode === 'production' && requestedWorkers >= 16);
+    const wallMs = Math.max(0, lastMs - firstMs);
+    const sequentialEstimateMs = workerDurations.length
+        ? workerDurations.reduce((sum, value) => sum + value, 0)
+        : requestedWorkers * positiveInt(opts.expectedWorkerRuntimeMs, 4000);
+    const visiblePanes = nonNegativeInt(opts.visiblePanes, sorted.filter((event) => event.placement === 'zellij-pane').length ? new Set(sorted.filter((event) => event.placement === 'zellij-pane').map((event) => event.slot_id || event.session_id || '')).size : 0);
+    const observedHeadlessWorkers = sorted.filter((event) => event.placement === 'headless' && (event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned')).length;
+    const headlessWorkers = Math.max(observedHeadlessWorkers, Math.max(0, targetActiveSlots - visiblePanes));
+    const minActiveWorkers = opts.minActiveWorkers === undefined
+        ? Math.min(targetActiveSlots, requestedWorkers)
+        : nonNegativeInt(opts.minActiveWorkers, Math.min(targetActiveSlots, requestedWorkers));
+    const minSpeedup = Number.isFinite(Number(opts.minSpeedupRatio)) ? Number(opts.minSpeedupRatio) : requestedWorkers >= 16 ? 5 : 1;
+    const speedupRatio = wallMs > 0 ? Number((sequentialEstimateMs / wallMs).toFixed(3)) : 0;
+    const launchEvents = sorted.filter((event) => event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned');
+    const launchSpanMs = launchEvents.length ? Math.max(...launchEvents.map((event) => event.ms)) - Math.min(...launchEvents.map((event) => event.ms)) : 0;
+    const firstBatchLimit = positiveInt(opts.firstBatchLaunchSpanLimitMs, requestedWorkers >= 16 ? 2500 : 30000);
+    const schedulerState = await readJson(path.join(root, 'agent-scheduler-state.json'), null).catch(() => null);
+    const coalescedOverlapWindows = coalesceOverlapWindows(overlapWindows);
+    const utilizationProofConsistency = buildUtilizationProofConsistency(schedulerState, {
+        proofMaxActive: maxWorkers,
+        proofWallMs: wallMs,
+        proofActiveSlotTimeMs: activeSlotTimeMsFromWindows(coalescedOverlapWindows)
+    });
+    const blockers = [];
+    if (!sorted.length)
+        blockers.push('parallel_runtime_events_missing');
+    if (minActiveWorkers > 0 && maxWorkers < minActiveWorkers)
+        blockers.push('max_observed_active_workers_below_target');
+    if (requireWorkerPids && workerPids.size < minActiveWorkers)
+        blockers.push('unique_worker_pids_below_target');
+    if (requireWorkerPids && workerPids.size === 0)
+        blockers.push('unique_worker_pids_missing_in_production_proof');
+    if (speedupRatio < minSpeedup)
+        blockers.push('speedup_ratio_below_target');
+    if (firstBatchLaunchSpanMs > firstBatchLimit)
+        blockers.push('first_batch_launch_span_above_limit');
+    return {
+        schema: PARALLEL_RUNTIME_PROOF_SCHEMA,
+        mission_id: missionId,
+        generated_at: nowIso(),
+        proof_mode: proofMode,
+        require_worker_pids: requireWorkerPids,
+        allow_missing_pids: allowMissingPids,
+        requested_workers: requestedWorkers,
+        target_active_slots: targetActiveSlots,
+        max_observed_active_workers: maxWorkers,
+        max_observed_worker_processes: Math.max(maxProcesses, workerPids.size ? maxProcesses : maxWorkers),
+        unique_worker_pids: workerPids.size,
+        unique_model_call_ids: modelIds.size,
+        max_observed_model_calls: maxModels,
+        launch_span_ms: launchSpanMs,
+        first_batch_launch_span_ms: firstBatchLaunchSpanMs,
+        wall_ms: wallMs,
+        sequential_estimate_ms: sequentialEstimateMs,
+        speedup_ratio: speedupRatio,
+        overlap_windows: coalescedOverlapWindows,
+        visible_panes: visiblePanes,
+        headless_workers: headlessWorkers,
+        utilization_proof_consistency: utilizationProofConsistency,
+        passed: blockers.length === 0,
+        blockers
+    };
+}
+export async function writeParallelRuntimeProof(root, missionId, opts = {}) {
+    const proof = await buildParallelRuntimeProof(root, missionId, opts);
+    await writeJsonAtomic(parallelRuntimeProofPath(root, missionId), proof);
+    return proof;
+}
+async function readParallelRuntimeEvents(root, missionId) {
+    const text = await readText(parallelRuntimeEventPath(root, missionId), '');
+    return String(text)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return parsed?.schema === PARALLEL_RUNTIME_EVENT_SCHEMA ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row));
+}
+function normalizeParallelRuntimeEvent(missionId, event) {
+    return {
+        schema: PARALLEL_RUNTIME_EVENT_SCHEMA,
+        ts: nowIso(),
+        ms: Date.now(),
+        mission_id: missionId,
+        event_type: event.event_type,
+        slot_id: event.slot_id == null ? null : String(event.slot_id),
+        generation_index: event.generation_index == null ? null : Math.max(1, Math.floor(Number(event.generation_index) || 1)),
+        session_id: event.session_id == null ? null : String(event.session_id),
+        pid: event.pid == null || !Number.isFinite(Number(event.pid)) ? null : Math.floor(Number(event.pid)),
+        backend: String(event.backend || 'unknown'),
+        placement: normalizePlacement(event.placement),
+        ...(event.worktree_id === undefined ? {} : { worktree_id: event.worktree_id == null ? null : String(event.worktree_id) }),
+        ...(event.model_call_id === undefined ? {} : { model_call_id: event.model_call_id == null ? null : String(event.model_call_id) }),
+        ...(event.batch_id === undefined ? {} : { batch_id: event.batch_id == null ? null : String(event.batch_id) }),
+        ...(event.meta && typeof event.meta === 'object' ? { meta: event.meta } : {})
+    };
+}
+function normalizePlacement(value) {
+    const text = String(value || 'unknown');
+    if (text === 'zellij-pane' || text === 'process' || text === 'headless')
+        return text;
+    return 'unknown';
+}
+function positiveInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return Math.max(1, Math.floor(fallback || 1));
+    return Math.floor(parsed);
+}
+function nonNegativeInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return Math.max(0, Math.floor(fallback || 0));
+    return Math.floor(parsed);
+}
+function buildUtilizationProofConsistency(state, input) {
+    if (!state || typeof state !== 'object') {
+        return {
+            ok: true,
+            scheduler_max_active: 0,
+            proof_max_active: input.proofMaxActive,
+            wall_ms_delta: 0,
+            scheduler_active_slot_time_ms: 0,
+            proof_active_slot_time_ms: input.proofActiveSlotTimeMs,
+            active_slot_time_ms_delta: 0,
+            scheduler_observation_delay_tolerance_ms: 0
+        };
+    }
+    const schedulerMaxActive = nonNegativeInt(state.max_observed_active_slots, 0);
+    const schedulerWallMs = nonNegativeInt(state.wall_time_ms, 0);
+    const schedulerActiveSlotTimeMs = nonNegativeInt(state.active_slot_time_ms, 0);
+    const wallDelta = Math.abs(schedulerWallMs - input.proofWallMs);
+    const activeSlotDelta = Math.abs(schedulerActiveSlotTimeMs - input.proofActiveSlotTimeMs);
+    const maxActiveDelta = Math.abs(schedulerMaxActive - input.proofMaxActive);
+    const wallToleranceMs = Math.max(500, Math.round(Math.max(schedulerWallMs, input.proofWallMs) * 0.25));
+    const activeSlotToleranceMs = Math.max(500, Math.round(Math.max(schedulerActiveSlotTimeMs, input.proofActiveSlotTimeMs) * 0.25));
+    const observationDelayToleranceMs = Math.max(activeSlotToleranceMs, wallDelta * Math.max(1, schedulerMaxActive));
+    const wallConsistent = wallDelta <= wallToleranceMs;
+    const activeSlotConsistent = schedulerActiveSlotTimeMs > 0 && input.proofActiveSlotTimeMs > 0 && (activeSlotDelta <= activeSlotToleranceMs
+        || (schedulerActiveSlotTimeMs >= input.proofActiveSlotTimeMs && activeSlotDelta <= observationDelayToleranceMs));
+    return {
+        ok: maxActiveDelta <= 1 && (wallConsistent || activeSlotConsistent),
+        scheduler_max_active: schedulerMaxActive,
+        proof_max_active: input.proofMaxActive,
+        wall_ms_delta: wallDelta,
+        scheduler_active_slot_time_ms: schedulerActiveSlotTimeMs,
+        proof_active_slot_time_ms: input.proofActiveSlotTimeMs,
+        active_slot_time_ms_delta: activeSlotDelta,
+        scheduler_observation_delay_tolerance_ms: observationDelayToleranceMs
+    };
+}
+function activeSlotTimeMsFromWindows(windows) {
+    return windows.reduce((sum, window) => sum + Math.max(0, window.end_ms - window.start_ms) * Math.max(0, window.active_workers), 0);
+}
+function coalesceOverlapWindows(windows) {
+    return windows
+        .filter((window) => window.end_ms > window.start_ms)
+        .filter((window) => window.active_workers > 0 || window.active_model_calls > 0)
+        .slice(0, 2000);
+}
+function inferAgentsDir(root, missionId) {
+    const resolved = path.resolve(root);
+    if (path.basename(resolved) === 'agents' && path.basename(path.dirname(resolved)) === missionId)
+        return resolved;
+    if (path.basename(resolved) === missionId && path.basename(path.dirname(resolved)) === 'missions')
+        return path.join(resolved, 'agents');
+    const marker = `${path.sep}.sneakoscope${path.sep}missions${path.sep}${missionId}${path.sep}`;
+    const index = resolved.indexOf(marker);
+    if (index >= 0)
+        return path.join(resolved.slice(0, index + marker.length - 1), 'agents');
+    return path.join(resolved, '.sneakoscope', 'missions', missionId, 'agents');
+}
+//# sourceMappingURL=parallel-runtime-proof.js.map

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

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { findLatestMission, missionDir } from '../mission.js';
+import { readJson, writeJsonAtomic } from '../fsx.js';
+export const RUNTIME_PROOF_SUMMARY_SCHEMA = 'sks.runtime-proof-summary.v1';
+export async function buildRuntimeProofSummary(root, missionIdInput = 'latest') {
+    const missionId = missionIdInput === 'latest' ? await findLatestMission(root) : missionIdInput;
+    if (!missionId)
+        throw new Error('runtime_proof_summary_mission_missing');
+    const dir = missionDir(root, missionId);
+    const agentsDir = path.join(dir, 'agents');
+    const parallel = await readJson(path.join(agentsDir, 'parallel-runtime-proof.json'), null);
+    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 governor = await readJson(path.join(agentsDir, 'naruto-concurrency-governor.json'), null);
+    const telemetryAgeMs = telemetry?.updated_at ? Math.max(0, Date.now() - Date.parse(telemetry.updated_at)) : Number.MAX_SAFE_INTEGER;
+    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 blockers = [
+        ...(!parallel ? ['parallel_runtime_proof_missing'] : []),
+        ...(!scheduler ? ['agent_scheduler_state_missing'] : []),
+        ...(parallel?.passed === false ? parallel.blockers || ['parallel_runtime_proof_failed'] : []),
+        ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : [])
+    ].map(String);
+    const summary = {
+        schema: RUNTIME_PROOF_SUMMARY_SCHEMA,
+        ok: blockers.length === 0,
+        mission_id: missionId,
+        generated_at: new Date().toISOString(),
+        parallel: {
+            max_active_workers: Number(parallel?.max_observed_active_workers || scheduler?.max_observed_active_slots || 0),
+            unique_worker_pids: Number(parallel?.unique_worker_pids || uniqueNumbers(swarm?.process_ids).length || 0),
+            speedup_ratio: Number(parallel?.speedup_ratio || 0),
+            proof_passed: parallel?.passed === true
+        },
+        ui: {
+            visible_panes: visiblePanes,
+            headless_workers: headlessWorkers,
+            telemetry_age_ms: telemetryAgeMs,
+            stale: telemetryAgeMs > 3000
+        },
+        model_calls: {
+            max_observed: Number(parallel?.max_observed_model_calls || 0),
+            unique_model_call_ids: Number(parallel?.unique_model_call_ids || 0)
+        },
+        scheduler: {
+            largest_batch_size: Number(scheduler?.largest_batch_size || 0),
+            utilization: Number(scheduler?.scheduler_utilization || 0)
+        },
+        blockers
+    };
+    await writeJsonAtomic(path.join(agentsDir, 'runtime-proof-summary.json'), summary);
+    return summary;
+}
+export function renderRuntimeProofSummary(summary) {
+    return [
+        `Parallel proof: ${summary.parallel.proof_passed ? 'passed' : 'blocked'}`,
+        `Active workers: ${summary.parallel.max_active_workers}`,
+        `Unique PIDs: ${summary.parallel.unique_worker_pids}`,
+        `Speedup: ${summary.parallel.speedup_ratio}x`,
+        `Visible/headless: ${summary.ui.visible_panes} / ${summary.ui.headless_workers}`,
+        `Telemetry: ${summary.ui.stale ? `stale ${(summary.ui.telemetry_age_ms / 1000).toFixed(1)}s` : `fresh ${(summary.ui.telemetry_age_ms / 1000).toFixed(1)}s`}`,
+        `Model calls max: ${summary.model_calls.max_observed}`,
+        ...(summary.blockers.length ? [`Blockers: ${summary.blockers.join(', ')}`] : [])
+    ].join('\n');
+}
+function telemetryVisiblePaneCount(snapshot) {
+    const slots = snapshot?.slots && typeof snapshot.slots === 'object' ? Object.values(snapshot.slots) : [];
+    return slots.filter((row) => row?.status && row.status !== 'headless').length;
+}
+function uniqueNumbers(values) {
+    return [...new Set((Array.isArray(values) ? values : []).map((value) => Number(value)).filter((value) => Number.isFinite(value)))];
+}
+//# sourceMappingURL=runtime-proof-summary.js.map

package/dist/core/codex-control/codex-task-runner.js

@@ -16,6 +16,7 @@ import { writeUltraRouterProof } from '../router/router-proof.js';
 import { readLocalModelConfig } from '../agents/ollama-worker-config.js';
 import { runLocalLlmTask } from '../local-llm/local-llm-control-adapter.js';
 import { detectPythonCodexSdkCapability, runPythonCodexSdkTask } from './python-codex-sdk-adapter.js';
+import { defaultModelCallBudget, withModelCallSlot } from './model-call-concurrency.js';
 export async function runCodexTask(input) {
     const root = path.resolve(input.mutationLedgerRoot);
     await ensureDir(root);
@@ -46,7 +47,16 @@ export async function runCodexTask(input) {
     ];
     let adapterResult = null;
     if (!blockers.length) {
-        adapterResult = await runWithCodexReliabilityShield(task, async () => {
+        adapterResult = await withModelCallSlot({
+            root,
+            missionId: task.missionId,
+            provider: 'codex-sdk',
+            budget: defaultModelCallBudget('codex-sdk'),
+            slotId: task.slotId || null,
+            generationIndex: task.generationIndex ?? null,
+            sessionId: task.sessionId || null,
+            backend: 'codex-sdk'
+        }, () => runWithCodexReliabilityShield(task, async () => {
             try {
                 return fakeAllowed
                     ? await runFakeCodexSdkTask(task)
@@ -63,7 +73,7 @@ export async function runCodexTask(input) {
                     blockers: ['codex_sdk_run_failed:' + String(err?.message || err)]
                 };
             }
-        });
+        }));
     }
     const events = Array.isArray(adapterResult?.events) ? adapterResult.events : [];
     const translatedEvents = translateCodexSdkEvents(events);
@@ -153,7 +163,16 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
         await ensureDir(runtime.env.env.CODEX_HOME);
     const fakeAllowed = process.env.SKS_PYTHON_CODEX_SDK_FAKE === '1';
     const adapterResult = capability.ok || fakeAllowed
-        ? await runPythonCodexSdkTask(task, { env: runtime.env.env, config: runtime.config })
+        ? await withModelCallSlot({
+            root,
+            missionId: task.missionId,
+            provider: 'python-codex-sdk',
+            budget: defaultModelCallBudget('python-codex-sdk'),
+            slotId: task.slotId || null,
+            generationIndex: task.generationIndex ?? null,
+            sessionId: task.sessionId || null,
+            backend: 'python-codex-sdk'
+        }, () => runPythonCodexSdkTask(task, { env: runtime.env.env, config: runtime.config }))
         : { ok: false, events: [], translatedEvents: [], finalResponse: '', threadId: '', turnId: '', blockers: capability.blockers, capability };
     const events = Array.isArray(adapterResult.events) ? adapterResult.events : [];
     const translatedEvents = Array.isArray(adapterResult.translatedEvents) ? adapterResult.translatedEvents : [];
@@ -251,7 +270,16 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
 }
 async function runLocalControlTask(root, task, schema, routerDecision) {
     const config = await readLocalModelConfig();
-    const adapterResult = await runLocalLlmTask(task, { config, outputSchema: schema });
+    const adapterResult = await withModelCallSlot({
+        root,
+        missionId: task.missionId,
+        provider: 'local-llm',
+        budget: defaultModelCallBudget('local-llm'),
+        slotId: task.slotId || null,
+        generationIndex: task.generationIndex ?? null,
+        sessionId: task.sessionId || null,
+        backend: 'local-llm'
+    }, () => runLocalLlmTask(task, { config, outputSchema: schema }));
     for (const event of adapterResult.events || [])
         await appendJsonl(path.join(root, 'local-llm-events.jsonl'), event);
     const structuredOutput = adapterResult.structuredOutput;

package/dist/core/codex-control/model-call-concurrency.js

@@ -0,0 +1,106 @@
+import { appendParallelRuntimeEvent } from '../agents/parallel-runtime-proof.js';
+const semaphores = new Map();
+export function getModelCallSemaphore(provider, budget) {
+    const normalizedProvider = String(provider || 'codex-sdk');
+    const normalizedBudget = Math.max(1, Math.floor(Number(budget || 1)));
+    const key = `${normalizedProvider}:${normalizedBudget}`;
+    const existing = semaphores.get(key);
+    if (existing)
+        return existing;
+    const created = new ModelCallSemaphoreImpl(normalizedProvider, normalizedBudget);
+    semaphores.set(key, created);
+    return created;
+}
+export async function withModelCallSlot(input, fn) {
+    const semaphore = getModelCallSemaphore(input.provider, input.budget);
+    const modelCallId = input.modelCallId || `${input.provider}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    return semaphore.run(async () => {
+        await appendParallelRuntimeEvent(input.root, input.missionId, {
+            event_type: 'model_call_started',
+            slot_id: input.slotId ?? null,
+            generation_index: input.generationIndex ?? null,
+            session_id: input.sessionId ?? null,
+            model_call_id: modelCallId,
+            backend: input.backend || input.provider,
+            placement: 'unknown',
+            meta: {
+                provider: input.provider,
+                budget: semaphore.budget,
+                active_model_calls: semaphore.active,
+                queued_model_calls: semaphore.queued
+            }
+        }).catch(() => undefined);
+        try {
+            return await fn();
+        }
+        finally {
+            await appendParallelRuntimeEvent(input.root, input.missionId, {
+                event_type: 'model_call_completed',
+                slot_id: input.slotId ?? null,
+                generation_index: input.generationIndex ?? null,
+                session_id: input.sessionId ?? null,
+                model_call_id: modelCallId,
+                backend: input.backend || input.provider,
+                placement: 'unknown',
+                meta: {
+                    provider: input.provider,
+                    budget: semaphore.budget,
+                    max_observed_model_calls: semaphore.maxObserved,
+                    queued_model_calls: semaphore.queued
+                }
+            }).catch(() => undefined);
+        }
+    });
+}
+export function defaultModelCallBudget(provider) {
+    const text = String(provider || '');
+    if (text === 'local-llm' || text === 'ollama')
+        return envInt('SKS_LOCAL_LLM_MAX_PARALLEL_REQUESTS', 4);
+    return envInt('SKS_REMOTE_API_PARALLEL_BUDGET', 12);
+}
+class ModelCallSemaphoreImpl {
+    provider;
+    budget;
+    active = 0;
+    queued = 0;
+    maxObserved = 0;
+    waiters = [];
+    constructor(provider, budget) {
+        this.provider = provider;
+        this.budget = budget;
+    }
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    async acquire() {
+        if (this.active < this.budget) {
+            this.active += 1;
+            this.maxObserved = Math.max(this.maxObserved, this.active);
+            return;
+        }
+        this.queued += 1;
+        await new Promise((resolve) => this.waiters.push(resolve));
+        this.queued = Math.max(0, this.queued - 1);
+        this.active += 1;
+        this.maxObserved = Math.max(this.maxObserved, this.active);
+    }
+    release() {
+        this.active = Math.max(0, this.active - 1);
+        const next = this.waiters.shift();
+        if (next)
+            next();
+    }
+}
+function envInt(name, fallback) {
+    const parsed = Number(process.env[name]);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return fallback;
+    return Math.floor(parsed);
+}
+//# sourceMappingURL=model-call-concurrency.js.map