sneakoscope 8.0.2 → 8.0.4

package/dist/commands/mad-sks.js

@@ -1,14 +1,10 @@
 import { madHighCommand } from '../core/commands/mad-sks-command.js';
-import { ensureMadLaunchDependencies, formatMadLaunchDependencyAction, maybePromptCodexUpdateForLaunch, maybePromptCodexLbSetupForLaunch, maybePromptSksUpdateForLaunch } from '../cli/install-helpers.js';
-import { maybePromptZellijUpdateForLaunch } from '../core/zellij/zellij-update.js';
+import { maybePromptCodexUpdateForLaunch, maybePromptCodexLbSetupForLaunch, maybePromptSksUpdateForLaunch } from '../cli/install-helpers.js';
 import { PACKAGE_VERSION } from '../core/fsx.js';
 export async function run(_command, args = []) {
     return madHighCommand(['--mad-sks', ...args], {
         maybePromptSksUpdateForLaunch,
         maybePromptCodexUpdateForLaunch,
-        maybePromptZellijUpdateForLaunch,
-        ensureMadLaunchDependencies,
-        printDepsInstallAction: (action) => console.error(formatMadLaunchDependencyAction(action)),
         maybePromptCodexLbSetupForLaunch,
         packageVersion: PACKAGE_VERSION
     });

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "8.0.2",
+  "package_version": "8.0.4",
   "skills": [
     {
       "canonical_name": "sks",
@@ -326,8 +326,10 @@
     {
       "canonical_name": "sks-naruto",
       "type": "core",
-      "content_sha256": "f8e808622e222b4ad7dcb2907e5f06a890db83139ae443ec6c8c33781dfa3e37",
+      "content_sha256": "d0d5968e78ac25e1d3e588735de1ddbcf149cfb3165edebca5dec1ed7c7a5c46",
       "hash_history": [
+        "34222c72e4e1ead3584907f4d905444b7de820283ee7348018f110d5e6b04461",
+        "f8e808622e222b4ad7dcb2907e5f06a890db83139ae443ec6c8c33781dfa3e37",
         "49b5e3dcc1b537b49c2cf09e5b875cb16acb05c622b22798e265e64dacd8ac90"
       ],
       "deprecated_aliases": []

package/dist/core/agents/agent-codex-cockpit.js

@@ -28,7 +28,6 @@ export async function buildAgentCodexCockpitState(missionDir, opts = {}) {
     const namespace = await readJson(path.join(missionDir, 'project-session-namespace.json'), null);
     const sourceIntelligence = await readJson(path.join(missionDir, 'source-intelligence-evidence.json'), null);
     const goalMode = await readJson(path.join(missionDir, 'goal-mode-applied.json'), null);
-    const zellijLayout = await readJson(path.join(root, 'agent-zellij-layout.json'), null);
     const scheduler = await readJson(path.join(root, 'agent-scheduler-state.json'), null);
     const workerSlots = await readJson(path.join(root, 'agent-worker-slots.json'), null);
     const generations = await readJson(path.join(root, 'agent-session-generations.json'), null);
@@ -68,7 +67,6 @@ export async function buildAgentCodexCockpitState(missionDir, opts = {}) {
         codex_web_search_status: sourceIntelligence?.codex_web_search?.status || sourceIntelligence?.policy?.codex_web_search?.status || null,
         goal_mode_status: goalMode?.mode || null,
         terminal_session_status: terminalClosed ? 'closed' : proof ? 'blocked_or_unverified' : null,
-        zellij_attach_command: zellijLayout?.attach_command || null,
         target_active_slots: scheduler?.target_active_slots ?? null,
         active_slot_count: scheduler?.active_slot_count ?? null,
         pending_queue_count: scheduler?.pending_count ?? null,
@@ -122,7 +120,6 @@ function summarizeLiveState(state) {
         codex_web_search_status: state.codex_web_search_status,
         goal_mode_status: state.goal_mode_status,
         terminal_session_status: state.terminal_session_status,
-        zellij_attach_command: state.zellij_attach_command,
         blockers: state.blockers,
     };
 }

package/dist/core/agents/agent-effort-policy.js

@@ -103,7 +103,7 @@ export function decideOfficialSubagentModel(input = {}) {
             ],
             downshift_triggers: [
                 'ordinary UI, logic, backend, or native implementation selects Sol High',
-                'long-context, Browser/Chrome, Computer Use, image-generation, or large search selects Terra Medium',
+                'long-context, Browser/Chrome, Computer Use, image-generation, or large search selects Terra Max',
                 'tiny short-context mechanical search/typing/rename work selects Luna Max'
             ]
         };
@@ -157,7 +157,7 @@ export function decideOfficialSubagentModel(input = {}) {
         ],
         downshift_triggers: [
             'ordinary UI, logic, backend, or native implementation selects Sol High',
-            'long-context, Browser/Chrome, Computer Use, or image-generation execution selects Terra Medium',
+            'long-context, Browser/Chrome, Computer Use, or image-generation execution selects Terra Max',
             'tiny short-context mechanical work selects Luna Max'
         ]
     };
@@ -186,16 +186,16 @@ export function buildAgentEffortPolicy(roster = {}) {
         model_catalog_policy: narutoFamilyOnly ? 'official_subagent_four_profile_matrix' : 'codex_catalog_passthrough',
         model_constraint: narutoFamilyOnly ? ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'] : null,
         model_tiers: narutoFamilyOnly
-            ? ['gpt-5.6-luna-max', 'gpt-5.6-sol-high', 'gpt-5.6-sol-max', 'gpt-5.6-terra-medium']
+            ? ['gpt-5.6-luna-max', 'gpt-5.6-sol-high', 'gpt-5.6-sol-max', 'gpt-5.6-terra-max']
             : ['codex-selected-low', 'codex-selected-medium', 'codex-selected-high', 'codex-selected-xhigh', 'glm-5.2-minimal', 'glm-5.2-low', 'glm-5.2-high', 'glm-5.2-xhigh'],
-        allowed_efforts: narutoFamilyOnly ? ['medium', 'high', 'max'] : codexModelEffortCapability().advertised_efforts,
+        allowed_efforts: narutoFamilyOnly ? ['high', 'max'] : codexModelEffortCapability().advertised_efforts,
         model_effort_capability: codexModelEffortCapability(),
         max_agents: roster.max_agents || 20,
         agent_count: roster.agent_count || decisions.length,
         concurrency: roster.concurrency || decisions.length,
         decisions,
         rule: narutoFamilyOnly
-            ? 'Official Naruto subagents use GPT-5.6 Luna Max only for tiny short-context mechanical work, GPT-5.6 Sol High for ordinary implementation, GPT-5.6 Sol Max for judgment-heavy work, and GPT-5.6 Terra Medium for long-context or Browser/Chrome, Computer Use, and image-generation execution. Judgment wins when one slice cannot be safely split.'
+            ? 'Official Naruto subagents use GPT-5.6 Luna Max only for tiny short-context mechanical work, GPT-5.6 Sol High for ordinary implementation, GPT-5.6 Sol Max for judgment-heavy work, and GPT-5.6 Terra Max for long-context or Browser/Chrome, Computer Use, and image-generation execution. Judgment wins when one slice cannot be safely split.'
             : 'Codex/OpenAI workers inherit the current Codex-selected model, including future catalog entries; SKS changes only advertised reasoning effort. Explicit non-Codex provider modes retain their provider model.'
     };
 }

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

@@ -35,10 +35,6 @@ export async function runAgentJanitor(input) {
             statusBySession.set(String(row.session_id), status);
     }
     const zombieProcesses = await detectZombieProcessSessions(agentRoot, statusByAgent, statusBySession);
-    const rawStaleZellijSessions = await detectStaleZellijSessions(agentRoot, staleMs);
-    const activeGenerationSet = new Set(activeGenerationSessions);
-    const staleZellijSessions = rawStaleZellijSessions.filter((id) => !activeGenerationSet.has(id));
-    const skippedActiveGenerations = rawStaleZellijSessions.filter((id) => activeGenerationSet.has(id));
     const orphanGenerationDirs = await detectOrphanGenerationDirs(agentRoot, new Set(generationRows.map((row) => String(row.artifact_dir || ''))));
     const orphanTempDirs = await scopedExistingPaths(Array.isArray(namespace?.orphan_temp_dirs) ? namespace.orphan_temp_dirs : [], projectHash, namespace?.temp_dir ? [namespace.temp_dir] : []);
     const staleLocks = await scopedStaleLockPaths(namespace?.lock_dir ? [namespace.lock_dir] : [], projectHash, staleMs);
@@ -56,7 +52,6 @@ export async function runAgentJanitor(input) {
     const blockers = [
         ...staleHeartbeat.map((id) => `stale_heartbeat:${id}`),
         ...zombieProcesses.map((id) => `zombie_process:${id}`),
-        ...staleZellijSessions.map((id) => `stale_zellij:${id}`),
         ...staleLocks.map((id) => `stale_lock:${id}`),
     ];
     const report = {
@@ -67,11 +62,9 @@ export async function runAgentJanitor(input) {
         project_hash: projectHash,
         stale_heartbeat_sessions: staleHeartbeat,
         zombie_process_sessions: zombieProcesses,
-        stale_zellij_sessions: staleZellijSessions,
         active_generation_sessions: activeGenerationSessions,
         active_generation_count: activeGenerationSessions.length,
         cleaned_generation_count: cleaned.filter((entry) => entry.includes(`${path.sep}sessions${path.sep}`)).length,
-        skipped_active_generations: skippedActiveGenerations,
         orphan_generation_dirs: orphanGenerationDirs,
         slot_generation_cleanup: cleaned.filter((entry) => entry.includes(`${path.sep}sessions${path.sep}`)),
         orphan_temp_dirs: orphanTempDirs,
@@ -143,19 +136,6 @@ async function detectZombieProcessSessions(agentRoot, statusByAgent, statusBySes
     }
     return out;
 }
-async function detectStaleZellijSessions(agentRoot, staleMs) {
-    const out = [];
-    const now = Date.now();
-    for (const file of await listNamedFiles(path.join(agentRoot, 'sessions'), 'agent-zellij-report.json')) {
-        const report = await readJson(file, null);
-        if (!report || report.launch_mode === 'optional_not_launched')
-            continue;
-        const stat = await fsp.stat(file).catch(() => null);
-        if (stat && now - stat.mtimeMs > staleMs)
-            out.push(String(report.session_id || report.agent_id || path.basename(path.dirname(file))));
-    }
-    return out;
-}
 async function listNamedFiles(dir, name) {
     return (await listFiles(dir)).filter((file) => path.basename(file) === name);
 }

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

@@ -29,14 +29,11 @@ import { appendAgentCodexCockpitHookEvent, writeAgentCodexCockpitArtifacts } fro
 import { runAgentJanitor } from './agent-janitor.js';
 import { startAgentTerminalSession, closeAgentTerminalSession } from './agent-terminal-session.js';
 import { writeScoutPolicyArtifact } from './scout-policy.js';
-import { writeZellijRightLaneCockpit } from './zellij-right-lane-cockpit.js';
 import { buildProjectNamespace, namespacedAgentSessionId, writeProjectNamespaceArtifact } from '../session/project-namespace.js';
 import { normalizeTargetActiveSlots, runAgentScheduler } from './agent-scheduler.js';
 import { runSourceIntelligence } from '../source-intelligence/source-intelligence-runner.js';
 import { detectOfficialGoalMode, writeOfficialGoalModeArtifact } from '../codex/official-goal-mode.js';
 import { writeAgentTaskGraph } from './agent-task-graph.js';
-import { drainZellijLaneSupervisor, initializeZellijLaneSupervisorEmpty, updateZellijLaneSupervisorFromSlots, verifyZellijLaneSurvival } from './zellij-lane-supervisor.js';
-import { writeZellijPaneProof } from '../zellij/zellij-pane-proof.js';
 import { writeIntelligentWorkGraphArtifacts } from './intelligent-work-graph.js';
 import { writeAdhdOrchestrationArtifacts } from '../strategy/adhd-orchestrating-gate.js';
 import { compileStrategy, writeStrategyCompilerArtifacts } from '../strategy/strategy-compiler.js';
@@ -72,8 +69,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const requestedBackend = String(opts.backend || (opts.mock ? 'fake' : 'codex-sdk'));
     const backend = normalizeAgentBackend(requestedBackend);
     const maxAgentCount = Number.isFinite(Number(opts.maxAgentCount)) && Number(opts.maxAgentCount) >= 1 ? Math.floor(Number(opts.maxAgentCount)) : MAX_AGENT_COUNT;
-    const realZellij = backend === 'zellij' && opts.real === true;
-    const realZellijProofRequired = realZellij && process.env.SKS_REQUIRE_ZELLIJ === '1';
     const created = opts.missionId
         ? { id: opts.missionId, dir: missionDir(root, opts.missionId), mission: { id: opts.missionId, mode: 'internal-worker-runtime', prompt } }
         : await createMission(root, { mode: 'internal-worker-runtime', prompt, sessionKey });
@@ -113,7 +108,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         })
     }));
     const targetActiveSlots = normalizeTargetActiveSlots(opts.targetActiveSlots ?? opts.agents ?? roster.agent_count, maxAgentCount);
