sneakoscope 8.0.2 → 8.0.4

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

@@ -7,6 +7,7 @@ import { closeAgentSessionGeneration, createAgentSessionGeneration, writeAgentSe
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
 export const AGENT_SCHEDULER_SCHEMA = 'sks.agent-scheduler.v1';
 export const AGENT_SCHEDULER_EVENT_SCHEMA = 'sks.agent-scheduler-event.v1';
+export const DEFAULT_AGENT_SCHEDULER_MAX_WALL_MS = 30 * 60 * 1000;
 export async function runAgentScheduler(input) {
     const maxActiveSlots = Number.isFinite(Number(input.maxActiveSlots)) && Number(input.maxActiveSlots) >= 1 ? Math.floor(Number(input.maxActiveSlots)) : MAX_AGENT_COUNT;
     const targetActiveSlots = normalizeTargetActiveSlots(input.targetActiveSlots ?? input.roster?.concurrency ?? input.roster?.agent_count ?? DEFAULT_AGENT_CONCURRENCY, maxActiveSlots);
@@ -21,100 +22,191 @@ export async function runAgentScheduler(input) {
     const active = new Map();
     const results = [];
     const schedulerStartedAt = Date.now();
+    const maxWallMs = normalizeSchedulerMaxWallMs(input.maxWallMs);
+    const stopSignal = createSchedulerStopSignal(maxWallMs, input.signal);
     let lastUtilizationUpdateMs = schedulerStartedAt;
     let activeSlotTimeMs = 0;
     let batchCounter = 0;
     let batchLaunchSpanTotalMs = 0;
     let batchDispatchInProgress = false;
+    let terminalStopReason = null;
     let state = buildState(input.missionId, targetActiveSlots, queue, slots, active, {
         status: 'initializing',
         refillDelayMs: input.refillDelayMs || 0,
         rateLimitBackoffMs: input.rateLimitBackoffMs || 0
     });
-    await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_initialized' }, input.onSchedulerEvent);
-    await refillSlots(null);
-    while (active.size > 0 || pendingWorkItems(queue).length > 0) {
-        if (!batchDispatchInProgress && active.size === 0 && pendingWorkItems(queue).length > 0) {
-            state.blockers.push('scheduler_pending_queue_without_active_sessions');
-            state.status = 'blocked';
-            await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_blocked', pending_count: pendingWorkItems(queue).length }, input.onSchedulerEvent);
-            break;
-        }
-        const settled = await Promise.race([...active.values()].map((entry) => entry.promise));
-        const entry = active.get(settled.session_id);
-        if (!entry)
-            continue;
-        const activeCountBeforeClose = active.size;
-        accumulateActiveSlotTime();
-        active.delete(settled.session_id);
-        const resultStatus = settled.result?.status === 'done' ? 'completed' : settled.result?.status === 'blocked' ? 'blocked' : 'failed';
-        completeWorkItem(queue, entry.work_item_id, settled.session_id, resultStatus, settled.error || null);
-        const slotIndex = slots.findIndex((slot) => slot.slot_id === entry.slot_id);
-        const closingSlot = slotIndex >= 0 ? slots[slotIndex] : null;
-        if (slotIndex >= 0 && closingSlot)
-            slots[slotIndex] = markWorkerSlotGenerationClosed(closingSlot, settled.session_id, resultStatus);
-        await closeAgentSessionGeneration(input.root, settled.session_id, {
-            status: resultStatus === 'completed' ? 'closed' : resultStatus,
-            resultArtifactPath: settled.result?.artifacts?.[0] || null,
-            terminalCloseReportPath: settled.terminal_close_report_path || path.join('sessions', entry.slot_id, `gen-${settled.generation_index}`, 'agent-terminal-close-report.json')
-        });
-        results.push(settled.result);
-        const followUps = Array.isArray(settled.result?.follow_up_work_items) ? settled.result.follow_up_work_items : [];
-        if (followUps.length) {
-            const enqueue = enqueueFollowUpWorkItems(queue, followUps, {
-                originSessionId: settled.session_id,
-                sourceIntelligenceRefs: input.sourceIntelligenceRefs || null,
-                goalModeRef: input.goalModeRef || null
+    try {
+        await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_initialized' }, input.onSchedulerEvent);
+        const initialStopReason = stopSignal.currentReason();
+        if (initialStopReason)
+            await stopScheduler(initialStopReason);
+        else
+            await refillSlots(null);
+        while (active.size > 0 || unfinishedWorkItems(queue).length > 0) {
+            const immediateStopReason = stopSignal.currentReason();
+            if (immediateStopReason) {
+                await stopScheduler(immediateStopReason);
+                break;
+            }
+            if (!batchDispatchInProgress && active.size === 0) {
+                const ready = pendingWorkItems(queue);
+                if (ready.length > 0) {
+                    await refillSlots(null);
+                    if (active.size > 0)
+                        continue;
+                }
+                await stopScheduler(ready.length > 0
+                    ? 'scheduler_ready_queue_without_launchable_slot'
+                    : 'scheduler_unresolvable_dependencies');
+                break;
+            }
+            const settled = await Promise.race([
+                ...[...active.values()].map((entry) => entry.promise),
+                stopSignal.promise
+            ]);
+            if (isSchedulerStopSignal(settled)) {
+                await stopScheduler(settled.scheduler_stop_reason);
+                break;
+            }
+            const entry = active.get(settled.session_id);
+            if (!entry)
+                continue;
+            const activeCountBeforeClose = active.size;
+            accumulateActiveSlotTime();
+            active.delete(settled.session_id);
+            const resultStatus = settled.result?.status === 'done' ? 'completed' : settled.result?.status === 'blocked' ? 'blocked' : 'failed';
+            completeWorkItem(queue, entry.work_item_id, settled.session_id, resultStatus, settled.error || null);
+            if (resultStatus !== 'completed')
+                addUniqueBlocker(state, `scheduler_work_item_${resultStatus}:${entry.work_item_id}`);
+            const slotIndex = slots.findIndex((slot) => slot.slot_id === entry.slot_id);
+            const closingSlot = slotIndex >= 0 ? slots[slotIndex] : null;
+            if (slotIndex >= 0 && closingSlot)
+                slots[slotIndex] = markWorkerSlotGenerationClosed(closingSlot, settled.session_id, resultStatus);
+            await closeAgentSessionGeneration(input.root, settled.session_id, {
+                status: resultStatus === 'completed' ? 'closed' : resultStatus,
+                resultArtifactPath: settled.result?.artifacts?.[0] || null,
+                terminalCloseReportPath: settled.terminal_close_report_path || path.join('sessions', entry.slot_id, `gen-${settled.generation_index}`, 'agent-terminal-close-report.json')
             });
-            if (enqueue.blocked.length)
-                state.blockers.push(...enqueue.blocked);
-            await appendAgentWorkQueueEvent(input.root, 'follow_up_work_items_enqueued', { accepted: enqueue.accepted.length, blocked: enqueue.blocked_count });
+            results.push(settled.result);
+            const followUps = resultStatus === 'completed' && Array.isArray(settled.result?.follow_up_work_items) ? settled.result.follow_up_work_items : [];
+            if (followUps.length) {
+                const enqueue = enqueueFollowUpWorkItems(queue, followUps, {
+                    originSessionId: settled.session_id,
+                    sourceIntelligenceRefs: input.sourceIntelligenceRefs || null,
+                    goalModeRef: input.goalModeRef || null
+                });
+                if (enqueue.blocked.length)
+                    state.blockers.push(...enqueue.blocked);
+                await appendAgentWorkQueueEvent(input.root, 'follow_up_work_items_enqueued', { accepted: enqueue.accepted.length, blocked: enqueue.blocked_count });
+            }
+            const pendingAfterClose = pendingWorkItems(queue).length;
+            if (pendingAfterClose > 0)
+                state.expected_backfill_count += 1;
+            updateUtilizationMetrics();
+            await writeAll(input.root, state, slots, queue, active, {
+                event_type: 'session_completed',
+                session_id: settled.session_id,
+                slot_id: entry.slot_id,
+                work_item_id: entry.work_item_id,
+                active_count_before_close: activeCountBeforeClose,
+                active_count_after_close: active.size,
+                pending_count_after_close: pendingAfterClose
+            }, input.onSchedulerEvent);
+            await refillSlots(pendingAfterClose > 0 ? {
+                closed_session_id: settled.session_id,
+                active_count_before: active.size,
+                closed_at_ms: Date.now()
+            } : null);
         }
-        const pendingAfterClose = pendingWorkItems(queue).length;
-        if (pendingAfterClose > 0)
-            state.expected_backfill_count += 1;
         updateUtilizationMetrics();
+        state.status = state.blockers.length ? 'blocked' : 'draining';
+        await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_draining' }, input.onSchedulerEvent);
+        slots = closeWorkerSlotsAfterDrain(slots);
+        state = buildState(input.missionId, targetActiveSlots, queue, slots, active, {
+            previous: state,
+            status: state.blockers.length ? 'blocked' : 'drained',
+            refillDelayMs: input.refillDelayMs || 0,
+            rateLimitBackoffMs: input.rateLimitBackoffMs || 0
+        });
+        state.pending_queue_drained = unfinishedWorkItems(queue).length === 0;
+        state.all_slots_closed_after_drain = slots.every((slot) => slot.status === 'closed');
+        state.all_generations_closed = active.size === 0 && slots.every((slot) => slot.history.every((entry) => Boolean(entry.closed_at) && entry.status !== 'running'));
+        if (!state.pending_queue_drained)
+            addUniqueBlocker(state, 'scheduler_pending_queue_not_drained');
+        if (!state.all_generations_closed)
+            addUniqueBlocker(state, 'scheduler_generations_not_closed');
+        state.status = state.blockers.length ? 'blocked' : 'drained';
+        state.stop_reason = terminalStopReason || (state.blockers.length ? 'scheduler_completed_with_blockers' : null);
+        state.completion_claim_allowed = state.status === 'drained';
+        updateUtilizationMetrics();
+        await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_drained' }, input.onSchedulerEvent);
+        return {
+            schema: 'sks.agent-scheduler-result.v1',
+            ok: state.completion_claim_allowed,
+            state,
+            queue,
+            slots,
+            results
+        };
+    }
+    finally {
+        stopSignal.dispose();
+    }
+    async function stopScheduler(reason) {
+        if (terminalStopReason)
+            return;
+        terminalStopReason = reason;
+        state.status = 'blocked';
+        state.stop_reason = reason;
+        state.completion_claim_allowed = false;
+        addUniqueBlocker(state, reason);
+        const cleanup = await invokeBoundedStop(input.onStop, reason);
+        if (!cleanup.ok)
+            addUniqueBlocker(state, cleanup.blocker);
+        const activeEntries = [...active.values()];
+        const activeWorkItemIds = new Set(activeEntries.map((entry) => entry.work_item_id));
+        for (const entry of activeEntries) {
+            completeWorkItem(queue, entry.work_item_id, entry.session_id, 'blocked', reason);
+            const slotIndex = slots.findIndex((slot) => slot.slot_id === entry.slot_id);
+            const currentSlot = slotIndex >= 0 ? slots[slotIndex] : null;
+            if (slotIndex >= 0 && currentSlot)
+                slots[slotIndex] = markWorkerSlotGenerationClosed(currentSlot, entry.session_id, 'blocked');
+            results.push(schedulerStoppedResult(input.missionId, entry, reason));
+        }
+        await Promise.all(activeEntries.map((entry) => closeAgentSessionGeneration(input.root, entry.session_id, {
+            status: 'blocked',
+            terminalCloseReportPath: null
+        }).catch(() => null)));
+        active.clear();
+        for (const item of queue.items) {
+            if (item.status !== 'pending' && item.status !== 'running')
+                continue;
+            if (!activeWorkItemIds.has(item.id)) {
+                results.push(schedulerStoppedResult(input.missionId, {
+                    slot_id: 'scheduler',
+                    work_item_id: item.id,
+                    session_id: item.running_session_id || `unlaunched:${item.id}`
+                }, reason));
+            }
+            item.status = 'blocked';
+            item.running_session_id = null;
+            item.blocked_reason = reason;
+        }
+        queue.updated_at = nowIso();
         await writeAll(input.root, state, slots, queue, active, {
-            event_type: 'session_completed',
-            session_id: settled.session_id,
-            slot_id: entry.slot_id,
-            work_item_id: entry.work_item_id,
-            active_count_before_close: activeCountBeforeClose,
-            active_count_after_close: active.size,
-            pending_count_after_close: pendingAfterClose
+            event_type: 'scheduler_terminal_unverified',
+            stop_reason: reason,
+            completion_claim_allowed: false
         }, input.onSchedulerEvent);
-        await refillSlots(pendingAfterClose > 0 ? {
-            closed_session_id: settled.session_id,
-            active_count_before: active.size,
-            closed_at_ms: Date.now()
-        } : null);
     }
-    updateUtilizationMetrics();
-    state.status = 'draining';
-    await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_draining' }, input.onSchedulerEvent);
-    slots = closeWorkerSlotsAfterDrain(slots);
-    state = buildState(input.missionId, targetActiveSlots, queue, slots, active, {
-        previous: state,
-        status: state.blockers.length ? 'blocked' : 'drained',
-        refillDelayMs: input.refillDelayMs || 0,
-        rateLimitBackoffMs: input.rateLimitBackoffMs || 0
-    });
-    state.pending_queue_drained = pendingWorkItems(queue).length === 0;
-    state.all_slots_closed_after_drain = slots.every((slot) => slot.status === 'closed');
-    state.all_generations_closed = true;
-    if (!state.pending_queue_drained)
-        state.blockers.push('scheduler_pending_queue_not_drained');
-    updateUtilizationMetrics();
-    await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_drained' }, input.onSchedulerEvent);
-    return {
-        schema: 'sks.agent-scheduler-result.v1',
-        ok: state.blockers.length === 0,
-        state,
-        queue,
-        slots,
-        results
-    };
     async function refillSlots(backfill) {
+        if (terminalStopReason)
+            return;
+        const stopReason = stopSignal.currentReason();
+        if (stopReason) {
+            await stopScheduler(stopReason);
+            return;
+        }
         state.status = 'running';
         const launches = collectLaunchBatch();
         if (!launches.length)
@@ -252,8 +344,16 @@ export async function runAgentScheduler(input) {
                         active_count_after: active.size
                     });
             }
-            if (input.refillDelayMs && input.refillDelayMs > 0)
-                await delay(input.refillDelayMs);
+            if (input.refillDelayMs && input.refillDelayMs > 0) {
+                const delayed = await Promise.race([
+                    delay(input.refillDelayMs).then(() => null),
+                    stopSignal.promise
+                ]);
+                if (isSchedulerStopSignal(delayed)) {
+                    await stopScheduler(delayed.scheduler_stop_reason);
+                    return;
+                }
+            }
             const launchSpanMs = Math.max(0, Date.now() - batchStart);
             batchLaunchSpanTotalMs += launchSpanMs;
             state.batch_dispatch_count += 1;
@@ -282,6 +382,10 @@ export async function runAgentScheduler(input) {
                 session_ids: launches.map((launch) => launch.generation.session_id)
             }, input.onSchedulerEvent);
         }
+        catch (error) {
+            addUniqueBlocker(state, `scheduler_batch_dispatch_error:${errorMessage(error)}`);
+            await stopScheduler('scheduler_batch_dispatch_failed');
+        }
         finally {
             batchDispatchInProgress = false;
         }
@@ -350,13 +454,19 @@ export function normalizeTargetActiveSlots(value, maxActiveSlots = MAX_AGENT_COU
 }
 function buildState(missionId, targetActiveSlots, queue, slots, active, opts) {
     const previous = opts.previous;
-    const pendingCount = pendingWorkItems(queue).length;
+    const pendingCount = queue.items.filter((item) => item.status === 'pending').length;
     const completed = queue.items.filter((item) => item.status === 'completed').map((item) => item.id);
     const failed = queue.items.filter((item) => item.status === 'failed').map((item) => item.id);
     const blocked = queue.items.filter((item) => item.status === 'blocked').map((item) => item.id);
+    const blockers = [...(previous?.blockers || [])];
+    const completionClaimAllowed = opts.status === 'drained'
+        && blockers.length === 0
+        && unfinishedWorkItems(queue).length === 0
+        && active.size === 0;
+    const updatedAt = nowIso();
     return {
         schema: AGENT_SCHEDULER_SCHEMA,
-        updated_at: nowIso(),
+        updated_at: updatedAt,
         mission_id: missionId,
         status: opts.status,
         target_active_slots: targetActiveSlots,
@@ -380,10 +490,13 @@ function buildState(missionId, targetActiveSlots, queue, slots, active, opts) {
         completed,
         failed,
         blocked,
-        pending_queue_drained: pendingCount === 0,
+        pending_queue_drained: unfinishedWorkItems(queue).length === 0,
         all_slots_closed_after_drain: slots.length > 0 && slots.every((slot) => slot.status === 'closed'),
-        all_generations_closed: false,
-        blockers: [...(previous?.blockers || [])],
+        all_generations_closed: active.size === 0 && slots.every((slot) => slot.history.every((entry) => Boolean(entry.closed_at) && entry.status !== 'running')),
+        stop_reason: previous?.stop_reason || null,
+        completion_claim_allowed: completionClaimAllowed,
+        runtime_evidence: schedulerRuntimeEvidence(completionClaimAllowed, opts.status, blockers, updatedAt),
+        blockers,
         batch_dispatch_count: previous?.batch_dispatch_count || 0,
         largest_batch_size: previous?.largest_batch_size || 0,
         first_batch_launch_span_ms: previous?.first_batch_launch_span_ms || 0,
@@ -418,6 +531,10 @@ async function writeAll(root, currentState, slots, queue, active, event, onSched
     currentState.blocked = nextState.blocked;
     currentState.pending_queue_drained = nextState.pending_queue_drained;
     currentState.all_slots_closed_after_drain = nextState.all_slots_closed_after_drain;
+    currentState.all_generations_closed = nextState.all_generations_closed;
+    currentState.stop_reason = nextState.stop_reason;
+    currentState.completion_claim_allowed = nextState.completion_claim_allowed;
+    currentState.runtime_evidence = nextState.runtime_evidence;
     currentState.batch_dispatch_count = nextState.batch_dispatch_count;
     currentState.largest_batch_size = nextState.largest_batch_size;
     currentState.first_batch_launch_span_ms = nextState.first_batch_launch_span_ms;
@@ -430,7 +547,23 @@ async function writeAll(root, currentState, slots, queue, active, event, onSched
     await writeJsonAtomic(path.join(root, 'agent-scheduler-state.json'), currentState);
     const entry = { schema: AGENT_SCHEDULER_EVENT_SCHEMA, ts: nowIso(), ...event };
     await appendJsonl(path.join(root, 'agent-scheduler-events.jsonl'), entry);
-    await onSchedulerEvent?.({ event: entry, state: currentState, slots, queue });
+    if (onSchedulerEvent) {
+        const callback = await invokeBoundedSchedulerCallback(onSchedulerEvent, { event: entry, state: currentState, slots, queue });
+        if (!callback.ok) {
+            addUniqueBlocker(currentState, callback.blocker);
+            currentState.status = 'blocked';
+            currentState.stop_reason = currentState.stop_reason || 'scheduler_event_callback_failed';
+            currentState.completion_claim_allowed = false;
+            currentState.runtime_evidence = schedulerRuntimeEvidence(false, 'blocked', currentState.blockers, nowIso());
+            await writeJsonAtomic(path.join(root, 'agent-scheduler-state.json'), currentState);
+            await appendJsonl(path.join(root, 'agent-scheduler-events.jsonl'), {
+                schema: AGENT_SCHEDULER_EVENT_SCHEMA,
+                ts: nowIso(),
+                event_type: 'scheduler_event_callback_failed',
+                blocker: callback.blocker
+            });
+        }
+    }
 }
 function buildAgentForGeneration(slot, generation, workItem) {
     const persona = slot.persona_assignment || {};
@@ -461,6 +594,115 @@ function activeWritePaths(queue) {
         .map((file) => String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, ''))
         .filter(Boolean);
 }
+function unfinishedWorkItems(queue) {
+    return queue.items.filter((item) => item.status === 'pending' || item.status === 'running');
+}
+function normalizeSchedulerMaxWallMs(value) {
+    const parsed = Number(value ?? DEFAULT_AGENT_SCHEDULER_MAX_WALL_MS);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return DEFAULT_AGENT_SCHEDULER_MAX_WALL_MS;
+    return Math.max(10, Math.min(Math.floor(parsed), 24 * 60 * 60 * 1000));
+}
+function createSchedulerStopSignal(maxWallMs, signal) {
+    let currentReason = signal?.aborted ? 'scheduler_external_abort' : null;
+    let resolveStop = () => undefined;
+    const promise = new Promise((resolve) => {
+        resolveStop = resolve;
+        if (currentReason)
+            resolve({ scheduler_stop_reason: currentReason });
+    });
+    const stop = (reason) => {
+        if (currentReason)
+            return;
+        currentReason = reason;
+        resolveStop({ scheduler_stop_reason: reason });
+    };
+    const timer = setTimeout(() => stop('scheduler_wall_time_budget_exhausted'), maxWallMs);
+    const abort = () => stop('scheduler_external_abort');
+    signal?.addEventListener('abort', abort, { once: true });
+    return {
+        promise,
+        currentReason: () => currentReason,
+        dispose: () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+        }
+    };
+}
+function isSchedulerStopSignal(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.scheduler_stop_reason === 'string');
+}
+function addUniqueBlocker(state, blocker) {
+    if (blocker && !state.blockers.includes(blocker))
+        state.blockers.push(blocker);
+}
+function schedulerRuntimeEvidence(completionClaimAllowed, status, blockers, observedAt) {
+    if (completionClaimAllowed) {
+        return {
+            schema: 'sks.runtime-evidence.v1',
+            runtime_status: 'proven',
+            evidence_source: 'runtime',
+            receipts: [{ command: 'runAgentScheduler', exit_code: 0, observed_at: observedAt }],
+            blockers: []
+        };
+    }
+    return {
+        schema: 'sks.runtime-evidence.v1',
+        runtime_status: status === 'blocked' ? 'blocked' : 'partial',
+        evidence_source: 'runtime',
+        receipts: [],
+        blockers: [...blockers]
+    };
+}
+async function invokeBoundedStop(callback, reason) {
+    if (!callback)
+        return { ok: true, blocker: '' };
+    return boundedCallback(() => callback(reason), 10_000, 'scheduler_stop_cleanup_timeout', 'scheduler_stop_cleanup_failed');
+}
+async function invokeBoundedSchedulerCallback(callback, ctx) {
+    return boundedCallback(() => callback(ctx), 30_000, 'scheduler_event_callback_timeout', 'scheduler_event_callback_failed');
+}
+async function boundedCallback(callback, timeoutMs, timeoutBlocker, errorPrefix) {
+    let timer = null;
+    try {
+        return await Promise.race([
+            Promise.resolve()
+                .then(callback)
+                .then(() => ({ ok: true, blocker: '' }))
+                .catch((error) => ({ ok: false, blocker: `${errorPrefix}:${errorMessage(error)}` })),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve({ ok: false, blocker: timeoutBlocker }), timeoutMs);
+            })
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function schedulerStoppedResult(missionId, entry, reason) {
+    return {
+        schema: 'sks.agent-result.v1',
+        mission_id: missionId,
+        agent_id: entry.slot_id,
+        session_id: entry.session_id,
+        task_slice_id: entry.work_item_id,
+        status: 'blocked',
+        backend: 'scheduler',
+        summary: `Scheduler stopped before runtime completion: ${reason}`,
+        blockers: [reason],
+        unverified: ['worker_runtime_completion'],
+        changed_files: [],
+        artifacts: [],
+        verification: { status: 'unverified', checks: [] },
+        completion_claim_allowed: false
+    };
+}
+function errorMessage(error) {
+    return (error instanceof Error ? error.message : String(error || 'unknown_error'))
+        .replace(/\s+/g, ' ')
+        .slice(0, 240);
+}
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

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

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

package/dist/core/agents/agent-trust-report.js

@@ -1,11 +1,7 @@
 import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { OFFICIAL_SUBAGENT_EXECUTION_ARTIFACTS, OFFICIAL_SUBAGENT_EXECUTION_AUTHORITY } from '../proof/fake-real-proof-policy.js';
-import { readZellijLaneSupervisor } from './zellij-lane-supervisor.js';
 export async function writeAgentTrustReport(root, input = {}) {
-    const laneSupervisor = await readZellijLaneSupervisor(root);
-    const zellijRuntimeManifest = await readJson(path.join(root, 'zellij-lane-runtime.json'), null);
-    const zellijPaneProof = await readJson(path.join(root, 'zellij-pane-proof.json'), null);
     const cleanupProof = await readJson(path.join(root, 'agent-cleanup-proof.json'), null);
     const intelligentWorkGraph = await readJson(path.join(root, 'agent-intelligent-work-graph.json'), null);
     const fakeRealPolicy = await readJson(path.join(root, 'fake-real-proof-policy.json'), null);
@@ -30,14 +26,12 @@ export async function writeAgentTrustReport(root, input = {}) {
         else if (/blocked|failed|missing/.test(status))
             runtimeTruthGroups.Blocked.push(label);
     };
-    pushTruth(zellijPaneProof?.ok === true ? 'passed' : zellijPaneProof ? 'blocked' : 'not_run', 'Zellij pane proof');
     pushTruth(cleanupProof?.ok === true ? 'passed' : cleanupProof ? 'blocked' : 'not_run', 'cleanup executor');
     pushTruth(intelligentWorkGraph?.ok === true ? 'passed' : intelligentWorkGraph ? 'partial' : 'not_run', 'intelligent work graph');
     pushTruth(officialSubagentExecution?.proof_level || 'not_run', 'official Codex subagent execution');
     const subsystemProofLevels = {
         ...(fakeRealPolicy?.subsystem_levels || {}),
         ...Object.fromEntries((runtimeTruthMatrix?.rows || runtimeTruthMatrix?.subsystems || []).map((row) => [row.subsystem, row.proof_level])),
-        zellij_pane: runtimeTruthMatrix?.rows?.find?.((row) => row.subsystem === 'zellij_pane')?.proof_level || fakeRealPolicy?.subsystem_levels?.zellij_pane || (zellijPaneProof?.ok === true ? 'proven' : zellijPaneProof ? 'blocked' : 'not_run'),
         cleanup: runtimeTruthMatrix?.rows?.find?.((row) => row.subsystem === 'cleanup')?.proof_level || fakeRealPolicy?.subsystem_levels?.cleanup || (cleanupProof?.ok === true ? 'proven' : cleanupProof ? 'blocked' : 'not_run'),
         intelligent_work_graph: runtimeTruthMatrix?.rows?.find?.((row) => row.subsystem === 'intelligent_work_graph')?.proof_level || fakeRealPolicy?.subsystem_levels?.intelligent_work_graph || intelligentWorkGraph?.proof_level || (intelligentWorkGraph ? 'partial' : 'not_run')
     };
@@ -64,31 +58,10 @@ export async function writeAgentTrustReport(root, input = {}) {
             expected_backfill_count: input.proof?.expected_backfill_count ?? input.scheduler?.expected_backfill_count ?? null,
             pending_queue_drained: input.proof?.pending_queue_drained ?? input.scheduler?.pending_queue_drained ?? null,
             generation_count: input.proof?.generation_count ?? null,
-            zellij_attach_command: input.missionId ? `zellij attach sks-${input.missionId}` : null,
-            zellij_lane_manifest: 'agent-zellij-lanes.json',
-            zellij_lane_persistence: {
-                supervisor: 'agent-zellij-lane-supervisor.json',
-                runtime_manifest: zellijRuntimeManifest ? 'zellij-lane-runtime.json' : null,
-                dispatch_mode: laneSupervisor?.dispatch_mode || zellijRuntimeManifest?.dispatch_mode || null,
-                fifo_policy: laneSupervisor?.fifo_policy || zellijRuntimeManifest?.fifo_policy || null,
-                resource_throttle_ms: laneSupervisor?.resource_throttle_ms || zellijRuntimeManifest?.resource_throttle_ms || null,
-                nice_level: laneSupervisor?.nice_level ?? zellijRuntimeManifest?.nice_level ?? null,
-                runtime_policy_ok: Array.isArray(laneSupervisor?.lanes) && laneSupervisor.lanes.every((lane) => lane?.dispatch_mode === 'jsonl_nonblocking' && lane?.command_inbox && lane?.state_dir),
-                pane_id_source_ok: Array.isArray(laneSupervisor?.lanes) && laneSupervisor.lanes.every((lane) => typeof lane?.pane_id_source === 'string' && lane.pane_id_source.length > 0),
-                no_flicker_verified: laneSupervisor?.no_flicker_verified === true,
-                pane_survival_checked: laneSupervisor?.pane_survival_checked === true,
-                unexpected_close_count: laneSupervisor?.unexpected_close_count || 0,
-                lane_count: laneSupervisor?.lane_count || 0,
-                pane_proof_ok: zellijPaneProof?.ok === true,
-                pane_proof_status: zellijPaneProof ? (zellijPaneProof.ok === true ? 'passed' : 'blocked') : 'not_run',
-                pane_proof: zellijPaneProof ? 'zellij-pane-proof.json' : null,
-                pane_count: zellijPaneProof?.pane_count ?? null
-            },
             cleanup_executor: {
                 status: cleanupProof?.ok === true ? 'passed' : cleanupProof ? 'blocked' : 'not_run',
                 proof: cleanupProof ? 'agent-cleanup-proof.json' : null,
                 stale_processes_killed: cleanupProof?.stale_processes_killed || [],
-                stale_zellij_panes_closed: cleanupProof?.stale_zellij_panes_closed || [],
                 orphan_temp_dirs_removed: cleanupProof?.orphan_temp_dirs_removed || [],
                 stale_locks_removed: cleanupProof?.stale_locks_removed || [],
                 skipped_active_sessions: cleanupProof?.skipped_active_sessions || []
@@ -152,15 +125,6 @@ function renderAgentTrustReportMarkdown(report) {
         `- backfill_count: ${orchestration.backfill_count ?? 'unknown'}`,
         `- expected_backfill_count: ${orchestration.expected_backfill_count ?? 'unknown'}`,
         `- pending_queue_drained: ${orchestration.pending_queue_drained === true}`,
-        `- zellij_lane_manifest: ${orchestration.zellij_lane_manifest || 'unknown'}`,
-        `- zellij_runtime_manifest: ${orchestration.zellij_lane_persistence?.runtime_manifest || 'not_run'}`,
-        `- zellij_dispatch_mode: ${orchestration.zellij_lane_persistence?.dispatch_mode || 'unknown'}`,
-        `- zellij_fifo_policy: ${orchestration.zellij_lane_persistence?.fifo_policy || 'unknown'}`,
-        `- zellij_runtime_policy_ok: ${orchestration.zellij_lane_persistence?.runtime_policy_ok === true}`,
-        `- zellij_no_flicker_verified: ${orchestration.zellij_lane_persistence?.no_flicker_verified === true}`,
-        `- zellij_pane_survival_checked: ${orchestration.zellij_lane_persistence?.pane_survival_checked === true}`,
-        `- zellij_pane_proof_ok: ${orchestration.zellij_lane_persistence?.pane_proof_ok === true}`,
-        `- zellij_pane_count: ${orchestration.zellij_lane_persistence?.pane_count ?? 'unknown'}`,
         `- cleanup_executor: ${orchestration.cleanup_executor?.status || 'not_run'}`,
         `- work_graph_quality_score: ${orchestration.intelligent_work_graph?.score ?? 'unknown'}`,
         `- runtime_truth_fake: ${(report.runtime_truth_groups?.Fake || []).join(', ') || 'None'}`,

package/dist/core/agents/agent-worker-pipeline.js

@@ -49,7 +49,6 @@ export function validateAgentWorkerResult(result) {
         ...(result?.backend_router_report === undefined ? {} : { backend_router_report: result.backend_router_report }),
         ...(result?.codex_child_report === undefined ? {} : { codex_child_report: result.codex_child_report }),
         ...(result?.process_child_report === undefined ? {} : { process_child_report: result.process_child_report }),
-        ...(result?.zellij_child_report === undefined ? {} : { zellij_child_report: result.zellij_child_report }),
         ...(result?.codex_sdk_thread === undefined ? {} : { codex_sdk_thread: result.codex_sdk_thread }),
         ...(result?.model_authored_patch_envelopes === undefined ? {} : { model_authored_patch_envelopes: Boolean(result.model_authored_patch_envelopes) }),
         ...(result?.fixture_patch_envelopes === undefined ? {} : { fixture_patch_envelopes: Boolean(result.fixture_patch_envelopes) }),

package/dist/core/agents/fast-mode-policy.js

@@ -122,10 +122,9 @@ export function applyFastModeToRoster(roster, policy) {
 export async function writeFastModePropagationProof(root, input = { policy: resolveFastModePolicy() }) {
     const workerProcessReports = await collectNamedJson(root, 'worker-process-report.json');
     const agentProcessReports = await collectNamedJson(root, 'agent-process-report.json');
-    const zellijReports = await collectNamedJson(root, 'agent-zellij-report.json');
     const madReports = await collectNamedJson(root, 'mad-sks-worker-report.json');
     const defaultFastExpected = input.policy.fast_mode === true;
-    const childReports = [...workerProcessReports, ...agentProcessReports, ...zellijReports, ...madReports];
+    const childReports = [...workerProcessReports, ...agentProcessReports, ...madReports];
     const missingFast = defaultFastExpected
         ? childReports.filter((row) => row.json?.fast_mode !== true && row.json?.fast_mode !== 'true')
         : [];
@@ -150,7 +149,6 @@ export async function writeFastModePropagationProof(root, input = { policy: reso
         worker_process_report_count: workerProcessReports.length,
         codex_sdk_process_report_count: agentProcessReports.filter((row) => row.json?.backend === 'codex-sdk').length,
         process_report_count: agentProcessReports.filter((row) => row.json?.backend === 'process').length,
-        zellij_report_count: zellijReports.length,
         mad_report_count: madReports.length,
         child_report_count: childReports.length,
         artifacts: childReports.map((row) => row.relative_path),

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

@@ -15,7 +15,7 @@ export async function writeNativeCliWorkerRuntimeProof(root, input = {}) {
     const spawnedWorkerProcessCount = Number(runtime?.spawned_worker_process_count || 0);
     const maxObservedWorkerProcessCount = Number(runtime?.max_observed_worker_process_count || 0);
     const processIds = Array.isArray(runtime?.process_ids) ? runtime.process_ids.filter((pid) => Number.isFinite(Number(pid))) : [];
-    const allowedScalingPrimitives = new Set(['native_cli_process', 'native_cli_process_in_zellij_worker_pane']);
+    const allowedScalingPrimitives = new Set(['native_cli_process']);
     const blockers = [
         ...(!runtime ? ['native_cli_worker_runtime_missing'] : []),
         ...(runtime && !allowedScalingPrimitives.has(String(runtime.scaling_primitive || '')) ? ['scaling_primitive_not_native_cli_process'] : []),