sneakoscope 2.0.15 → 2.0.16

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

@@ -10,6 +10,7 @@ import { resolveProviderContext } from '../provider/provider-context.js';
 import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.js';
 import { resolveZellijUiMode } from '../zellij/zellij-ui-mode.js';
 import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
+import { appendParallelRuntimeEvent } from './parallel-runtime-proof.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);
@@ -175,6 +176,16 @@ class NativeCliSessionSwarmRecorder {
         record.pid = child.pid || null;
         record.process_id = child.pid || null;
         record.status = 'running';
+        await appendParallelRuntimeEvent(this.root, this.input.missionId, {
+            event_type: 'worker_process_spawned',
+            slot_id: ctx.agent.slot_id || ctx.agent.id || null,
+            generation_index: ctx.agent.generation_index || null,
+            session_id: ctx.agent.session_id || null,
+            pid: child.pid || null,
+            backend: this.input.backend,
+            placement: record.worker_placement === 'headless' ? 'headless' : 'process',
+            worktree_id: worktree?.id || null
+        }).catch(() => undefined);
         await this.telemetry(ctx, {
             eventType: 'worker_spawned',
             status: 'launching',
@@ -321,6 +332,30 @@ class NativeCliSessionSwarmRecorder {
                 mode: uiMode,
                 watch: true
             });
+        const processRun = uiMode === 'full-debug'
+            ? null
+            : await this.spawnCompactSlotWorkerProcess({
+                args: input.args,
+                cwd: workerCwd,
+                env: workerEnv,
+                stdoutRel: input.stdoutRel,
+                stderrRel: input.stderrRel
+            });
+        if (processRun?.pid) {
+            input.record.pid = processRun.pid;
+            input.record.process_id = processRun.pid;
+            await appendParallelRuntimeEvent(this.root, this.input.missionId, {
+                event_type: 'worker_process_spawned',
+                slot_id: slotId,
+                generation_index: Number(input.ctx.agent.generation_index || 1),
+                session_id: input.ctx.agent.session_id || null,
+                pid: processRun.pid,
+                backend: this.input.backend,
+                placement: 'zellij-pane',
+                worktree_id: worktree?.id || null
+            }).catch(() => undefined);
+            await this.record(input.record);
+        }
         let paneRecord;
         try {
             paneRecord = await openWorkerPane({
@@ -367,7 +402,9 @@ class NativeCliSessionSwarmRecorder {
             if (input.zellijReservation)
                 this.releaseVisibleZellijReservation(input.zellijReservation);
         }
-        const launchBlockers = paneRecord.blockers || [];
+        const zellijRequired = process.env.SKS_REQUIRE_ZELLIJ === '1';
+        const launchBlockers = zellijRequired ? paneRecord.blockers || [] : [];
+        const launchWarnings = zellijRequired ? [] : paneRecord.blockers || [];
         input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', uiMode === 'full-debug' ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
         input.record.zellij_session_name = sessionName;
         input.record.zellij_pane_id = paneRecord.pane_id || null;
@@ -385,6 +422,7 @@ class NativeCliSessionSwarmRecorder {
         input.record.slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
+        input.record.warnings = [...(input.record.warnings || []), ...launchWarnings];
         await this.telemetry(input.ctx, {
             eventType: 'worker_spawned',
             status: launchBlockers.length ? 'failed' : 'launching',
@@ -422,27 +460,18 @@ class NativeCliSessionSwarmRecorder {
                 goal_mode_ref: input.ctx.agent.goal_mode_ref || null
             });
         }
-        const processRun = uiMode === 'full-debug'
-            ? null
-            : await this.spawnCompactSlotWorkerProcess({
-                args: input.args,
-                cwd: workerCwd,
-                env: workerEnv,
-                stdoutRel: input.stdoutRel,
-                stderrRel: input.stderrRel
+        const heartbeatSeen = await waitForWorkerHeartbeat(path.join(this.root, input.heartbeatRel), Number(process.env.SKS_ZELLIJ_WORKER_HEARTBEAT_TIMEOUT_MS || 5000));
+        if (heartbeatSeen) {
+            await this.telemetry(input.ctx, {
+                eventType: 'heartbeat',
+                status: 'running',
+                artifacts: [input.heartbeatRel],
+                logTail: await tailFile(path.join(this.root, input.heartbeatRel), 600)
             });
-        if (processRun?.pid) {
-            input.record.pid = processRun.pid;
-            input.record.process_id = processRun.pid;
-            await this.record(input.record);
         }
-        await waitForWorkerHeartbeat(path.join(this.root, input.heartbeatRel), Number(process.env.SKS_ZELLIJ_WORKER_HEARTBEAT_TIMEOUT_MS || 30000));
-        await this.telemetry(input.ctx, {
-            eventType: 'heartbeat',
-            status: 'running',
-            artifacts: [input.heartbeatRel],
-            logTail: await tailFile(path.join(this.root, input.heartbeatRel), 600)
-        });
+        else {
+            input.record.warnings = [...(input.record.warnings || []), 'zellij_worker_heartbeat_missing_launch_warning'];
+        }
         await appendJsonl(path.join(this.root, input.workerDirRel, 'zellij-worker-pane-events.jsonl'), {
             schema: 'sks.zellij-worker-pane-event.v1',
             ts: nowIso(),
@@ -505,8 +534,10 @@ class NativeCliSessionSwarmRecorder {
         const heartbeatOk = await hasHeartbeat(path.join(this.root, input.heartbeatRel));
         input.record.blockers = [
             ...(parsed ? parsed.blockers || [] : ['zellij_worker_result_timeout']),
-            ...(heartbeatOk ? [] : ['zellij_worker_heartbeat_missing'])
+            ...(heartbeatOk ? [] : [])
         ];
+        if (!heartbeatOk)
+            input.record.warnings = [...(input.record.warnings || []), 'zellij_worker_heartbeat_missing'];
         paneRecord = await closeWorkerPane({
             root: this.root,
             paneRecord,
@@ -593,6 +624,24 @@ class NativeCliSessionSwarmRecorder {
             log_tail: input.logTail || '',
             blockers: input.blockers || []
         }).catch(() => undefined);
+        const parallelEvent = mapTelemetryToParallelEvent(input.eventType);
+        if (parallelEvent) {
+            await appendParallelRuntimeEvent(this.root, this.input.missionId, {
+                event_type: parallelEvent,
+                slot_id: String(ctx.agent?.slot_id || ctx.agent?.id || 'slot-001'),
+                generation_index: Number(ctx.agent?.generation_index || 1),
+                session_id: ctx.agent?.session_id == null ? null : String(ctx.agent.session_id),
+                pid: null,
+                backend: this.input.backend,
+                placement: normalizeParallelPlacement(ctx.opts?.workerPlacement || this.input.workerPlacement || (input.status === 'headless' ? 'headless' : 'unknown')),
+                worktree_id: ctx.agent?.worktree?.id || ctx.slice?.worktree?.id || null,
+                meta: {
+                    status: input.status,
+                    artifacts: input.artifacts || [],
+                    blockers: input.blockers || []
+                }
+            }).catch(() => undefined);
+        }
     }
     async persist() {
         this.writeLock = this.writeLock.catch(() => undefined).then(async () => {
@@ -765,6 +814,23 @@ function firstString(values) {
     }
     return null;
 }
+function mapTelemetryToParallelEvent(eventType) {
+    if (eventType === 'slot_reserved')
+        return 'slot_reserved';
+    if (eventType === 'heartbeat')
+        return 'worker_heartbeat_seen';
+    if (eventType === 'worker_completed')
+        return 'worker_completed';
+    if (eventType === 'worker_failed')
+        return 'worker_failed';
+    return null;
+}
+function normalizeParallelPlacement(value) {
+    const text = String(value || '');
+    if (text === 'zellij-pane' || text === 'process' || text === 'headless')
+        return text;
+    return 'unknown';
+}
 async function tailFile(file, max) {
     try {
         const text = await fs.promises.readFile(file, 'utf8');

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

@@ -0,0 +1,217 @@
+import path from 'node:path';
+import { appendJsonlBounded, ensureDir, nowIso, 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 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 blockers = [
+        ...(sorted.length ? [] : ['parallel_runtime_events_missing']),
+        ...(minActiveWorkers <= 0 || maxWorkers >= minActiveWorkers ? [] : ['max_observed_active_workers_below_target']),
+        ...(requestedWorkers >= 16 && workerPids.size && workerPids.size < minActiveWorkers ? ['unique_worker_pids_below_target'] : []),
+        ...(speedupRatio >= minSpeedup ? [] : ['speedup_ratio_below_target']),
+        ...(firstBatchLaunchSpanMs <= firstBatchLimit ? [] : ['first_batch_launch_span_above_limit'])
+    ];
+    return {
+        schema: PARALLEL_RUNTIME_PROOF_SCHEMA,
+        mission_id: missionId,
+        generated_at: nowIso(),
+        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: coalesceOverlapWindows(overlapWindows),
+        visible_panes: visiblePanes,
+        headless_workers: headlessWorkers,
+        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 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/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