-    const visualLaneCount = normalizeVisualLaneCount(opts.visualLaneCount ?? opts.agents ?? roster.agent_count, roster.agent_count, Math.min(maxAgentCount, DEFAULT_AGENT_CONCURRENCY));
     const desiredWorkItemCount = normalizeDesiredWorkItemCount(opts.desiredWorkItemCount, opts.minimumWorkItems, targetActiveSlots);
     const minimumWorkItems = normalizeMinimumWorkItems(opts.minimumWorkItems, targetActiveSlots);
     const sourceIntelligence = await runSourceIntelligence({ root, missionDir: dir, route, query: prompt, offline: true, context7Available: true });
@@ -241,9 +235,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     await writeStrategyGateArtifact(ledgerRoot, strategyGate);
     await writeIntelligentWorkGraphArtifacts(ledgerRoot, partition.intelligent_work_graph);
     await writeScoutPolicyArtifact(ledgerRoot);
-    await writeZellijRightLaneCockpit(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, agents: roster.roster });
-    await initializeZellijLaneSupervisorEmpty(ledgerRoot, { missionId, sessionName: `sks-${missionId}` });
-    await writeZellijPaneProof(root, { missionId, require: realZellijProofRequired, phase: 'initial', ledgerRoot });
     await writeAgentCodexCockpitArtifacts(dir, { missionId, projectHash: namespace.root_hash });
     await writeJsonAtomic(path.join(ledgerRoot, 'agent-no-overlap-proof.json'), partition.no_overlap_proof || { schema: 'sks.agent-no-overlap-proof.v1', ok: false, blockers: ['missing_no_overlap_proof'] });
     await writeAgentLifecyclePolicy(ledgerRoot);
@@ -256,7 +247,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         concurrency: roster.concurrency,
         batch_count: 0,
         target_active_slots: targetActiveSlots,
-        visual_lane_count: visualLaneCount,
         desired_work_items: desiredWorkItemCount,
         minimum_work_items: minimumWorkItems,
         requested_work_items: desiredWorkItemCount,
@@ -347,11 +337,10 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         noOllama: opts.noOllama === true,
         route,
         fastModePolicy,
-        ...(opts.workerPlacement === undefined ? {} : { workerPlacement: String(opts.workerPlacement) }),
-        zellijVisiblePaneCap: Number(opts.zellijVisiblePaneCap || visualLaneCount || targetActiveSlots),
         projectRoot: root
     });
     const schedulerHardTimeoutMs = normalizeMissionHardTimeoutMs(opts, route);
+    const schedulerAbortController = new AbortController();
     let lastTimeoutReapMs = 0;
     async function reapTimedOutAgentSessions(force = false) {
         const now = Date.now();
@@ -371,6 +360,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         prompt,
         targetActiveSlots,
         maxActiveSlots: maxAgentCount,
+        maxWallMs: schedulerHardTimeoutMs,
         ...(opts.maxQueueExpansion === undefined ? {} : { maxQueueExpansion: opts.maxQueueExpansion }),
         ...(opts.refillDelayMs === undefined ? {} : { refillDelayMs: opts.refillDelayMs }),
         sourceIntelligenceRefs: sourceIntelligenceRef,
@@ -408,12 +398,12 @@ export async function runNativeAgentOrchestrator(opts = {}) {
             await appendAgentLedgerEvent(ledgerRoot, { agent_id: agent.id, session_id: agent.session_id, event_type: 'agent_started', payload: { backend, slice_id: slice.id } });
             await startAgentTerminalSession(ledgerRoot, agent, {
                 backend,
-                real: backend === 'process' || (backend === 'codex-sdk' && opts.real === true) || backend === 'zellij',
+                real: backend === 'process' || (backend === 'codex-sdk' && opts.real === true),
                 slotId: agent.slot_id,
                 generationIndex: agent.generation_index,
                 requireGeneration: true
             });
-            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, projectRoot: root, projectHash: namespace.root_hash, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
+            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, projectRoot: root, projectHash: namespace.root_hash, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, signal: schedulerAbortController.signal, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
             const result = await workerSessionRuntime.launchWorker({ agent: runtimeAgent, slice: runtimeSlice, opts: backendOpts });
             await reapTimedOutAgentSessions();
             if (route === '$Naruto')
@@ -467,26 +457,19 @@ export async function runNativeAgentOrchestrator(opts = {}) {
             await writeAgentCodexCockpitArtifacts(dir, { missionId, projectHash: namespace.root_hash });
             return result;
         },
+        onStop: async (reason) => {
+            if (!schedulerAbortController.signal.aborted)
+                schedulerAbortController.abort(reason);
+            await reapTimedOutAgentSessions(true);
+        },
         onSchedulerEvent: async ({ event, slots, state }) => {
             await reapTimedOutAgentSessions();
-            const paneBySlot = await readZellijPaneIdsBySlot(ledgerRoot);
-            const enrichedSlots = slots.map((slot) => ({ ...slot, pane_id: paneBySlot.get(slot.slot_id) || null, launch_status: paneBySlot.has(slot.slot_id) ? 'launched' : slot.status }));
-            await writeZellijRightLaneCockpit(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, slots: enrichedSlots });
             await writeAgentCodexCockpitArtifacts(dir, { missionId, projectHash: namespace.root_hash });
             if (['session_completed', 'backfill_event', 'scheduler_drained'].includes(String(event.event_type))) {
                 const periodicJanitor = await runAgentJanitor({ missionDir: dir, missionId, projectHash: namespace.root_hash });
                 if (!periodicJanitor.ok)
                     await appendAgentLedgerEvent(ledgerRoot, { agent_id: 'orchestrator', session_id: 'orchestrator', event_type: 'periodic_janitor_blocked', payload: periodicJanitor });
             }
-            if (String(event.event_type) === 'scheduler_draining') {
-                await verifyZellijLaneSurvival(ledgerRoot);
-                await writeZellijPaneProof(root, { missionId, require: realZellijProofRequired, phase: 'before_drain', ledgerRoot });
-            }
-            await updateZellijLaneSupervisorFromSlots(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, slots, state, event });
-            if (String(event.event_type) === 'scheduler_drained') {
-                await drainZellijLaneSupervisor(ledgerRoot);
-                await writeZellijPaneProof(root, { missionId, require: realZellijProofRequired, phase: 'after_drain', ledgerRoot });
-            }
         }
     });
     await reapTimedOutAgentSessions(true);
@@ -494,7 +477,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const parallelRuntimeProof = await writeParallelRuntimeProof(ledgerRoot, missionId, {
         requestedWorkers: Number(opts.agents || roster.agent_count || targetActiveSlots),
         targetActiveSlots,
-        visiblePanes: visualLaneCount,
         expectedWorkerRuntimeMs: targetActiveSlots >= 10 ? 8000 : targetActiveSlots >= 2 ? 2000 : 25,
         minActiveWorkers: Math.min(targetActiveSlots, desiredWorkItemCount),
         ...(backend === 'codex-sdk' && opts.real === true ? { minSpeedupRatio: 3 } : {}),
@@ -573,10 +555,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const outputValidation = await writeAgentOutputValidationReport(ledgerRoot, results);
     const outputTails = await writeAgentOutputTailReport(ledgerRoot, results);
     const backendReport = await writeAgentBackendReport(ledgerRoot, { backend, results, outputTails, fastModePolicy });
-    const finalPaneBySlot = await readZellijPaneIdsBySlot(ledgerRoot);
-    const finalZellijSlots = scheduler.slots.map((slot) => ({ ...slot, pane_id: finalPaneBySlot.get(slot.slot_id) || null, launch_status: finalPaneBySlot.has(slot.slot_id) ? 'launched' : slot.status }));
-    await writeZellijRightLaneCockpit(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, slots: finalZellijSlots });
-    await writeZellijPaneProof(root, { missionId, require: realZellijProofRequired, phase: 'final', ledgerRoot });
     await compactAgentLedger(ledgerRoot);
     const cleanup = await writeAgentCleanupReport(ledgerRoot);
     const janitor = await runAgentJanitor({ missionDir: dir, missionId, projectHash: namespace.root_hash });
@@ -607,7 +585,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         minimumWorkItems: partition.task_graph?.minimum_work_items || minimumWorkItems,
         targetActiveSlots,
         realParallel: backend === 'codex-sdk' && opts.mock !== true,
-        visualLaneCount,
         roster,
         partition,
         consensus,
@@ -652,7 +629,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         requested_work_items: partition.task_graph?.desired_work_items || desiredWorkItemCount,
         actual_total_work_items: partition.task_graph?.total_work_items || partition.slices.length,
         target_active_slots: targetActiveSlots,
-        visual_lane_count: visualLaneCount,
         minimum_work_items: partition.task_graph?.minimum_work_items || minimumWorkItems,
         scheduler,
         source_intelligence: sourceIntelligenceRef,
@@ -1862,16 +1838,6 @@ function normalizeMinimumWorkItems(value, targetActiveSlots) {
         return Math.max(1, Math.floor(targetActiveSlots));
     return Math.max(1, Math.floor(parsed));
 }
-function normalizeVisualLaneCount(value, fallback, maxAgentCount) {
-    const parsed = Number(value);
-    const fallbackCount = Number(fallback);
-    const raw = Number.isFinite(parsed) && parsed > 0
-        ? parsed
-        : Number.isFinite(fallbackCount) && fallbackCount > 0
-            ? fallbackCount
-            : 1;
-    return Math.max(1, Math.min(maxAgentCount, Math.floor(raw)));
-}
 function isWriteCapableRun(opts) {
     if (opts.readonly === true)
         return false;
@@ -1995,19 +1961,6 @@ function buildProvidedAgentRoster(input, opts = {}) {
         effort_policy: input?.effort_policy || { schema: 'sks.agent-effort-policy.v1', dynamic: true, decisions: [] }
     };
 }
-async function readZellijPaneIdsBySlot(root) {
-    const out = new Map();
-    const text = await readText(path.join(root, 'agent-zellij-pane-launch-ledger.jsonl'), '');
-    for (const line of String(text).split(/\n/).filter(Boolean)) {
-        try {
-            const entry = JSON.parse(line);
-            if (entry.slot_id && entry.pane_id)
-                out.set(String(entry.slot_id), String(entry.pane_id));
-        }
-        catch { }
-    }
-    return out;
-}
 async function writeAgentOutputTailReport(root, results) {
     const records = [];
     for (const result of results || []) {

package/dist/core/agents/agent-output-validator.js

@@ -34,7 +34,7 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
         task_slice_id: { type: 'string' },
         work_item_kind: { type: 'string' },
         status: { enum: ['done', 'blocked', 'failed'] },
-        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk', 'zellij', 'ollama', 'local-llm'] },
+        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk', 'ollama', 'local-llm'] },
         summary: { type: 'string' },
         findings: { type: 'array', items: { type: 'string' } },
         proposed_changes: { type: 'array', items: { type: 'string' } },
@@ -80,7 +80,7 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
                 required: ['schema', 'agent_id', 'session_id', 'slot_id', 'generation_index', 'operations'],
                 properties: {
                     schema: { const: 'sks.agent-patch-envelope.v1' },
-                    source: { enum: ['fixture', 'model_authored', 'process_generated', 'zellij_generated', 'git-worktree-diff'] },
+                    source: { enum: ['fixture', 'model_authored', 'process_generated', 'git-worktree-diff'] },
                     mission_id: { type: 'string' },
                     route: { type: 'string' },
                     agent_id: { type: 'string', minLength: 1 },
@@ -155,7 +155,6 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
         codex_child_report: { type: 'object', additionalProperties: true },
         codex_sdk_thread: { type: 'object', additionalProperties: true },
         process_child_report: { type: 'object', additionalProperties: true },
-        zellij_child_report: { type: 'object', additionalProperties: true },
         model_authored_patch_envelopes: { type: 'boolean' },
         fixture_patch_envelopes: { type: 'boolean' },
         no_patch_reason: { type: 'object', additionalProperties: true },

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

@@ -55,7 +55,7 @@ export function validateAgentPatchEnvelope(envelope) {
         violations.push('lease_id_missing');
     if (!envelope.operations.length)
         violations.push('operations_missing');
-    if (envelope.source && !['fixture', 'model_authored', 'process_generated', 'zellij_generated', 'git-worktree-diff'].includes(envelope.source))
+    if (envelope.source && !['fixture', 'model_authored', 'process_generated', 'git-worktree-diff'].includes(envelope.source))
         violations.push('source_invalid');
     if (envelope.source === 'model_authored' && !hasFiniteNumber(envelope.backend_child_process_id) && !envelope.backend_sdk_thread_id && !envelope.backend_ollama_request_id)
         violations.push('model_authored_backend_proof_missing');
@@ -84,7 +84,7 @@ export function validateAgentPatchEnvelope(envelope) {
 }
 function normalizeEnvelopeSource(value) {
     const text = String(value || '');
-    return text === 'fixture' || text === 'model_authored' || text === 'process_generated' || text === 'zellij_generated' || text === 'git-worktree-diff' ? text : null;
+    return text === 'fixture' || text === 'model_authored' || text === 'process_generated' || text === 'git-worktree-diff' ? text : null;
 }
 function hasFiniteNumber(value) {
     return value !== null && value !== undefined && value !== '' && Number.isFinite(Number(value));

package/dist/core/agents/agent-proof-evidence.js

@@ -5,7 +5,6 @@ import { validateAgentLedgerHashChain } from './agent-central-ledger.js';
 import { assertAllAgentSessionsClosed } from './agent-lifecycle.js';
 import { assertAgentTerminalSessionsClosed } from './agent-terminal-session.js';
 import { assertAgentSessionGenerationsClosed } from './agent-session-generation.js';
-import { readZellijLaneSupervisor } from './zellij-lane-supervisor.js';
 import { writeFakeRealProofPolicyReport } from '../proof/fake-real-proof-policy.js';
 import { buildRuntimeTruthMatrix, writeRuntimeTruthMatrix } from '../proof/runtime-truth-matrix.js';
 import { evaluateLocalCollaborationFinalGate, localCollaborationParticipated, resolveLocalCollaborationPolicy } from '../local-llm/local-collaboration-policy.js';
@@ -14,9 +13,6 @@ export async function writeAgentProofEvidence(root, input) {
     const terminal = await assertAgentTerminalSessionsClosed(root);
     const generations = await assertAgentSessionGenerationsClosed(root);
     const ledger = await validateAgentLedgerHashChain(root);
-    const zellijLanes = await readJson(path.join(root, 'agent-zellij-lanes.json'), null);
-    const laneSupervisor = await readZellijLaneSupervisor(root);
-    const zellijRuntimeManifest = await readJson(path.join(root, 'zellij-lane-runtime.json'), null);
     const workQueue = await readJson(path.join(root, 'agent-work-queue.json'), null);
     const scheduler = input.scheduler || await readJson(path.join(root, 'agent-scheduler-state.json'), null);
     const taskGraph = input.partition?.task_graph || await readJson(path.join(root, 'agent-task-graph.json'), null);
@@ -51,15 +47,12 @@ export async function writeAgentProofEvidence(root, input) {
     const noSubagentScalingPolicy = input.noSubagentScalingPolicy || await readJson(path.join(root, 'no-subagent-scaling-policy.json'), null);
     const officialSubagentHelperPolicy = input.officialSubagentHelperPolicy || await readJson(path.join(root, 'official-subagent-helper-policy.json'), null);
     const fastModePropagation = input.fastModePropagation || await readJson(path.join(root, 'fast-mode-propagation-proof.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 slots = await readJson(path.join(root, 'agent-worker-slots.json'), null);
     const generationArtifact = await readJson(path.join(root, 'agent-session-generations.json'), null);
     const strategyGate = input.strategyGate || await readJson(path.join(root, 'strategy-gate.json'), null);
     const schedulerEvents = await readTextSafe(path.join(root, 'agent-scheduler-events.jsonl'));
-    const zellijLaunchLedger = await readTextSafe(path.join(root, 'agent-zellij-pane-launch-ledger.jsonl'));
-    const zellijPaneLaunchCount = zellijLaunchLedger.split(/\n/).filter(Boolean).length;
     const terminalCloseReportCount = terminal.total_sessions || 0;
     const generationCount = generations.generation_count || 0;
     const finalWorkItemCount = Number(scheduler?.completed_count || 0) + Number(scheduler?.failed_count || 0) + Number(scheduler?.blocked_count || 0);
@@ -68,7 +61,6 @@ export async function writeAgentProofEvidence(root, input) {
     const workQueueTotalWorkItems = Number(workQueue?.total_work_items || 0);
     const schedulerTotalWorkItems = Number(scheduler?.total_work_items || 0);
     const targetActiveSlots = Number(input.targetActiveSlots || scheduler?.target_active_slots || taskGraph?.target_active_slots || input.roster?.agent_count || 0);
-    const visualLaneCount = Number(input.visualLaneCount || zellijLanes?.lane_count || laneSupervisor?.lane_count || targetActiveSlots || 0);
     const minimumWorkItems = Number(input.minimumWorkItems || taskGraph?.minimum_work_items || targetActiveSlots || 0);
     const taskGraphMatchesCliOptions = Boolean(taskGraph) && requestedWorkItems === taskGraphTotalWorkItems && targetActiveSlots === Number(taskGraph.target_active_slots || 0);
     const workQueueMatchesTaskGraph = Boolean(workQueue && taskGraph) && workQueueTotalWorkItems === taskGraphTotalWorkItems;
@@ -84,24 +76,6 @@ export async function writeAgentProofEvidence(root, input) {
     const isNarutoRoute = route === '$Naruto';
     const routeCommand = String(input.routeCommand || 'internal-worker-runtime');
     const realRouteCommandUsed = routeCommand !== 'internal-worker-runtime';
-    const laneSupervisorIntegrated = Boolean(laneSupervisor);
-    const zellijSpawnOnDemandSupervisor = Boolean(laneSupervisor)
-        && Number(laneSupervisor?.lane_count || 0) === 0
-        && Array.isArray(laneSupervisor?.lanes)
-        && laneSupervisor.lanes.length === 0
-        && Number(zellijRuntimeManifest?.lane_count || 0) === 0
-        && Array.isArray(zellijRuntimeManifest?.lanes)
-        && zellijRuntimeManifest.lanes.length === 0;
-    const zellijLaneRuntimePolicyOk = zellijSpawnOnDemandSupervisor || Boolean(laneSupervisor)
-        && Array.isArray(laneSupervisor?.lanes)
-        && laneSupervisor.lanes.length > 0
-        && laneSupervisor.lanes.every((lane) => lane?.dispatch_mode === 'jsonl_nonblocking'
-            && lane?.command_inbox
-            && lane?.state_dir
-            && lane?.runtime?.dispatch?.fifo_policy === 'disabled_to_avoid_writer_blocking');
-    const zellijLanePaneIdSourceOk = Boolean(laneSupervisor)
-        && Array.isArray(laneSupervisor?.lanes)
-        && laneSupervisor.lanes.every((lane) => typeof lane?.pane_id_source === 'string' && lane.pane_id_source.length > 0);
     const patchEntries = Array.isArray(patchQueue?.entries) ? patchQueue.entries : [];
     const patchApplyRows = Array.isArray(patchApplyResults?.results) ? patchApplyResults.results : [];
     const patchQueuePendingCount = Number(patchQueue?.queued_count || patchEntries.filter((entry) => entry.status === 'pending').length || 0);
@@ -177,18 +151,6 @@ export async function writeAgentProofEvidence(root, input) {
         ...(generationCount < finalWorkItemCount ? ['session_generation_count_below_finished_work_items'] : []),
         ...(terminalCloseReportCount < generationCount ? ['terminal_close_report_count_below_generation_count'] : []),
         ...(slots && slots.all_slots_closed_after_drain !== true ? ['agent_worker_slots_not_closed_after_drain'] : []),
-        ...(!laneSupervisor ? ['zellij_lane_supervisor_missing'] : []),
-        ...(laneSupervisor && !zellijSpawnOnDemandSupervisor && visualLaneCount > 0 && Number(laneSupervisor.lane_count || 0) < visualLaneCount ? ['zellij_lane_count_below_visual_lane_count'] : []),
-        ...(laneSupervisor && laneSupervisor.no_flicker_verified !== true ? ['zellij_lane_no_flicker_not_verified'] : []),
-        ...(laneSupervisor && laneSupervisor.pane_survival_checked !== true ? ['zellij_lane_survival_not_checked'] : []),
-        ...(laneSupervisor && Number(laneSupervisor.unexpected_close_count || 0) > 0 ? ['zellij_lane_unexpected_close_before_drain'] : []),
-        ...(laneSupervisor && !zellijLaneRuntimePolicyOk ? ['zellij_lane_runtime_policy_missing'] : []),
-        ...(laneSupervisor && !zellijLanePaneIdSourceOk ? ['zellij_lane_pane_id_source_missing'] : []),
-        ...(laneSupervisor?.blockers || []),
-        ...(input.backend === 'zellij' && zellijPaneProof?.ok !== true ? ['zellij_pane_proof_missing'] : []),
-        ...(input.backend === 'zellij' && Array.isArray(zellijPaneProof?.blockers) ? zellijPaneProof.blockers : []),
-        ...(input.backend === 'zellij' && zellijLanes?.ok !== true ? ['zellij_right_lane_manifest_missing'] : []),
-        ...(input.backend === 'zellij' && zellijPaneLaunchCount === 0 ? ['zellij_pane_launch_evidence_missing'] : []),
         ...(ledger.blockers || []),
         ...(input.partition?.blockers || []),
         ...(input.consensus?.blockers || []),
@@ -293,8 +255,6 @@ export async function writeAgentProofEvidence(root, input) {
         naruto_implementation_like_ratio: Number(narutoRoleDistribution?.implementation_like_ratio || 0),
         naruto_concurrency_governor: narutoConcurrencyGovernor ? 'naruto-concurrency-governor.json' : null,
         naruto_safe_active_workers: Number(narutoConcurrencyGovernor?.safe_active_workers || 0),
-        naruto_safe_zellij_visible_panes: Number(narutoConcurrencyGovernor?.safe_zellij_visible_panes || 0),
-        naruto_headless_workers: Number(narutoConcurrencyGovernor?.headless_workers || 0),
         naruto_active_pool: narutoActivePool ? 'naruto-active-pool.json' : null,
         naruto_active_pool_refill_events: Number(narutoActivePool?.refill_events || 0),
         naruto_verification_dag: narutoVerificationDag ? 'naruto-verification-dag.json' : null,
@@ -329,7 +289,6 @@ export async function writeAgentProofEvidence(root, input) {
         all_generations_closed: generations.ok,
         scheduler_state: 'agent-scheduler-state.json',
         target_active_slots: targetActiveSlots,
-        visual_lane_count: visualLaneCount,
         requested_work_items: requestedWorkItems,
         actual_total_work_items: taskGraphTotalWorkItems || schedulerTotalWorkItems,
         minimum_work_items: minimumWorkItems,
@@ -356,31 +315,8 @@ export async function writeAgentProofEvidence(root, input) {
         work_queue_goal_refs_ok: workQueueGoalRefsOk,
         task_graph_strategy_refs_ok: taskGraphStrategyRefsOk,
         work_queue_strategy_refs_ok: workQueueStrategyRefsOk,
-        zellij_lane_manifest: 'agent-zellij-lanes.json',
-        zellij_lane_manifest_ok: zellijLanes?.ok === true,
-        zellij_lane_supervisor: 'agent-zellij-lane-supervisor.json',
-        lane_supervisor_integrated: laneSupervisorIntegrated,
-        zellij_lane_runtime_manifest: zellijRuntimeManifest ? 'zellij-lane-runtime.json' : null,
-        zellij_spawn_on_demand_supervisor: zellijSpawnOnDemandSupervisor,
-        zellij_lane_runtime_policy_ok: zellijLaneRuntimePolicyOk,
-        zellij_lane_dispatch_mode: laneSupervisor?.dispatch_mode || zellijRuntimeManifest?.dispatch_mode || null,
-        zellij_lane_fifo_policy: laneSupervisor?.fifo_policy || zellijRuntimeManifest?.fifo_policy || null,
-        zellij_lane_resource_throttle_ms: laneSupervisor?.resource_throttle_ms || zellijRuntimeManifest?.resource_throttle_ms || null,
-        zellij_lane_nice_level: laneSupervisor?.nice_level ?? zellijRuntimeManifest?.nice_level ?? null,
-        zellij_lane_pane_id_source_ok: zellijLanePaneIdSourceOk,
-        zellij_lane_no_flicker_verified: laneSupervisor?.no_flicker_verified === true,
-        zellij_lane_survival_checked: laneSupervisor?.pane_survival_checked === true,
-        zellij_lane_unexpected_close_count: laneSupervisor?.unexpected_close_count || 0,
-        zellij_lane_auto_reopen_count: laneSupervisor?.auto_reopen_count || 0,
-        zellij_pane_launch_ledger: 'agent-zellij-pane-launch-ledger.jsonl',
-        zellij_pane_launch_count: zellijPaneLaunchCount,
-        zellij_pane_verified: zellijPaneProof?.ok === true,
-        zellij_pane_proof: 'zellij-pane-proof.json',
-        zellij_pane_count: zellijPaneProof?.pane_count ?? null,
         real_truth_summary: {
             fake_backend: input.backend === 'fake',
-            zellij_pane_verified: zellijPaneProof?.ok === true,
-            real_zellij_status: zellijPaneProof ? (zellijPaneProof.ok === true ? 'passed' : 'blocked') : (input.backend === 'zellij' ? 'missing' : 'not_applicable'),
             cleanup_executor_status: cleanupProof?.ok === true ? 'passed' : cleanupProof ? 'blocked' : 'not_run',
             work_graph_quality_score: Number(intelligentWorkGraph?.work_graph_quality_score || taskGraph?.work_graph_quality_score || 0),
             fake_vs_real_policy: 'fake-real-proof-policy.json'
@@ -421,7 +357,6 @@ export async function writeAgentProofEvidence(root, input) {
         agentRoot: root,
         releaseVersion: PACKAGE_VERSION,
         reports: {
-            'zellij-pane-proof.json': zellijPaneProof,
             'agent-cleanup-proof.json': cleanupProof,
             'agent-intelligent-work-graph.json': intelligentWorkGraph,
             'source-intelligence-evidence.json': input.partition?.source_intelligence_refs,

package/dist/core/agents/agent-recursion-guard.js

@@ -373,7 +373,7 @@ function transcriptGroupForChannel(channel) {
 function isWorkerExecutionSurface(rel, channel) {
     if (channel === 'stdout' || channel === 'stderr' || channel === 'agent_result')
         return true;
-    return /(?:^|\/)agent-worker-pipeline\.(?:ts|mjs|js)$/.test(rel) || /(?:^|\/)agent-runner-(?:process|zellij|ollama)\.(?:ts|mjs|js)$/.test(rel);
+    return /(?:^|\/)agent-worker-pipeline\.(?:ts|mjs|js)$/.test(rel) || /(?:^|\/)agent-runner-(?:process|ollama)\.(?:ts|mjs|js)$/.test(rel);
 }
 function classifyNonRecursivePipelinePath(file) {
     const normalized = normalizePath(file);

package/dist/core/agents/agent-runner-codex-exec.js

@@ -5,6 +5,7 @@ import { agentWorkerEnv, validateAgentWorkerResult } from './agent-worker-pipeli
 import { fastModeEnv, resolveFastModePolicy } from './fast-mode-policy.js';
 import { buildCodexExecArgs } from '../codex/codex-cli-syntax-builder.js';
 import { codexLbRecoveryBlockedProcessResult, withCodexLbCliLaunchRecovery } from '../codex-control/codex-lb-launch-recovery.js';
+import { prepareCodexAppServerRuntimeEnv } from '../codex-control/codex-app-server-runtime-env.js';
 export function buildCodexExecAgentArgs(agent, prompt, opts = {}) {
     const resultFile = opts.resultFile || defaultCodexResultFile(agent, opts);
     const sandbox = opts.workspaceWrite ? 'workspace-write' : 'read-only';
@@ -74,15 +75,16 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
     const allowedCommandsFile = path.join(opts.agentRoot || opts.cwd || process.cwd(), 'agent-allowed-commands.json');
     const workerEnv = agentWorkerEnv(agent, allowedCommandsFile);
     const effectiveEnv = { ...process.env, ...(opts.env || {}) };
-    const proxyEnv = managedProxyEnvForChild(effectiveEnv);
+    const runtimeEnv = await prepareCodexAppServerRuntimeEnv({ env: effectiveEnv });
+    const proxyEnv = managedProxyEnvForChild(runtimeEnv);
     const execute = opts.runProcessImpl || runProcess;
     const guarded = await withCodexLbCliLaunchRecovery({
         root: opts.cwd || process.cwd(),
-        env: effectiveEnv,
+        env: runtimeEnv,
         cliArgs: command.args.slice(0, -1),
         ...(typeof opts.recoveryFetch === 'function' ? { fetchImpl: opts.recoveryFetch } : {}),
         ...(opts.recoveryTimeoutMs === undefined ? {} : { timeoutMs: opts.recoveryTimeoutMs })
-    }, () => execute(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile }));
+    }, () => execute(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...runtimeEnv, ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile }));
     const result = guarded.launched
         ? guarded.value
         : codexLbRecoveryBlockedProcessResult(guarded.toolOutputRecovery);